ZK Rollup

DUAL's zero-knowledge proof layer enables scalable, private, and verifiable state transitions. By bundling thousands of tokenization actions into a single cryptographic proof, ZK Rollup achieves enterprise-grade throughput while maintaining complete on-chain verifiability and data availability.

Why Zero-Knowledge Proofs Matter

Zero-knowledge proofs give DUAL three superpowers: the ability to verify massive batches of transactions without replaying them on-chain (scalability), cryptographic assurance that state transitions are valid without exposing intermediate details (privacy), and mathematical certainty that the entire rollup history is consistent.

For enterprises and asset issuers, this translates to economic sustainability: DUAL can process thousands of tokenization actions, compliance checks, and settlements for the cost of a handful of Ethereum transactions. The rollup's capacity scales to meet demand while maintaining a nearly constant, negligible per-action cost.

Architecture Overview

DUAL's ZK Rollup executes a four-stage pipeline to produce a single proof that can verify thousands of state transitions:

How Zero-Knowledge Proofs Work

The Core Idea: Imagine proving that you know the answer to a puzzle without actually revealing the answer. A zero-knowledge proof is a cryptographic method to do exactly that—convince someone of a fact's truth without divulging the fact itself.

Proof System Design

Proof Scheme: ZK-SNARK

DUAL uses a Succinct Non-interactive Argument of Knowledge (ZK-SNARK). This means:

• Succinct: The proof is tiny (~200 bytes), regardless of batch size.
• Non-interactive: No back-and-forth between prover and verifier.
• Argument of Knowledge: Computationally infeasible to forge a false proof.

Circuit Design

The ZK circuit encodes the DUAL state transition rules. It validates:

Key Technical Parameters

State Management

State Tree: Sparse Merkle Tree

DUAL represents all platform state (objects, wallets, ownership records, token balances) as leaves in a sparse Merkle tree. Each leaf corresponds to a unique entity on the platform. The root of this tree is a single 256-bit hash that cryptographically commits to the entire state.

State Diff: What Changes

Instead of updating every leaf in the tree with each batch, DUAL only tracks the leaves that have changed. The state diff includes:

State Root: The Commitment

The state root is the Merkle root of the entire sparse tree. It's a 256-bit value that uniquely identifies the platform state at a given moment. Every action changes the state root.

Chaining State Roots

Each ZK proof validates a state transition from state_root_N to state_root_N+1. Because each proof commits to both roots, the entire rollup history forms an immutable chain. Any attempt to rewrite history would require forging a proof, which is cryptographically infeasible.

Rollup Economics

The economic case for ZK Rollup is compelling for asset issuers and enterprises. Here's how costs compare:

Revenue Model Implications

With on-chain costs reduced to nearly zero, DUAL can:

• Monetize selectively: Charge market-rate fees only on premium features, without passing along on-chain infrastructure costs.
• Achieve unit economics: Even at modest per-action fees ($0.001–$0.01), DUAL is highly profitable at scale.
• Compete on efficiency: Offer costs 100–1000x lower than traditional asset issuance infrastructure.
• Support high-volume use cases: Compliance engines, atomic swaps, and complex settlement workflows become economically viable.

Developer Integration

API Endpoints

DUAL exposes endpoints to query state and proofs:

{
  "stateRoot": "0x1f2a...",
  "checkpointId": 42,
  "timestamp": 1710618000,
  "blockNumber": 19402410
}

{
  "checkpointId": 42,
  "stateRootBefore": "0x1e9b...",
  "stateRootAfter": "0x1f2a...",
  "proof": "0x1a2b3c...",
  "proofSize": 200,
  "actionCount": 5243,
  "timestamp": 1710618000
}

Proof Verification

Developers and auditors can independently verify a proof. Here's a code sample:

// Pseudo-code: Independent proof verification

const stateRootBefore = "0x1e9b...";
const stateRootAfter = "0x1f2a...";
const proof = "0x1a2b3c...";

// Verify the proof using the on-chain verifier contract
const isValid = await verifierContract.verify(
  proof,
  stateRootBefore,
  stateRootAfter
);

if (isValid) {
  console.log("✓ Proof is valid");
  console.log("✓ State transition is correct");
  console.log("✓ All actions were valid");
} else {
  console.log("✗ Proof verification failed");
  console.log("✗ Something went wrong");
}

On-Chain Contract Addresses

Contract addresses are placeholders. Check the deployment docs for current mainnet and testnet addresses.

Security Model