Across Protocol: A Deep Dive into Its Cross-Chain Bridge Architecture

·

Across is an innovative Ethereum-based cross-chain protocol that enables fast, decentralized asset transfers from Layer 2 rollups (such as Optimism, Arbitrum, and Boba Network) back to the Ethereum mainnet. By combining optimistic oracle mechanisms, bonded relayers, and single-sided liquidity pools, Across delivers secure and efficient bridging with minimal user friction. This comprehensive analysis explores the core architecture, smart contract design, and operational workflows behind Across’s v1 implementation.

What Is Across?

Across is a trust-minimized cross-chain bridge protocol designed specifically for L2-to-L1 asset transfers on Ethereum. Unlike traditional bidirectional bridges that require liquidity on both chains, Across leverages native L2-to-L1 message passing and a unique optimistic relay model to enable fast withdrawals.

The protocol supports bidirectional bridging by integrating with major Ethereum Layer 2 solutions:

Its standout feature is the ability to offer instant finality for users through incentivized relayers, while maintaining decentralization via an optimistic dispute mechanism powered by the UMA Optimistic Oracle.

👉 Discover how decentralized finance platforms are redefining cross-chain interoperability.

Core Components of the Across Architecture

The Across ecosystem consists of several key roles and smart contracts working in harmony:

Key Roles in the Protocol

Each role plays a crucial part in ensuring security, speed, and economic sustainability.

Deposit & Relay Workflow

Deposits follow multiple possible paths depending on timing and dispute status:

Regardless of path, depositors are always protected — funds cannot be lost due to malicious or faulty relaying.

All deposited assets on L2 are transferred via native bridges (e.g., Optimism’s StandardBridge) to L1 liquidity pools, which reimburse relayers upon successful completion.

Contract Overview: v1 Source Code Analysis

The source code for Across v1 is hosted at github.com/across-protocol/contracts-v1. While v2 development is underway, this analysis focuses on the audited v1 contracts.

Project Structure

contract-v1
├── contracts       // Core protocol logic
├── deploy          // Deployment scripts
├── hardhat.config.js
├── helpers
├── networks        // Chain deployment addresses
└── package.json

We focus primarily on contracts/ and deploy/.

Main Contract Directories

These components form the backbone of Across’s cross-chain security model.

BridgeAdmin: Central Governance Contract

Deployed on L1, BridgeAdmin manages administrative functions across all connected chains.

Key State Variables

Ownership is typically assigned to a multi-sig wallet for enhanced security.

Admin Functions

Administrators can:

Cross-chain communication uses chain-specific messenger contracts:

These handle L1-to-L2 message relaying through canonical bridges.

BridgeDepositBox: L2 Deposit Handler

This abstract contract manages deposit logic on Layer 2.

bridgeTokens – Native Token Transfer

Used by the system (not users) to rebalance liquidity from L2 to L1 via native bridges. It includes safeguards:

For example, on Arbitrum:

StandardBridgeLike(outboundTransfer(...));

This triggers a standard withdrawal via Arbitrum’s native bridge.

deposit – User Initiated Withdrawal

Users call this function to initiate a withdrawal. It handles both ETH and ERC20s:

if (WETH deposit) {
    WETH.deposit{value: msg.value}();
} else {
    IERC20.safeTransferFrom(user, this, amount);
}

An event FundsDeposited is emitted, containing:

Relayer bots monitor these events to process withdrawals.

👉 Learn how blockchain protocols ensure secure asset transfers across networks.

BridgePool: Liquidity & Relay Management on L1

Deployed on Ethereum mainnet, BridgePool manages liquidity and processes relays.

Constructor Setup

On deployment, it:

constructor(
    string memory _lpTokenName,
    address _bridgeAdmin,
    address _l1Token,
    uint64 _lpFeeRatePerSecond,
    bool _isWethPool,
    address _timer
) Testable(_timer) ERC20(...) {
    ...
    syncUmaEcosystemParams();
    syncWithBridgeAdminParams();
}

