Secure Cross-Chain Bridge Architect

Cross-Chain Bridge Expert is a skill for architecting, implementing, and securing bridges that transfer assets and data between different blockchain networks, covering the tradeoffs between bridging approaches and the security practices bridges need.

It covers the two core bridge architectures: lock-and-mint, where assets are locked on the source chain and an equivalent wrapped token is minted on the destination chain once validator signatures confirm the lock, and burn-and-release, the reverse flow that burns the wrapped token and releases the original asset back on its home chain. For security it details multisig validator consensus (a configurable signature threshold checked against a registered, staked validator set), Merkle-proof verification for light-client-based bridges (checking a transaction leaf against a stored block header root), rate limiting and circuit breakers (daily and hourly volume caps plus a guardian-controlled emergency pause), and oracle-secured bridging that checks a token's current price against an expected price and rejects transfers with excessive slippage. It also covers a generic cross-chain message bridge for passing arbitrary calldata (not just token transfers) between chains, tracking a nonce and a hash of already-executed messages to prevent replay.

Use it when designing or reviewing a bridge that needs concrete security patterns - multisig thresholds, rate limits, Merkle proofs, or price-deviation checks - rather than a bespoke, unaudited transfer mechanism. It is not a substitute for a full security audit or formal verification, both of which the skill's own best practices explicitly call for on critical bridge components; the patterns here are architecture and implementation guidance, not a certification.

Input is the bridge's requirements: the source/destination chains, the transfer or messaging pattern needed, and the trust model (validator multisig vs. light-client proofs vs. oracle-checked pricing). Output is Solidity contract patterns for each of these - lock/mint and burn/release contracts, a validator-signature verification contract, a Merkle-proof verification contract, a rate-limited and pausable bridge contract, an oracle-secured bridge contract, and a generic message bridge - plus a test pattern for verifying the lock-and-mint flow end-to-end:

// Example test for bridge functionality
describe("CrossChainBridge", function() {
    it("should handle lock and mint flow", async function() {
        const amount = ethers.utils.parseEther("100");
        
        // Lock tokens on source chain
        await sourceBridge.lockTokens(amount, DEST_CHAIN_ID);
        
        // Generate validator signatures
        const message = ethers.utils.solidityKeccak256(
            ["address", "uint256", "bytes32"],
            [user.address, amount, lockTxHash]
        );
        
        const signatures = await generateValidatorSignatures(message);
        
        // Mint on destination chain
        await destBridge.mintTokens(user.address, amount, lockTxHash, signatures);
        
        expect(await wrappedToken.balanceOf(user.address)).to.equal(amount);
    });
});

The patterns are written in Solidity, using keccak256/ECDSA.recover for signature verification, OpenZeppelin's MerkleProof.verify for light-client proofs, and an IPriceFeed oracle interface for price checks; the test example runs on ethers.js.

Smart contract engineers and security reviewers designing or auditing cross-chain bridges who need concrete patterns for validator consensus, Merkle-proof verification, rate limiting, price-deviation protection, and cross-chain messaging - and who follow up with real security audits, timelocked upgrades, validator slashing, and incident-response procedures, as the skill's own best practices recommend.