Why Banks Must Build, Not Just Bridge, to DeFi

Relying on third-party bridges like LayerZero or Across cedes control, introduces systemic risk, and imposes a permanent fee structure. You're renting, not owning, the critical rail.

• Revenue Leakage: Paying ~10-50 bps per transaction to external liquidity providers.
• Settlement Risk: Exposure to bridge hacks, which have drained >$2.5B.
• Vendor Lock-in: Your customer flow is dependent on a third party's uptime and economics.

Build your own application-specific chain or sovereign rollup (using Celestia, EigenLayer, Arbitrum Orbit). This captures the full stack, from transaction fees to MEV.

• Fee Capture: Retain 100% of sequencer fees and influence over block ordering.
• Regulatory Moat: Enforce KYC/AML at the protocol level, creating compliant DeFi.
• Performance Sovereignty: Guarantee ~2s finality and customize gas economics for your clients.

Trading via DEX aggregators like 1inch or intent-based systems like Uniswap X means you're blindly trusting anonymous liquidity pools. You have no insight into the capital or compliance status of your counterparty.

• Capital Inefficiency: Must over-collateralize positions due to unknown risk profiles.
• Compliance Black Box: Impossible to prove trade counterparties aren't sanctioned entities.
• Slippage from Anonymity: Lack of trusted relationships forces reliance on volatile, impersonal AMM pools.

Deploy a private, institutional-grade AMM or order book (e.g., leveraging Circle's CCTP for mint/burn) where liquidity is provided by vetted entities. This recreates prime brokerage on-chain.

• Risk-Weighted Capital: Apply Basel-like frameworks to on-chain credit lines and collateral.
• Auditable Compliance: Every transaction and counterparty is KYC'd, creating an immutable audit trail.
• Tighter Spreads: Direct trading between known entities reduces spreads by ~30-70% versus public pools.

Bridging legacy core banking systems (think SWIFT, ACH) to blockchain via APIs creates a fragile, point-to-point integration hell. It's a cost center that fails at scale.

• Latency Mismatch: ~2-day settlement cycles forced to interact with ~2-second block times.
• Spaghetti Architecture: Each new chain or protocol requires a new, brittle connector.
• No Composability: Bridged assets are siloed and cannot natively interact with DeFi smart contracts.

Re-platform the core ledger of record onto a dedicated chain. Treat blockchain as the single source of truth, not an appendage. This is what JPMorgan Onyx and ANZ Bank are pioneering.

• Atomic Settlement: Eliminate reconciliation with single-ledger truth across all assets.
• Programmable Money: Embed regulatory logic and business rules directly into the asset (via token extensions).
• Future-Proof Stack: New applications plug into the core ledger, turning tech debt into a revenue-generating platform.

Bridging corporate cash to earn yield on Compound or Aave introduces settlement and custodial risk. The solution is a native, compliant issuance layer.

• Direct Issuance: Mint permissioned, regulatory-grade stablecoins (e.g., JPYz) on a private ledger.
• Atomic Settlement: Enable instant, final cross-border payments without correspondent banking layers.
• Audit Trail: Every transaction is programmatically compliant, reducing KYC/AML overhead by ~70%.

Aggregating across Uniswap, Curve, and Balancer via bridges exposes banks to MEV and slippage. The solution is a dedicated institutional AMM.

• Concentrated Liquidity: Deploy capital with 10-100x higher capital efficiency than public pools.
• MEV Protection: Use private mempools and intent-based routing (like CowSwap) to eliminate front-running.
• Regulatory Perimeter: Operate within a sanctioned environment, whitelisting counterparties and assets.

Banks cannot replace core banking systems overnight. The solution is a modular middleware layer that abstracts blockchain complexity.

• API-First Gateway: Expose simple REST APIs for balance checks and payments, masking underlying EVM or Cosmos SDK chains.
• Unified Ledger: Create a single source of truth reconciling on-chain and off-chain assets in real-time.
• Modular Compliance: Plug in identity providers (KYC) and transaction monitoring tools as independent modules.

Tokenizing private equity or bonds on public chains like Ethereum leaks sensitive data. The solution is a purpose-built, institutional L2.

• ZK-Proof Privacy: Use zk-SNARKs (like Aztec) to validate transactions without revealing counterparties or amounts.
• Institutional Validator Set: A permissioned set of regulated nodes (banks, auditors) achieves ~500ms finality.
• Regulatory Node: Grant read-only access to supervisors for real-time oversight, a feature impossible on public DeFi.

Relying on LayerZero or Axelar for interoperability hands control to external protocols. The solution is a native interbank clearing chain.

• Sovereign Bridge: Operate a validated, bi-directional bridge between institutional chains, eliminating third-party risk.
• Atomic Cross-Chain Swaps: Execute forex or securities trades across ledgers with Hash Time-Locked Contracts (HTLCs).
• Shared Security: Use a proof-of-stake model where stake is held by member institutions, aligning economic incentives.

Deploying unaudited code on public EVM chains exposes banks to catastrophic bugs. The solution is a formally verified execution environment.

• Domain-Specific Language (DSL): Use a financial DSL (like Daml) where business logic is inherently safer and auditable.
• Multi-Party Governance: Critical transactions (e.g., >$10M) require M-of-N signatures from pre-defined roles.
• Upgrade Safeguards: Implement time-locked, governance-mandated upgrades with rollback capabilities, unlike immutable public contracts.

Relying on third-party bridges like LayerZero or Axelar cedes control and revenue. You pay fees for a commoditized service while your clients' assets are locked in opaque smart contracts you don't audit.

• Revenue Leakage: You pay ~10-50 bps per cross-chain transaction to a third party.
• Vendor Lock-in: Your product's reliability is tied to their security, which has seen $2B+ in bridge hacks since 2020.
• No Product Differentiation: Every bank uses the same bridge; you cannot offer unique speed or pricing.

Deploy a dedicated application-specific chain (appchain) using frameworks like Polygon CDK or Arbitrum Orbit. This makes you the issuer and validator of your financial primitives.

• Capture Full Economics: Earn validator fees and MEV from your own transaction flow.
• Regulatory Clarity: Enforce KYC/AML at the protocol level, a feature generic L2s like Base cannot offer.
• Performance Guarantees: Achieve sub-second finality and predictable gas costs for your clients, unlike the volatile Ethereum base layer.

JPMorgan's Onyx Digital Assets network is the canonical case study. It's a private, permissioned EVM chain for intra-bank settlement, processing $1B+ daily.

• Proven Scale: Handles institutional volume with ~500ms block times.
• Controlled Access: Participants are vetted, eliminating anonymous counterparty risk endemic to public DeFi.
• Path to Composability: A private appchain can be strategically connected to public networks like Avalanche or Polygon for specific functions, maintaining sovereignty.

Your treasury and capital markets desk transforms from a legacy cost center into a proprietary trading and market-making engine.

• New Revenue Streams: Run automated market makers (AMMs) and lending pools with your balance sheet, competing with Aave and Uniswap.
• Atomic Composability: Execute complex cross-product trades (e.g., repo + swap) in a single transaction, impossible in fragmented TradFi systems.
• Data Advantage: Gain a real-time, immutable ledger of all activity for risk modeling and product development, a dataset Bloomberg can't sell you.