Skip to content
Crypto.world

Research

ZK Coprocessor Bridge: Replay-Safe Private Execution from Solana to Aztec via Wormhole

Solana is fast and has a mature developer stack, but some applications need private or selectively disclosed computation that is impractical to run on Solana consensus.

ZK Coprocessor Bridge: Replay-Safe Private Execution from Solana to Aztec via Wormhole
arXiv
2510.22536
Published
2025-10-26
Authors
Jotaro Yano

AI summary

Overview

Research area: Cross-chain interoperability and applied cryptography — specifically bridge design combining Solana, Wormhole attestations, an Ethereum (EVM) verification contract, and the Aztec privacy L2.

Technical level: Advanced. The paper is a formal specification (state machines, invariants, lemmas and theorem sketches) rather than an empirical study, though the prose descriptions of the flow are readable for intermediate readers.

Scope: The paper specifies and argues the security of a minimal "ZK coprocessor bridge" that lets Solana programs dispatch private computation to Aztec L2 over Wormhole Verifiable Action Approvals (VAAs), with an EVM Portal enforcing replay locks and parameter binding.

What This Paper Is About

Solana is fast and has a mature developer stack, but some applications need private or selectively disclosed computation that is impractical to run on Solana consensus. Aztec offers a privacy-preserving L2 with succinct rollup proofs, and Wormhole offers cross-chain attestation via VAAs, so the paper asks whether these three systems can be composed so that a Solana program can request private execution on Aztec safely. The goal is a precise, replay-safe design — with explicit message formats, state machines and proof sketches — rather than a new proving system or a new bridge protocol.

Key Contributions

  1. A normative bound-payload interface. The Portal accepts a VAA, parses secretHash || m from the attested payload, derives a domain-separated field commitment c = toField(Keccak-256(dom || m)) on-chain, and enqueues (c, secretHash) to the Aztec Inbox — removing the relayer's ability to choose Aztec parameters.
  2. Small state machines with invariants for the Portal (consumed set of VAA body hashes, configured emitter chain/address, inbox, L2 instance, rollup version) and the Aztec consumer (portalAddr, lastContent, lastLeaf, lastSecret, count), plus Invariant 1 (Portal replay lock) and Invariant 2 (Aztec single consumption).
  3. Proof sketches for seven properties: parameter binding (Lemma 1, Theorem 1), replay-safety (Theorem 2), origin authenticity (Theorem 3), finality alignment (Theorem 4), privacy and commitment integrity (Lemma 2, Lemma 3, Theorem 5), idempotence (Theorem 6), and liveness.
  4. Engineering guidance and a reproducibility note — an implementation mapping table, migration guidance from the legacy consumeWithSecret path, and a pinned public-testnet stack drawn from the open-source repository.

Main Findings

  • Parameter binding is achievable by construction. If the Portal extracts secretHash from the VAA payload and computes c from the same payload, then the enqueued (c, secretHash) pair is a deterministic function of the VAA body; Theorem 1 states a relayer cannot make the Portal enqueue a different pair for the same VAA hash h.
  • Replay safety comes from a consumed-hash set. Invariant 1 (Portal replay lock) makes any second Consume with the same h reject atomically, which yields Theorem 2; Theorem 6 extends this to idempotence by combining the Portal lock with Aztec's single-consumption invariant.
  • Authenticity reduces to signature verification plus an origin check. Because verification succeeds only for correctly signed VAAs and the Portal enforces the configured emitterChainId and emitterAddress, all accepted VAAs are authentic to the designated Solana program (Theorem 3).
  • The shipped v0.1.0 code does not yet meet the bound interface. The repository at v0.1.0 uses consumeWithSecret(vaa, secretHash), and consume(bytes) in v0.1.0 is a compatibility helper with secretHash = 0. The paper states the parameter-binding and anti-front-running guarantees do not hold as stated for this legacy path — a relayer can choose secretHash, which does not break replay or authenticity but can hinder Aztec consumption until corrected.
  • The Solana-side receipt recorder is incomplete in v0.1.0. record_receipt_from_vaa should require: the PostedVAA account owner is Wormhole Core; origEmitterChain and origEmitter match the local allowlist; origSequence matches the PDA key; and version = 1. The paper notes v0.1.0 does not yet do this.
  • Domain separation reduces cross-context ambiguity. dom := Keccak-256("ZKCB/v1" || emitterChainId || emitterAddress || sequence), with 32-byte strings interpreted as big-endian integers before toField into the BN254 scalar field with prime modulus r; the paper also recommends application-level salting for low-entropy payloads.
  • Liveness depends on named assumptions. At least one honest relayer or user submits each available VAA, Aztec eventually includes L1→L2 messages, and transactions are eventually mined on EVM and sequenced on Aztec. Aztec consumption needs a retry loop because membership proofs become valid only after the Inbox leaf is included in a rollup block; the paper says bounded exponential backoff suffices.
  • Cost profile is described qualitatively, not measured. Portal Consume cost is driven by Wormhole verification (approximately linear in guardian signatures), event emission (linear in payload size), and the Aztec Inbox call (constant for a fixed ABI); hashing is linear in |m|. No gas figures, latency numbers, or benchmark results are reported.
  • Positioning is deliberately narrow. The bridge does not verify heavy ZK proofs on Solana L1; it is presented as complementary to Light Protocol's zk-compression, Arcium's off-chain confidentiality, and EVM-side coprocessors such as Succinct, RISC Zero, and Axiom. Proof-system choices (PLONK/Groth16, FRI families) are treated as orthogonal.

