Cross-chain Bridge
Tenzro provides bridge adapters for connecting to multiple blockchains via LayerZero V2, Chainlink CCIP, deBridge DLN, and Canton enterprise ledger.
Supported Bridge Adapters
LayerZero V2
Omnichain messaging protocol for arbitrary cross-chain message passing.
Use cases: Token transfers, contract calls, state sync
Chainlink CCIP
Cross-Chain Interoperability Protocol with DON-verified messaging and token transfers.
Use cases: High-value transfers, oracle-verified settlements
deBridge DLN
Debridge Liquidity Network for intent-based cross-chain swaps.
Use cases: Fast token swaps, MEV-resistant transfers
Canton Adapter
DAML 3.x enterprise ledger integration for permissioned chains.
Use cases: Enterprise settlement, DAML contract execution
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
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
- Lock — User locks tokens on source chain (Tenzro)
- Message — Bridge adapter sends cross-chain message
- Relay — Relayers/validators relay message to destination
- Verify — Destination chain verifies message proof
- Mint — Wrapped tokens minted on destination chain
- Receipt — Transfer receipt returned to user
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);
}
}
Supported Chains
| Chain | Chain ID |
|---|---|
| Ethereum | 1 |
| Polygon | 137 |
| Arbitrum | 42161 |
| Optimism | 10 |
| Solana | N/A |
| Canton | N/A |
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