Adding and Removing Liquidity

Liquidity providers supply assets to earn yield from relay fees.

addLiquidity

Suppliers receive LP tokens proportional to the current exchange rate:

uint256 lpTokensToMint = (amount * 1e18) / _exchangeRateCurrent();
_mint(msg.sender, lpTokensToMint);

Special handling exists for WETH pools where ETH is wrapped automatically.

Exchange Rate Calculation

The _exchangeRateCurrent() function accounts for:

  1. Accrued but undistributed LP fees.
  2. On-chain balance changes due to relays.
  3. Bonded amounts locked in pending relays.

It ensures fair minting and redemption based on real-time utilization.

removeLiquidity

LPs burn tokens to withdraw underlying assets:

uint256 l1TokensToReturn = (lpTokenAmount * rate) / 1e18;

Withdrawals are blocked if utilization exceeds safe thresholds.

Relay Mechanisms: Speed vs Security

Data Structures

Two core structs define relay operations:

struct DepositData { ... }
struct RelayData { ... }

They store metadata about deposits and active relay attempts.

Slow Relay (relayDeposit)

Initiates a standard relay:

Only one pending relay allowed per deposit.

Instant Relay (relayAndSpeedUp)

Combines slow and fast relay in one transaction:

This function merges logic from relayDeposit and speedUpRelay, saving gas through optimized execution flow.

Accelerated Relay (speedUpRelay)

Upgrades an existing slow relay:

Ensures user gets fast confirmation without waiting for liveness period.

Dispute Resolution via Optimistic Oracle

When fraud is suspected:

disputeRelay

Submits a dispute to UMA’s Optimistic Oracle:

_requestProposeDispute(slowRelayer, disputer, bond, finalFee, ancillaryData);

Outcomes:

Disputes reset the relay state, allowing another attempt.

_requestProposeDispute

Handles oracle interaction:

Robust error handling ensures safety even if oracle fails.

Finalizing Relays: settleRelay

After liveness period expires:

Critical checks include:

require(expirationTime <= getCurrentTime(), "Not settleable yet");
require(msg.sender == slowRelayer || lateBy(>15min), "Not slow relayer");

This prevents front-running and encourages timely resolution.

Contract Deployment Process

Eight deployment scripts orchestrate full setup:

  1. 001_deploy_across_bridge_admin.js
  2. 002_deploy_across_weth_bridge_pool.js
    3–6. Messenger contracts for Optimism, Arbitrum, Boba
    7–8. Deposit box deployments

Scripts ensure proper dependency ordering and cross-chain configuration.

Summary: Why Across Stands Out

Across represents a novel approach to cross-chain liquidity:

Its clean architecture and modular design make it a compelling case study in secure bridge engineering.

Frequently Asked Questions (FAQ)

Q: How does Across differ from other cross-chain bridges?
A: Unlike most bridges requiring two-way liquidity, Across uses native L2→L1 messaging and optimistic relaying. This allows faster withdrawals with less capital lockup.

Q: Can I lose money using Across as a depositor?
A: No. The protocol guarantees that depositors always receive their funds — either through instant relays or after a challenge period. Your assets are never at risk during transit.

Q: What happens if a relayer submits incorrect data?
A: Anyone can dispute the relay via the Optimistic Oracle. If proven fraudulent, the relayer loses their bond, and the disputer is rewarded. The correct relay can then proceed.

Q: How do liquidity providers earn yield?
A: LPs earn fees from every relay — including slow relay fees, instant relay premiums, and accrued LP fees based on utilization over time.

Q: Is Across compatible with non-EVM chains?
A: Currently, Across only supports EVM-compatible Layer 2s like Optimism and Arbitrum. Expansion to other ecosystems would require significant architectural changes.

Q: Where can I view live contract deployments?
A: Verified contracts are deployed across mainnet and testnets. Deployment addresses are listed in the /networks directory of the GitHub repository.

👉 Explore cutting-edge DeFi protocols transforming digital asset movement today.