What is Across

Across is an interoperability protocol powered by intents. It is the first cross-chain intents protocol in production today, enabling the fastest and lowest-cost way to transfer value with better security tradeoffs vs. traditional bridge designs.

Introduction

This guide provides step-by-step instructions for integrating the Across Bridge Plugin with BuildBear Sandboxes. The Across Bridge Plugin enables developers to test and simulate cross-chain transactions using the Across Bridge interoperability protocol. This integration facilitates seamless asset transfers, intent-based execution, and enhanced cross-chain development in a controlled sandbox environment.

What You'll Learn

Install and set up the Across Bridge Plugin in your BuildBear Sandbox.
Retrieve transfer quotes for bridging WETH from Ethereum Mainnet to Base Mainnet.
Configure and execute a cross-chain WETH deposit on Ethereum Mainnet.
Extract and decode the Deposit ID on Ethereum Mainnet.
Track the status of the cross-chain deposit on Base Mainnet using the Deposit ID.

Why Use Across Bridge Plugin

Intents Explorer

Track cross-chain intents and their execution status via an integrated explorer within the Across plugin.

Advanced Developer Configurations

On-Chain Relayer Mimic: In testnets, cross-chain deposits often fail due to missing relayer parameters, preventing transactions from being picked up. This plugin solves this issue by allowing developers to simulate relayer behavior, ensuring deposits are fulfilled in a controlled environment. Developers can configure real or mock relayer conditions to test execution flows without relying on testnet relayers that may not exist.
Intent Fulfillment Delay: Customize execution delays to analyze transaction performance under varying network conditions, helping developers optimize cross-chain interactions before deployment.

Eliminate High Testing Costs

Test and refine your cross-chain applications without spending real funds. The Across Bridge Plugin allows seamless experimentation within BuildBear Sandboxes, eliminating the need for costly mainnet transactions.

Reliable Bridging & Tracking

The built in Explorer enables real-time monitoring of cross-chain intents and execution statuses. Developers no longer need to rely on unreliable testnet RPCs or manually track mainnet bridging transactions.

Step 1: Installing the Plugin

Install the Across Bridge Plugin

Log in to your BuildBear account and navigate to the Plugin Marketplace on both the sandboxes (Two Sandboxes are needed, one for source and another for destination).
Search for "Across Bridge Plugin" and click Install.

Configure Your Sandbox

Create two new Sandboxes or navigate to existing ones.
Open the Across Bridge Plugin and configure linked Sandboxes for cross-chain interaction.
(Optional) Adjust developer configurations:
1. On-Chain Relayer Mimic
2. Fulfillment Delay

Step 2: Defining and Submitting Cross-Chain Intents

Prerequisites

Install the following dependencies as listed in package.json here
A sufficiently funded account with Native or ERC20 tokens is needed to facilitate swapping & bridging, thus a private key for the account is needed in the .env file

1️⃣ Define API URL & Endpoints

// ### RPC URL ###

let BASE_URL = `https://api.buildbear.io/{from-sandbox-id}/plugin/across/{to-sandbox-id}`;

 

// ### API Endpoints ###

let GET_SUGGESTED_FEES = `/suggested-fees`;

let BRIDGE_STATUS = `/deposit/status`;

Replace {sandbox-id} with your specific BuildBear Sandbox ID.

2️⃣ Define the bridge Parameters

The bridge params include the input token on the origin chain and the output token on the destination chain with the input amount for the input token

let bridgeParams: BridgeParams = {

  inputToken: `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`, // WETH
  outputToken: `0x4200000000000000000000000000000000000006`, // WETH
  originChainId: 1,
  destinationChainId: 8453,
  amount: parseEther("0.1"),

};

3️⃣ Type Declarations for Requests & Response (Optional)

Declaring the types for the requests and response can improve code-readability and make debugging easier, but is still optional.

Refer to the type-definitions in the tutorial repository.

4️⃣ Retrieving Deposit Route & Bridge Parameters