Methodology in Plain English

The author takes three existing systems and specifies precisely how they should talk to each other, then argues why the composition is safe. First, a Solana program posts a message through Wormhole's core contract, choosing either Confirmed or Finalized finality, with the payload formatted as secretHash || m. Second, an EVM contract called the Portal checks the VAA's signatures, checks that it came from the configured Solana emitter, and checks that this exact VAA hash has never been seen before — then computes a commitment c from the payload and hands (c, secretHash) to the Aztec Inbox. Third, a minimal Aztec contract called via consume_from_inbox(content_hash, leaf_index, secret) calls consume_l1_to_l2_message(content_hash, secret, sender=portal, leaf_index) and records the last content, leaf index, secret and a counter.

To reason about safety, the author writes down the four domains (Solana program, Wormhole guardians, Ethereum Portal plus Aztec Inbox, Aztec consumer), an adversary who can front-run and reorder public transactions across all chains, and standard cryptographic assumptions (collision- and preimage-resistant Keccak-256, a preimage-resistant H, canonical reduction into the BN254 scalar field). Each security property is then stated as a definition, lemma or theorem over the two state machines. A mapping table connects each formal element to an implementation hook and the delta still required in the code, and a reproducibility section lists pinned tooling and a five-step testnet procedure.

Why This Matters

The paper's value is as a specification pattern: it shows that replay safety, origin authenticity and parameter binding can be obtained at the message layer of a bridge, without verifying heavy proofs at the origin chain. For research, it offers a reusable template — state machines plus invariants plus a normative payload encoding — for reasoning about cross-domain private dispatch, and it is unusually candid about the gap between the formal model and the released v0.1.0 code.

Real-world applications the design pattern enables:

  • Private execution offload: Solana programs that need confidential or selectively disclosed computation can dispatch it to Aztec and receive a receipt, keeping the public chain fast and the sensitive logic elsewhere.
  • Auditable private transactions: because the Portal enqueues a domain-separated commitment c bound to (dom, m) and a secretHash, an on-chain observer sees a commitment while the secret stays hidden, which suits compliance-style selective disclosure.
  • Cross-chain private coordination: sealed-bid auctions, private voting, or private payroll where the trigger lives on Solana but the private state and execution live on Aztec.
  • Receipt-anchored workflows: the optional receipt VAA fields (origEmitterChain, origEmitter, origSequence, c, aztecKey, leafIndex, secretHash, resultHash) let the origin chain record that private work happened, without revealing what it was.

Industry relevance: teams building Solana-to-Ethereum messaging, privacy L2 integration, or any bridge that must resist relayer manipulation can adopt the secretHash || m payload convention, the "ZKCB/v1" domain tag, and the consumed-hash replay lock directly.

Future Directions

  • Migrate off the legacy path. New deployments "SHOULD" adopt payload-bound consume(bytes), parsing secretHash internally and deprecating external secretHash; keeping the legacy path behind a feature flag is suggested, and the correctness delta is stated but not empirically evaluated.
  • Complete the receipt recorder. record_receipt_from_vaa in v0.1.0 lacks the four stated checks (Wormhole Core ownership of the PostedVAA account, allowlist match on the origin pair, PDA-key match on origSequence, and version = 1); implementing and testing these is an open engineering step.
  • Quantify the cost and liveness claims. The paper argues cost qualitatively (verification linear in guardian signatures, events linear in payload size, hashing linear in |m|) and prescribes bounded exponential backoff for Aztec retries, but reports no measurements; empirical gas, latency and retry data would substantiate the operational sections.
  • Stress the trust and DoS assumptions. Guardian set changes and Wormhole finality policy misconfiguration are explicitly out of scope, and malformed-VAA flooding is only argued to short-circuit at bounded EVM cost; formal treatment of these, and of salting for low-entropy m, remain open.

Target Audience

Bridge and protocol engineers integrating Solana, Wormhole and Aztec; security researchers and auditors who need a checklist of invariants (replay lock, single consumption, origin pair, parameter binding) for cross-domain message dispatch; and graduate-level readers in applied cryptography who want a compact worked example of specifying a bridge and sketching its proofs. Readers seeking performance data, deployed-mainnet results, or a novel proof system will not find them here — the contribution is the interface, the state machines, and the proof sketches.

Authors’ abstract

We formalize a cross-domain "ZK coprocessor bridge" that lets Solana programs request private execution on Aztec L2 (via Ethereum) using Wormhole Verifiable Action Approvals (VAAs) as authenticated transport. The system comprises: (i) a Solana program that posts messages to Wormhole Core with explicit finality; (ii) an EVM Portal that verifies VAAs, enforces a replay lock, parses a bound payload secretHash||m from the attested VAA, derives a domain-separated field…

The full abstract on arXiv
Read the original paper