Cross-chain Bridge

Tenzro provides bridge adapters for connecting to multiple blockchains via LI.FI aggregator (58+ chains), LayerZero V2, Chainlink CCIP v1.6, deBridge DLN, and Canton enterprise ledger.

Supported Bridge Adapters

Bridge Router

The BridgeRouter automatically selects the best adapter based on cost, speed, and availability:

use tenzro_bridge::{BridgeRouter, BridgeStrategy};

let router = BridgeRouter::new()?;

// Transfer tokens with automatic adapter selection
let transfer_result = router.transfer(
    "USDC",
    100.0,
    "tenzro1from...xyz",
    "0xto...abc", // Ethereum address
    1, // Ethereum chain ID
    BridgeStrategy::Cost, // Optimize for lowest cost
).await?;

// Strategies:
// - Cost: Minimize fees
// - Speed: Minimize latency
// - Availability: Use most reliable adapter

LayerZero Integration

Send Message

use tenzro_bridge::LayerZeroAdapter;

let lz = LayerZeroAdapter::new(
    "https://layerzero-endpoint.tenzro.network",
    endpoint_contract,
)?;

// Send cross-chain message
let tx_hash = lz.send_message(
    1, // Destination chain ID (Ethereum)
    "0xrecipient...abc",
    payload,
).await?;

// Message automatically routed via LayerZero relayers

Verify Message

// Verify message delivery
let verified = lz.verify_message(
    &message_id,
    &source_chain,
    &proof,
).await?;

if verified {
    println!("Message delivered and verified");
}

Chainlink CCIP Integration

use tenzro_bridge::ChainlinkCcipAdapter;

let ccip = ChainlinkCcipAdapter::new(
    "https://ccip-router.tenzro.network",
    router_contract,
)?;

// Send token transfer via CCIP
let tx_hash = ccip.send_tokens(
    "USDC",
    100.0,
    137, // Polygon chain ID
    "0xrecipient...def",
).await?;

// CCIP provides DON-verified delivery with finality guarantee

deBridge DLN Integration

use tenzro_bridge::DeBridgeAdapter;

let debridge = DeBridgeAdapter::new(
    "https://debridge-api.tenzro.network",
)?;

// Create cross-chain swap order
let order = debridge.create_order(
    "TNZO", // Source token
    "USDC", // Destination token
    100.0,
    1, // Ethereum
    "0xrecipient...ghi",
).await?;

// DLN market makers fill order with best execution

deBridge Hooks (Post-Fulfillment Actions)

deBridge Hooks (2026) allow arbitrary on-chain actions to execute when a cross-chain order is fulfilled on the destination chain. The deBridge API validates, encodes, and simulates the hook before including it in the order.

use tenzro_bridge::debridge::{DeBridgeAdapter, DlnHook};

// Create a hook that stakes tokens on the destination chain after bridging
let hook = DlnHook::new(
    "0xStakingContract...",           // target contract
    "0xa694fc3a000000000000...0001",  // stake() calldata
    true,                              // revert fill if hook fails
);

let order = adapter.create_order_with_hook(
    "ethereum", "arbitrum",
    "0xUSDC...", 1_000_000_000,
    "0xUSDC...", 0,  // auto amount
    "0xmaker...",
    hook,
).await?;

// CLI equivalent:
// tenzro-cli bridge hook --from-chain ethereum --to-chain arbitrum \
//   --token 0xUSDC... --amount 1000000000 --sender 0xmaker... \
//   --hook-target 0xStakingContract... --hook-calldata 0xa694fc3a...

Batch Order Monitoring

Monitor multiple deBridge orders by wallet address using the stats API:

// Query all orders for a wallet (paginated, max 100 per page)
let orders = adapter.get_orders_by_wallet(
    "0xwallet...",
    0,   // skip
    50,  // take
).await?;

// Look up order by creation transaction hash
let order = adapter.get_order_by_creation_tx("0xtxhash...").await?;

Canton/DAML Integration

Canton adapter enables interaction with DAML 3.x enterprise ledgers:

use tenzro_bridge::CantonAdapter;