We have the bridgeParams defined, which allows us to dynamically fetch the fee quotes and routes for intent execution, therefore we can use them to get a available route (spokePool) for depositing, with other parameters such as fees, fulfillment timestamp, etc.

async function getSuggestedFees(): Promise<RelayQuoteData | undefined> {
let res = await axios.get(`${BASE_URL}${GET_SUGGESTED_FEES}`, {

   params: {
     inputToken: bridgeParams.inputToken,
     outputToken: bridgeParams.outputToken,
     originChainId: bridgeParams.originChainId,
     destinationChainId: bridgeParams.destinationChainId,
     amount: bridgeParams.amount,
     recipient: bridgeParams.recipient,
     message: bridgeParams.message,
     relayer: bridgeParams.relayer,
     timestamp: bridgeParams.timestamp,
   },

});

let data: RelayQuoteData = res.data;
return data;
}

5️⃣ Extract the result of fees estimation and initiate the Deposit

The parameters defined in the type definition RelayQuoteData above, which is fetched via getDepositStatus is passed as a parameter to the below function to define correct and error-free deposit parameters.

Once we have the bridge quotes, we can use the dynamic variables like fees, deadlines, spokePool address. etc to connect and execute a cross-chain intent (spokePool.depositV3)

This will return the tx hash for the intent execution on Ethereum Mainnet and also emit a event with the deposit ID in hex which we will convert to decimals. This deposit ID is crucial as it is used to track the status of our intent on Base Mainnet

async function depositToSpokePool(bridgeQuote: RelayQuoteData) {
  // 🔹 Setup provider & signer using private key
  const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

  const provider = new ethers.JsonRpcProvider(
"https://rpc.buildbear.io/{SANDBOX-ID}"
  );

  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider); // Create wallet instance from private key

  // 🔹 Define SpokePool contract
  
  const spokePool = new ethers.Contract(
		bridgeQuote.spokePoolAddress,

		parseAbi([
   		"function depositV3( address depositor, address recipient, address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 destinationChainId, address exclusiveRelayer, uint32 quoteTimestamp, uint32 fillDeadline, uint32 exclusivityDeadline, bytes calldata message ) external",

		]),
		wallet
  		);

  // 🔹 Define deposit parameters

  const depositor = await wallet.getAddress(); // Get the address associated with the private key
  const recipient = await wallet.getAddress(); // Change if sending to another wallet
  const inputToken = bridgeParams.inputToken; // ERC20 token being deposited
  const outputToken = bridgeParams.outputToken; // Token received after bridging
  const inputAmount = bridgeParams.amount; // Adjust decimals
  const outputAmount = BigInt(inputAmount) - BigInt(bridgeQuote.totalRelayFee.total);
  const destinationChainId = bridgeParams.destinationChainId; // Base as an example
  const quoteTimestamp = bridgeQuote.timestamp;
  const fillDeadlineBuffer = 18000;
  const fillDeadline = Math.round(Date.now() / 1000) + fillDeadlineBuffer;
  const exclusivityDeadline = bridgeQuote.exclusivityDeadline;
  const exclusiveRelayer = bridgeQuote.exclusiveRelayer;
  const message = "0x";

 

  // 🔹 Execute deposit transaction

const tx = await spokePool.depositV3(
   depositor, // Sender
   recipient, // Receiver
   inputToken, // Token to deposit
   outputToken, // Token received on the other chain
   inputAmount, // Amount sent
   outputAmount, // Amount expected
   destinationChainId, // Chain ID
   exclusiveRelayer, // No exclusive relayer
   quoteTimestamp, // Timestamp for the quote
   fillDeadline, // Deadline to fill
   exclusivityDeadline, // Exclusive deadline
   message, // Optional message,
      { value: inputAmount }
);

console.log("Transaction sent! Tx Hash:", tx.hash);
await tx.wait();t receipt = await provider.getTransactionReceipt(tx.hash);
const depositIdHex = receipt?.logs[1].topics[2]; // deposit id from event logs in hex
const depositId = BigInt(depositIdHex).toString();
console.log(`Deposit ID: ${depositId}`);

