Rethinking Blockchain Infrastructure

Lyquor is a decentralized platform for off-chain ready smart contracts, hosted with choice. It unifies on-chain and off-chain logic through a single programming model, powered by:

• Smart coordination between nodes for selective hosting,
• Seamless state preservation across executions without overhead, and
• Aggregation-style composability of off-chain computation.

DeFi reveals the architectural limits of today's blockchains. To improve pricing and performance, and to reduce MEV, protocols like UniswapX and CoWSwap increasingly rely on off-chain solvers and wallet-side routing to match trades based on user intents, moving execution logic outside the contract. Others, like Hyperliquid, deploy custom chains to gain speed and predictability, at the cost of fragmentation. These trends highlight a growing need for dedicated execution environments tailored to each service, yet without giving up composability or scalability. Lyquor addresses this need by enabling Selective Hosting and off-chain capable contracts, allowing services to scale independently while staying integrated within a unified system for liquidity and coordination.

The same limitations appear in emerging sectors outside finance. Recent experiments in "AI+Crypto", SocialFi, GameFi categories aim to combine decentralized infrastructure with application logic. While directionally promising, their approach suffers from a critical flaw. Only the underlying data is verified on chain, while the interpretation of that data, the logic that powers services and drives key decisions, is carried out off-chain in a centralized and opaque way.

This is not about moving all computation back on chain. In most existing designs, the parts of the system that actually determine user outcomes, such as rankings, payouts, GPU orchestration or game cluster management, could be made directly driven by on-chain contracts. Other application-specific components could have been designed more deliberately to make off-chain computation verifiable. But they are often not engineered that way, due to the lack of a unified and flexible framework. The result is an illusion of decentralization, where tokens are issued with value not directly tied to the approach.

What is needed instead is a rethinking of blockchain architecture itself:

• Off-chain behavior should be seamlessly driven by on-chain state.
• Off-chain execution should be secure and resilient, even if it does not run on chain.
• We should eliminate the gap between on-chain and off-chain, both in performance and in usability.

While powerful for verifying a fixed sequence of operations, Zero Knowledge proofs are fundamentally designed to optimize replication, not collaboration. They allow one party to perform a computation and others to verify it without repeating the work. But they cannot address the broader challenge of distributed execution, where specialized nodes contribute different parts of a computation over a final result. A complete system should enable both replication and collaboration.

Therefore, Lyquor is designed from the ground up to meet these needs.

Fate-Constrained Ordering (FCO) allows nodes to host contracts selectively without losing Layer-1 grade composability, enabling flexible off-chain use cases.

Direct Memory Architecture (DMA) eliminates the gap between on-chain and off-chain execution, enabling fast, seamless computation across both domains.

Universal Procedure Call (UPC) extends composability beyond replication (on-chain), enabling collaboration across independently hosted services (off-chain).

Together, these innovations form the foundation for a service-native decentralized infrastructure, built to move beyond the limits of traditional blockchains.

While the idea of decentralization may not matter to every end user, the outcomes it enables do. Open systems offer better pricing, broader choice, and more self-service experiences. The same applies to cloud services: a new generation of automated, self-governed, easily deployable infrastructure is needed, one that reduces friction without reintroducing central points of control.

From Chains to Services

Traditional blockchains, whether Layer-1, Layer-2, or Data Availability Layer, are built around the same core assumption: nodes run chains, and every node is expected to execute every transaction for every contract.

This model is increasingly unsustainable because:

• Nodes are forced to carry unrelated workloads.
• Gas pricing becomes over-conservative, driven by worst-case assumptions, since every node must execute every transaction for every contract.
• Developers and node operators remain decoupled, with no direct incentive loop between service quality and infrastructure support.
• Attempts at scaling through subnets, parachains, or chain sharding often introduce fragmentation, sacrificing global composability for throughput.

Lyquor introduces a new foundation: the Service-Centric model.

In this model, nodes no longer run chains, they run services. Execution happens per service, not per chain. Each service maintains its own structured, persistent state and can incorporate off-chain logic natively.

We call these services Lyquids: unified, off-chain capable smart contracts written using a lightweight Rust-based programming model. Developers write logic in idiomatic Rust, enriched with simple macros for declaring state and defining callable functions. There is no new language to learn, just durable, composable services built for decentralized hosting.

