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

Crypto.world

> 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.

**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](https://arxiv.org/abs/2510.22536)

[Read the original paper](https://arxiv.org/abs/2510.22536)

---

Canonical: https://crypto.world/paper/zk-coprocessor-bridge-replay-safe-private-execution-from-solana-to-2510.22536