// Now, use depositId to get the deposit status
await getDepositStatus(+depositId);

}

5️⃣ Fetching the status of deposit

The depositId in combination with the originChainId is passed to BRIDGE_STATUS API call to track the status of the deposit, it also returns the tx hash for the filled tx on the Base Mainnet.

async function getDepositStatus(
  depositId: number
): Promise<DepositStatusData | undefined> {

let res = await axios.get(`${BASE_URL}${BRIDGE_STATUS}`, {
   params: {
     originChainId: bridgeParams.originChainId,
     depositId,
   },

});

let data: DepositStatusData = res.data; console.log(`Fill Status : ${data.fillStatus}`
return data;

}

Now, that all the crucial functions are defined we can call the functions in the following order to bridge assets

// 🔹 Main function
let bridgeQuote = await getSuggestedFees();
if (bridgeQuote) {
  depositToSpokePool(bridgeQuote);
}

If the script is configured correctly, the cross-chain deposit should execute successfully on the Ethereum Mainnet and the tx should be visible in the sandbox block explorer:

===========Suggested Fees===========

{

  estimatedFillTimeSec: 10,
  capitalFeePct: '95313207088108',
  capitalFeeTotal: '10721118321356',
  relayGasFeePct: '4724256651654',
  relayGasFeeTotal: '531398702133',
  relayFeePct: '100037463739762',
  relayFeeTotal: '11252517023489',
  lpFeePct: '0',
  timestamp: '1741144079',
  isAmountTooLow: false,
  quoteBlock: '21977900',
  exclusiveRelayer: '0xB96b74874126A787720a464EAb3FBD2F35a5D14e',
  exclusivityDeadline: 1741144325,
  spokePoolAddress: '0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5',
  destinationSpokePoolAddress: '0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64',
  totalRelayFee: { pct: '100037463739762', total: '11252517023489' },
  relayerCapitalFee: { pct: '95313207088108', total: '10721118321356' },
  relayerGasFee: { pct: '4724256651654', total: '531398702133' },
  lpFee: { pct: '0', total: '0' },
  limits: {
	minDeposit: '229232666571917',
	maxDeposit: '1013936183218258295723',
	maxDepositInstant: '180701577849658105483',
	maxDepositShortDelay: '1013936183218258295723',
	recommendedDepositInstant: '180701577849658105483'
  },
  fillDeadline: '1741156015'
}
====================================
inputAmount 0.112483029885315943
bridgeQuote.totalRelayFee.total 0.000011252517023489
outputAmount 0.112471777368292454
====================================
Transaction sent! Tx Hash: 0x6465f35e56cdec1cb65172528ab4aa9864372dfede5077b4b57d8e47b9946dbe
Deposit completed!
Deposit ID: 2347472
Fill Status : filled

Block Explorers & Transactions Debugging

We can observe the tx on the BlockScout Explorer Plugin for Ethereum Mainnet in the sandbox, which shows the token flow for the tx for cross chain deposit

Additionally, installing the sentio plugin, can equip users with debugging capabilities, we can easily observe flow of funds to/from the contracts

Observe the stack traces for a more deeper insight into the transaction

The Call Graph section shows call flow of different functions, across different contracts

We can also observe the tx on the Base Mainnet explorer in the sandbox, which shows the token flow for the tx for cross chain deposit

Similar to Ethereum Mainnet, we can also observe the fund flow, call traces, call graph for the bridge fill transaction on Base Mainnet

Conclusion

The Across Bridge Plugin for BuildBear Sandboxes provides a streamlined way to develop and test cross-chain transactions. We have successfully managed to, get suggested fees & routes for bridging parameters. Execute a cross-chain intent and deposit on Ethereum Mainnet. Track fill status on the Base Mainnet, destination chain.
For the full tutorial, you can check out the Github Repository

Bridging WETH from Ethereum Mainnet to Base Mainnet Using the Across Bridge Plugin

Let’s get started then, Shall we?

Let’s get started then, Shall we?