Design Principles
Liminal is built around a small set of strict design principles. These principles intentionally limit flexibility at the deployment layer in order to maximize predictability, safety, and scalability.
Determinism
Determinism is the foundation of Liminal.
Given the same SPL mint address, Liminal must always derive the same cross-chain identity and deploy the same ERC-20 representation on Base. This process is purely functional: the output depends only on the input and never on mutable state, environment-specific configuration, or off-chain coordination.
No manual mapping, registration, or governance action is required to associate an SPL token with its ERC-20 twin. This removes ambiguity and ensures that deployment outcomes are repeatable and verifiable by anyone. Determinism also enables idempotency: repeated deployment attempts either converge to the same result or are safely rejected.
Without determinism, cross-chain deployment becomes a coordination problem. With determinism, it becomes a computation.
Standardization
Liminal prioritizes standardization over flexibility.
All tokens follow the exact same deployment rules. The deployment layer does not support token-specific customization, conditional logic, or special cases. While this may appear restrictive, it is what allows Liminal to scale safely and predictably.
Custom deployment logic introduces hidden assumptions, increases surface area for bugs, and makes integrations harder to reason about. By enforcing a single standard deployment flow, Liminal ensures that tooling, interfaces, and downstream integrations can rely on consistent behavior across all tokens.
Standardization turns cross-chain deployment from an artisanal process into infrastructure.
Chain-Native Assets
Liminal does not create synthetic or wrapped assets.
SPL tokens remain native SPL assets on Solana, governed entirely by Solana’s token program semantics. ERC-20 tokens deployed on Base are native ERC-20 contracts that integrate seamlessly with existing EVM tooling.
There is no escrow contract holding underlying assets, no wrapper logic, and no proxy pattern introduced at the deployment layer. Liminal defines representations, not custody.
By preserving native asset semantics on each chain, Liminal minimizes trust assumptions and avoids introducing new security or liquidity risks.
Persona Abstraction
Liminal separates infrastructure from interface.
The core deployer logic is identical for all users. Whether the user is a creator deploying a token, a developer integrating deployment into a pipeline, or an end user interacting through a UI, the underlying deployment semantics do not change.
Only the interface layer adapts to different personas. This ensures that the system remains internally consistent while still being accessible to a wide range of users.
Persona abstraction prevents fragmentation at the infrastructure level and allows Liminal to support multiple user types without compromising determinism or standardization.
Last updated