let canton = CantonAdapter::new(
    "https://canton-node.enterprise.network",
    participant_id,
)?;

// Submit DAML command to Canton
let tx_id = canton.submit_daml_command(
    DamlCommand::Create {
        template_id: "Finance.Settlement:SettlementInstruction",
        arguments: daml_record,
    },
).await?;

// Query DAML contracts
let contracts = canton.query_contracts(
    "Finance.Settlement:SettlementInstruction",
    filter,
).await?;

Message Signing & Verification

All bridge messages support cryptographic signing and verification using Ed25519 or Secp256k1 keys from tenzro-crypto:

use tenzro_bridge::TenzroMessage;
use tenzro_crypto::KeyPair;

// Create a bridge message
let mut message = TenzroMessage::new(
    source_chain,
    dest_chain,
    payload,
);

// Sign with Ed25519 or Secp256k1 keypair
let keypair = KeyPair::generate_ed25519()?;
message.sign(keypair)?;

// Verify signature (e.g., on the receiving end)
let is_valid = message.verify_signature()?;
assert!(is_valid);

// Messages without signatures or with forged signatures
// are rejected by verify_signature()

Transfer Flow

Fee Estimation

// Estimate bridge fees for all adapters
let estimates = router.estimate_fees(
    "USDC",
    100.0,
    1, // Ethereum
).await?;

for estimate in estimates {
    println!("Adapter: {:?}", estimate.adapter);
    println!("Fee: {} TNZO", estimate.fee);
    println!("Estimated time: {}s", estimate.estimated_time);
}

// Select cheapest
let best = router.select_adapter(
    estimates,
    BridgeStrategy::Cost,
)?;

Replay Protection

Bridge router includes replay protection to prevent duplicate transfers:

// Each transfer gets unique ID based on:
// - Source chain
// - Destination chain
// - Asset
// - Amount
// - Sender
// - Nonce (incremented per sender)

let transfer_id = hash(
    source_chain,
    dest_chain,
    asset,
    amount,
    sender,
    nonce,
);

// Duplicate transfer with same ID rejected

Monitoring Transfer Status

// Track transfer status
let status = router.get_transfer_status(&transfer_id).await?;

match status {
    TransferStatus::Pending => {
        println!("Transfer initiated, awaiting relay");
    }
    TransferStatus::Relayed => {
        println!("Message relayed to destination");
    }
    TransferStatus::Delivered => {
        println!("Tokens delivered on destination chain");
        println!("Destination tx: {}", status.dest_tx_hash);
    }
    TransferStatus::Failed => {
        println!("Transfer failed: {}", status.error);
    }
}

ERC-7802 Cross-chain Token Standard

Tenzro supports ERC-7802 (SuperchainERC20) for standardized cross-chain token supply management. ERC-7802 defines crosschainMint and crosschainBurn functions that allow authorized bridge contracts to mint tokens on the destination chain and burn them on the source chain, ensuring consistent total supply across all connected networks.

Combined with the Sei V2 pointer model used internally by Tenzro, this creates a unified token layer that spans both cross-VM environments (EVM, SVM, Canton) and external chains. Native TNZO balances are shared across all VMs via pointer contracts, while ERC-7802 handles supply coordination with external chains like Ethereum and Optimism.

SDK Usage

// Mint TNZO on a destination chain via ERC-7802
const tx = await client.erc7802().crosschainMint(
    "TNZO",
    "0xRecipientAddress",
    "1000000000000000000", // 1 TNZO (18 decimals)
    "ethereum",
);

// Burn TNZO on the source chain
const burnTx = await client.erc7802().crosschainBurn(
    "TNZO",
    "1000000000000000000",
    "ethereum",
);

See the Cross-VM Tokens documentation for details on how the Sei V2 pointer model and ERC-7802 work together to provide a unified token layer.

Supported Chains

CLI Usage

# Bridge USDC to Ethereum
tenzro-cli bridge transfer \
  --asset USDC \
  --amount 100 \
  --to 0xrecipient...abc \
  --chain ethereum \
  --strategy cost

# Check transfer status
tenzro-cli bridge status --transfer-id 0x123...

# List supported chains
tenzro-cli bridge chains