Boundless Cross-Chain

Standalone repository for the on-chain and relay-side primitives behind Boundless cross-chain verification, starting with Boundless-DVN: the packaged LayerZero integration that adds a ZK-backed verification layer to existing OFT routes.

Live beta site: https://boundless-cross-chain-boundless-network.vercel.app/

Warning

Beta status only. Live end-to-end LayerZero beta on Sepolia <-> Base Sepolia. Not ready for production use yet. The public corridor currently uses the deploy-time owner fallback, which can be permanently disabled later but not re-enabled. The proof-backed attest() entrypoint is on-chain, but this repo does not yet ship the full source-attestation builder and guest pipeline needed to drive that path end-to-end.

What This Repo Contains

This repo is just the codebase and the minimal docs needed to understand it.

• contracts/: BoundlessDVN, SignalProofVerifier, the reference OFT, tests, and Foundry scripts for deploy/configure/deliver flows
• adapter/: the off-chain service that watches assignJob, requests proofs, and submits attestations back on-chain
• website/: legacy demo site kept for reference; not the canonical public website
• scripts/: helper scripts for local fork testing

Codebase Flow

source OApp
contracts/src/ReferenceOFT.sol
    |
    v
LayerZero SendLib
assignJob()
    |
    v
BoundlessDVN
contracts/src/BoundlessDVN.sol
    |
    +--> JobAssigned event ----------------------------+
    |                                                  |
    v                                                  v
ReceiveUln302.verify()                         adapter/src/index.ts
    |                                                  |
    v                                                  v
destination OApp                                 Signal / Helios / Steel-style
lzReceive()                                      source verification path
                                                       |
                                                       v
                                                Boundless marketplace
                                                proof fulfillment
                                                       |
                                                       v
                                                BoundlessDVN.attest()

The repo's packaged integration is LayerZero today, but the product thesis is broader. The same source-proof plus destination-verifier pattern can expand corridor by corridor across EVM routes and adapt to other bridge integrations.

Why This Is Useful

The point of this repo is not just to show that a ZK proof exists. It shows a repeatable cross-chain verification pattern, packaged for LayerZero today:

• keep the existing bridge and verifier path in place
• add Boundless as a ZK-backed verification layer on supported routes
• choose proof depth that matches the value at risk
• adapt the same source-proof plus destination-verifier model to additional LayerZero routes and, over time, other bridge providers

Quick Start

1. Bootstrap the repo

Copy the example environment file and fill in the values you need:

cp .env.example .env

Install the Solidity and TypeScript dependencies:

make bootstrap

2. Validate the repo

Run the main checks:

make check

This runs:

• forge build in contracts/
• bun run typecheck in adapter/
• bun run typecheck in website/

3. Run the legacy demo site (optional)

make website-dev

Open http://localhost:3000.

4. Run the adapter

cd adapter
bun run start

Start Reading Here

If you are evaluating the system, start with:

1. contracts/src/BoundlessDVN.sol
2. contracts/script/SetDVNConfig.s.sol
3. adapter/src/index.ts
4. website/app/page.tsx