Unlike other Rust-based (WASM) smart contract frameworks, Lyquid is not more complex than Solidity. It's often simpler. The abstractions closely mirror what developers are already used to, but without the boilerplate or manual storage management. Common patterns like value transfer and information mapping are just as concise in Lyquid, while enabling zero-overhead state access and powerful off-chain logic. Lyquids also integrate seamlessly with the Ethereum API, allowing users to interact with them using existing Ethereum tooling for both on-chain and off-chain computation.

This service-native model enables a more efficient, modular, and incentive-aligned infrastructure, where nodes and services can form a healthy computation market without sacrificing composability or scalability.

Selective Hosting with Composability

In Lyquor, nodes can choose which Lyquids to host. This alone unlocks a new execution economy:

• Nodes run only the workloads that matter to them.
• Lyquids can offer custom incentives to attract nodes with specialized infrastructure (e.g., GPU, storage, low-latency compute).
• Developers are no longer confined to one-size-fits-all fee models. They can build custom billing or credit logic.

This creates an organic, market-driven ecosystem:

• High-quality services grow stronger, attracting more nodes.
• Low-quality or toy Lyquids naturally fade. No protocol-level curation needed.

For example, a Lyquid offering AI inference might only be viable on GPU-enabled nodes, and another Lyquid may only be hosted by a group of nodes capable of ZK proof generation. With Lyquor, this works natively. Those nodes can join the "virtual cluster" to host that Lyquid without burdening others, and the Lyquid can reward them accordingly.

But this flexibility raises a fundamental question: how can composability be preserved without requiring every node to replicate every service's state, as in a monolithic Layer-1?

Most scalability solutions, such as subnets and sharding, solve this by partitioning the system. In doing so, they compromise the ability to coordinate atomically across services, and fragment the unified execution environment that platforms like Ethereum provide.

Lyquor avoids this tradeoff through Fate-Constrained Ordering (FCO). FCO decouples execution from ordering by establishing a global causal order of contract calls before any execution takes place. The ordering described here applies to the globally consistent portion of execution. The other form, off-chain logic, is handled differently and discussed in a later section. This sealed timeline is produced efficiently through a lightweight sequencing layer, and every node, even if executing only a partial view, must respect the same global fate. In effect, the system's fate is already written, like a play script. Each node is an actor, not improvising. Instead, it unravels its part of the story as written. Its role is progressively discovered from the globally sequenced timeline.

The result is a platform that retains the determinism and global integrity of a monolithic Layer-1, while enabling modular, service-centric execution. With FCO, composability scales without requiring full replication.

This stands in contrast to how sequencing works in typical Layer-2 systems:

• In a Layer-2, the sequencer batches transactions off-chain, executes them locally, and then eventually pushes the results back to the Layer-1 chain for settlement.
• A Layer-2 is still fundamentally chain-centric. The execution is a temporary staging phase, but the main battlefield remains the Layer-1 chain where liquidity lives, and where finality must be posted.
• Unlike a Layer-2, where global ordering is composed at settlement, Lyquor determines the causal order up front. Nodes simply follow the parts relevant to them rather than inventing the story as they go.
• Lyquor's sequencing is akin to shared rollup sequencing, in that it establishes a global ordering across autonomous chains, though in Lyquor, this applies to Lyquids rather than chains. Lyquids are not Layer-2 chains. They do not settle on a Layer-1. They settle independently.

Lyquor's sequencer is not a staging layer for another chain. It is a coordination fabric for service-centric execution. The sequencer does not execute transactions; it only enforces global order across Lyquid calls, ensuring that composability is preserved even when execution is modular and decentralized.

While Lyquor does have a chain, it is not responsible for performing the computation. It writes the script, but does not act it out. This change in architecture does not sacrifice the guarantees of a Layer-1. With FCO, Lyquor uses an existing consensus protocol to provide the global consistency and neutrality expected from a Layer-1, without inheriting its architectural constraints.

This enables seamless coordination across services without bridges or loss of atomicity, and allows parallel execution when Lyquids operate independently. As a result, composability scales without the burden of full replication.

Organic Growth from Base Availability

To ensure every Lyquid service has a fair and smooth start, Lyquor introduces Archival Nodes, a decentralized set of nodes that replicate the network state for all Lyquids. These nodes provide baseline on-chain data availability and guaranteed onboarding for new services.

Archival nodes run the same Lyquor program but operate in an inclusive mode. They are not required to host the off-chain part of each Lyquid, which makes them lightweight and broadly compatible. They also do not need per-Lyquid specialized hardware or capabilities required by off-chain computation.

Importantly, archival nodes form only a small subset of the network to bootstrap a Lyquid. The majority of Lyquor nodes participate selectively, hosting only the Lyquids they choose based on utility, performance, or economic incentives. This forms a market-driven execution landscape where hosting naturally concentrates around useful services, and underutilized ones fade without needing protocol-level intervention.

While archival nodes ensure onboarding and state completeness, they also play a critical role in supporting FCO. By maintaining access to global side effects, they allow composable contract behavior even when execution is distributed across selectively hosted nodes.

Fearless Off-chain, Serverless Computation

While most platforms treat off-chain logic as an afterthought, Lyquor makes it a first-class citizen. In traditional systems, off-chain tasks often rely on external availability layers, intermediate indexing services, or centralized infrastructure. This introduces latency, increases system complexity, and creates new trust boundaries. Worse, off-chain code typically loses the simplicity that makes smart contracts appealing in the first place. Developers value smart contracts because they are like FaaS, but without hassle in data preservation. That same convenience has rarely been available for fast, off-chain workloads.

Lyquor changes that. With Direct Memory Architecture (DMA), off-chain logic runs against the same structured state as on-chain execution: no schema design, no database plumbing. Developers simply write stateful logic, without infrastructure baggage. This combines the best of both worlds: the low-friction experience of smart contracts with the speed and flexibility of serverless functions.

While selective hosting in Lyquor elegantly resolves the longstanding tradeoff between scalability and composability faced by traditional Layer-1/2 platforms, its original motivation was even deeper: enabling seamless and resilient off-chain computation. Off-chain workloads vary widely in hardware requirements and performance characteristics, and differ fundamentally from on-chain computation where nodes must replicate the same execution. In contrast, off-chain tasks often involve different nodes performing different portions of a larger computation by specialization.

Without selective hosting, every node would be forced to carry the on-chain state of every contract, including those irrelevant to its off-chain responsibilities. This creates unnecessary deployment barriers and breaks the seamless flow between on-chain and off-chain logic. As a result, most existing off-chain systems rely on trusted Data Availability layers to fetch inputs. The actual computation is often performed by centralized, one-off implementations, typically written without a common framework. Unlike on-chain contracts, these off-chain components lack standardization, code validation, and result resilience, which makes them difficult to trust, scale, or generalize across applications.

In addition to accessing on-chain data, off-chain logic in Lyquor can also collaborate across nodes in a programmable way. This is enabled by Lyquor's Universal Procedure Call (UPC), a multicast function call that allows a Lyquid service to invoke custom logic on multiple nodes concurrently. Each node can perform part of the task or act in specialized roles. Results are then aggregated or reconciled by the caller in real time. This model supports resilient coordination across untrusted infrastructure without sacrificing performance.

Lightweight Execution, Cloud-Like Economics

Because Lyquid execution is powered by DMA, on-chain calls are fast, lightweight, and direct: with no serialization, no object decoding, and no key hashing. The result is a snappier execution layer with minimal runtime overhead.

Crucially, this means on-chain execution now costs as little as off-chain logic, closing the historical gap that made blockchain compute expensive and over-metered. In Lyquid, both on-chain and off-chain logic share the same execution engine and data model. The only distinction is that on-chain execution is triggered by events sequenced on the chain. With this symmetry, it becomes possible to rethink not just performance, but also how computation is priced.

Instead of relying on fine-grained gas metering, Lyquor could adopt a simpler model:

• Each call is bounded by a maximum gas limit (set generously, thanks to DMA's efficiency).
• Actual fees could be application-defined. Developers may implement their own pricing logic inside their Lyquid.

This mirrors the economics of cloud services, where users are billed per API call rather than per CPU instruction. Nodes, in turn, decide whether a service is worth running based on real economic value, not just technical cost.

While this fee model remains open to future refinement, it introduces exciting possibilities:

• No overpricing for simple logic.
• No forced duplication of execution.
• Less protocol-imposed friction, more developer-driven pricing flexibility.

As the Lyquor ecosystem matures, this model can evolve naturally, blending performance efficiency with economic simplicity, and giving developers more control over how their services are accessed and monetized.

To summarize, Lyquor isn't a Layer-1 or a Layer-2. It's a platform rethinking the blockchain infrastructure model entirely:

• Nodes run services, not chains.
• Execution is modular and selective.
• Composability is preserved via global sequencing.
• Off-chain logic becomes the first-class citizen with the same model.
• Developers control economics, not just logic.
• Scalability emerges organically, service by service.

This is not just a new contract framework. It's what a cloud-native, service-aligned decentralized compute network should look like.