Build Your First Omni-Chain dApp

Burn/Mint

Step 1: Get the OATS Token Code

1. Open Remix IDE: https://remix.ethereum.org/ 
2. Create a new file named OATSToken.sol.
3. Copy and paste the following code into the file. This is a simplified version of the OATSToken contract for demonstration.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
 
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
 
// A simplified interface for the Analog Gateway
interface IGateway {
    function submitMessage(address destinationAddress, uint16 network, uint64 gasLimit, bytes calldata data) external payable returns (bytes32);
    function estimateMessageCost(uint16 network, uint16 messageSize, uint64 gasLimit) external view returns (uint256);
}
 
// A simplified interface for receiving messages
interface IGmpReceiver {
    function onGmpReceived(bytes32 id, uint128 networkId, bytes32 source, uint64 nonce, bytes calldata data) external payable returns (bytes32);
}
 
contract OATSToken is ERC20, ERC20Burnable, Ownable, IGmpReceiver {
    IGateway public immutable gateway;
    mapping(uint16 => address) public supportedTokens;
 
    constructor(string memory name, string memory symbol, address _gateway) ERC20(name, symbol) Ownable(msg.sender) {
        gateway = IGateway(_gateway);
        _mint(msg.sender, 1000000 * 10**decimals());
    }
 
    function setSupportedToken(uint16 networkId, address tokenAddress) public onlyOwner {
        supportedTokens[networkId] = tokenAddress;
    }
 
    function estimateSendCost(uint16 destinationNetworkId) public view returns (uint256) {
        bytes memory message = abi.encode(msg.sender, msg.sender, 0);
        return gateway.estimateMessageCost(destinationNetworkId, uint16(message.length), 100000);
    }
 
    function send(uint16 destinationNetworkId, address recipient, uint256 amount) public payable {
        require(supportedTokens[destinationNetworkId] != address(0), "Unsupported network");
        _burn(msg.sender, amount);
        bytes memory message = abi.encode(msg.sender, recipient, amount);
        gateway.submitMessage{value: msg.value}(supportedTokens[destinationNetworkId], destinationNetworkId, 100000, message);
    }
 
    function onGmpReceived(bytes32, uint128, bytes32, uint64, bytes calldata data) external payable override returns (bytes32) {
        // In a real scenario, you'd verify the gateway and source.
        (, address to, uint256 amount) = abi.decode(data, (address, address, uint256));
        _mint(to, amount);
        return bytes32(0);
    }
}
 

Step 2: Deploy on Ethereum Sepolia

1. Compile: In Remix, go to the "Solidity Compiler" tab, select a compiler version ^0.8.0, and click "Compile OATSToken.sol".
2. Deploy:
   • Go to the "Deploy & Run Transactions" tab.
   • Select "Injected Provider - MetaMask" as the environment.
   • Make sure your MetaMask is connected to the "Ethereum Sepolia" network.
   • In the "Deploy" section, next to the "Deploy" button, provide the constructor arguments:
     • name: "MyOATSToken"
     • symbol: "MOT"
     • _gateway: (Use the Sepolia Analog GMP Gateway address). See Gateway Addresses & Network IDs for more details.
   • Click "Deploy" and confirm the transaction in MetaMask.
3. Copy the Deployed Address: Once deployed, copy the address of your token contract on Sepolia.

Step 3: Deploy on Arbitrum Sepolia

1. Switch Network: In MetaMask, switch to the "Arbitrum Sepolia" network.
2. Deploy Again: Repeat the deployment steps from Step 2, but this time connected to Arbitrum Sepolia. Use the same constructor arguments, but for _gateway use the Arbitrum address. See Gateway Addresses & Network IDs for more details.
3. Copy the Deployed Address: Copy the address of your token contract on Arbitrum Sepolia.

Step 4: Configure the Tokens

1. On Ethereum Sepolia:
   • In Remix, at the deployed contract address for your Sepolia token, call the setSupportedToken function.
   • networkId: (The chain ID for Arbitrum Sepolia). See Gateway Addresses & Network IDs for more details.
   • tokenAddress: The address of the token you deployed on Arbitrum Sepolia.
   • Click "transact" and confirm in MetaMask.
2. On Arbitrum Sepolia:
   • Switch your MetaMask to Arbitrum Sepolia.
   • In Remix, at the deployed contract address for your Arbitrum token, call setSupportedToken.
   • networkId: (The chain ID for Ethereum Sepolia). See Gateway Addresses & Network IDs for more details.
   • tokenAddress: The address of the token you deployed on Ethereum Sepolia.
   • Click "transact" and confirm.

Step 5: Transfer Tokens

1. Switch to Sepolia: In MetaMask, switch back to the Ethereum Sepolia network.
2. Estimate Cost: In Remix, for your Sepolia token contract, call the estimateSendCost function with the Arbitrum Sepolia networkId. This will give you the required fee in wei.
3. Send Tokens:
   • Call the send function.
   • destinationNetworkId: The Arbitrum Sepolia networkId.
   • recipient: The address you want to receive the tokens on Arbitrum.
   • amount: The amount of tokens to send (in wei, e.g., 1000000000000000000 for 1 token).
   • In the "Value" field at the top of the Remix panel, enter the cost estimated in the previous step, in wei.
   • Click "transact" and confirm in MetaMask.

Your newly minted tokens will arrive at your Arbitrum Sepolia wallet address in a few minutes. You can confirm the transaction and view your updated balance on Arbiscan 

Lock/Unlock

Objective

To bridge a custom ERC20 token (MyToken) from Ethereum Sepolia to Arbitrum Sepolia. We'll lock tokens in a bridge on Ethereum and unlock them from a pre-funded bridge on Arbitrum.

Step 1: Gather Contract Code and Key Addresses

First, we need to set up our smart contracts in Remix and note down the essential Analog protocol addresses. See Gateway Addresses & Network IDs for more details. Proceed as follows:

1. Open the Remix IDE. 
2. In the File Explorers tab, create the following 3 files and paste the code into them.

1. MyToken.sol This is the custom ERC-20 token we will be bridging.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/token/ERC20/ERC20.sol";
 
// A standard, pre-existing ERC20 token.
contract MyToken is ERC20 {
    constructor() ERC20("My Test Token", "MTT") {
        _mint(msg.sender, 1000000 * 10**18); // Mint 1 Million tokens to the deployer
    }
}

2. Interfaces.sol This file will contain all the necessary interfaces:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
// --- GMP Interfaces ---
interface IGateway {
    function estimateMessageCost(uint16 network, uint16 messageSize, uint64 gasLimit) external view returns (uint256);
    function submitMessage(address destinationAddress, uint16 network, uint64 gasLimit, bytes calldata data) external payable returns (bytes32);
}
 
interface IGmpReceiver {
    function onGmpReceived(bytes32 id, uint128 networkId, bytes32 source, uint64 gasLimit, bytes calldata data) external payable returns (bytes32);
}
 
// --- OATS Interfaces ---
library Utils {
    error UnauthorizedGW(address caller);
    error UnknownNetwork(uint16 networkId);
}
 
interface ISender {
    function cost(uint16 networkId) external view returns (uint256);
    function send(uint16 networkId, address recipient, uint256 amount) external payable returns (bytes32 msgId);
}

3. OATSBridge.sol This is the main bridge contract that implements the lock/unlock logic.

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/token/ERC20/IERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/access/Ownable.sol";
import "./Interfaces.sol";
 
/// @title OATSBridge (Lock/Unlock)
/// @notice An OATS-compliant bridge for an existing ERC20 token.
contract OATSBridge is ISender, IGmpReceiver, Ownable {
    IGateway private immutable _gateway;
    IERC20 private immutable _token;
 
    mapping(uint16 => address) public supportedNetworks;
 
    uint64 private constant _GAS_LIMIT = 100_000;
 
    struct TransferPayload {
        address recipient;
        uint256 amount;
    }
 
    event TokensLocked(address indexed from, uint16 indexed toNetwork, address indexed toRecipient, uint256 amount);
    event TokensUnlocked(address indexed to, uint16 indexed fromNetwork, uint256 amount);
 
    constructor(address gatewayAddress, address tokenAddress) Ownable() {
        _gateway = IGateway(gatewayAddress);
        _token = IERC20(tokenAddress);
    }
 
    function setNetwork(uint16 networkId, address bridgeAddress) public onlyOwner {
        supportedNetworks[networkId] = bridgeAddress;
    }
 
    function cost(uint16 networkId) external view returns (uint256) {
        bytes memory message = abi.encode(TransferPayload({recipient: address(0), amount: 0}));
        return _gateway.estimateMessageCost(networkId, uint16(message.length), _GAS_LIMIT);
    }
 
    function send(uint16 networkId, address recipient, uint256 amount) external payable returns (bytes32) {
        address targetBridge = supportedNetworks[networkId];
        if (targetBridge == address(0)) {
            revert Utils.UnknownNetwork(networkId);
        }
 
        // 1. Lock tokens: Pull tokens from the user into this bridge contract.
        _token.transferFrom(msg.sender, address(this), amount);
 
        bytes memory message = abi.encode(TransferPayload({recipient: recipient, amount: amount}));
 
        emit TokensLocked(msg.sender, networkId, recipient, amount);
        return _gateway.submitMessage{value: msg.value}(targetBridge, networkId, _GAS_LIMIT, message);
    }
 
    function onGmpReceived(bytes32, uint128 networkId, bytes32 source, uint64, bytes calldata data)
        external
        payable
        returns (bytes32)
    {
        if (msg.sender != address(_gateway)) {
            revert Utils.UnauthorizedGW(msg.sender);
        }
        address sourceBridge = address(uint160(uint256(source)));
        if (supportedNetworks[uint16(networkId)] != sourceBridge) {
            revert Utils.UnknownNetwork(uint16(networkId));
        }
 
        TransferPayload memory payload = abi.decode(data, (TransferPayload));
 
        // 1. Unlock tokens: Transfer tokens from the bridge to the recipient.
        _token.transfer(payload.recipient, payload.amount);
 
        emit TokensUnlocked(payload.recipient, uint16(networkId), payload.amount);
        return keccak256("OATS_UNLOCK_SUCCESS");
    }
}

Step 2: Compile Contracts

1. Navigate to the Solidity Compiler tab in Remix.
2. Select a compiler version compatible with the code (e.g., 0.8.19).
3. Compile MyToken.sol and OATSBridge.sol.

Step 3: Deploy on Ethereum Sepolia

1. In the Deploy & Run Transactions tab, set the ENVIRONMENT to Injected Provider - MetaMask.
2. Ensure your MetaMask is connected and set to the Ethereum Sepolia network.
3. Deploy MyToken.sol:
   • Select MyToken - contracts/MyToken.sol from the CONTRACT dropdown.
   • Click Deploy.
   • Confirm the transaction in MetaMask.
   • Once deployed, copy the contract address from the Deployed Contracts section. Let's call this ETH_MYTOKEN_ADDRESS.
4. Deploy OATSBridge.sol:
   • Select OATSBridge - contracts/OATSBridge.sol from the CONTRACT dropdown.
   • In the Deploy field, enter the constructor arguments separated by a comma:
     • gatewayAddress: Enter gateway address for Ethereum Sepolia here.
     • tokenAddress: The ETH_MYTOKEN_ADDRESS you just copied.
   • Click Deploy and confirm in MetaMask.
   • Copy the deployed bridge address. Let's call this ETH_BRIDGE_ADDRESS.

Step 4: Deploy on Arbitrum Sepolia

1. Switch Network: Change your MetaMask network to Arbitrum Sepolia.
2. Deploy MyToken.sol:
   • Follow the same steps as before to deploy MyToken.sol.
   • Copy the new token address. Let's call this ARB_MYTOKEN_ADDRESS.
3. Deploy OATSBridge.sol:
   • Select the OATSBridge contract.
   • Enter the constructor arguments:
     • gatewayAddress: Enter the gateway address for Arbitrum Sepolia.
     • tokenAddress: The ARB_MYTOKEN_ADDRESS you just deployed.
   • Click Deploy and confirm in MetaMask.
   • Copy the deployed bridge address. Let's call this ARB_BRIDGE_ADDRESS.

Step 5: Configure and Fund the Bridges

The two bridges now need to be made aware of each other.

1. Configure Ethereum Bridge:
   • Switch MetaMask back to Ethereum Sepolia.
   • In Remix, under Deployed Contracts, find your OATSBridge at ETH_BRIDGE_ADDRESS.
   • Expand its functions and find setNetwork.
   • Enter the following arguments:
     • networkId: (Arbitrum Sepolia's ID). See Gateway Addresses & Network IDs for more details.
     • bridgeAddress: The ARB_BRIDGE_ADDRESS you copied.
   • Click transact and confirm in MetaMask.
2. Configure Arbitrum Bridge:
   • Switch MetaMask to Arbitrum Sepolia.
   • Find your OATSBridge at ARB_BRIDGE_ADDRESS.
   • In the setNetwork function, enter:
     • networkId: (Ethereum Sepolia's ID). See Gateway Addresses & Network IDs for more details.
     • bridgeAddress: The ETH_BRIDGE_ADDRESS.
   • Click transact and confirm.
3. Fund the Arbitrum Bridge (Crucial Step):
   • For the "unlock" to work, the bridge on Arbitrum must hold tokens. We will simulate this by sending it some of the MyToken we deployed on Arbitrum.
   • Find your MyToken contract at ARB_MYTOKEN_ADDRESS.
   • Expand its functions and use the transfer function to send tokens (e.g., 100000 tokens, remembering decimals: 100000000000000000000000) to the ARB_BRIDGE_ADDRESS.

Step 6: Execute the Cross-Chain Transfer

Now, let's transfer 500 MTT from Ethereum Sepolia to Arbitrum Sepolia.

1. Switch to Ethereum Sepolia: Make sure your MetaMask is on the Ethereum Sepolia network.
2. Approve Tokens:
   • In Remix, find your MyToken contract at ETH_MYTOKEN_ADDRESS.
   • Expand the approve function and enter:
     • spender: The ETH_BRIDGE_ADDRESS.
     • amount: The amount in wei (500000000000000000000 for 500 tokens).
   • Click transact and confirm.
3. Estimate Gas Cost:
   • Find your OATSBridge contract at ETH_BRIDGE_ADDRESS.
   • Call the cost function with the networkId for Arbitrum Sepolia .
   • Copy the returned value (e.g., 2500000000000000). This is the fee in wei.
4. Send the Tokens:
   • In the top section of Remix, set the VALUE field to the cost you just copied (in wei).
   • Expand the send function on the OATSBridge contract.
   • Enter the arguments:
     • networkId: Arbitrum Sepolia ID.
     • recipient: Your own wallet address.
     • amount: The amount to send (500000000000000000000).
   • Click transact. MetaMask will pop up, asking you to confirm the transaction and pay both the standard gas fee and the value for the cross-chain fee. Confirm it.

Step 7: Verify the Transfer

• On Ethereum Sepolia: Check your MyToken balance using the balanceOf function on the token contract. It should be reduced by 500. Check the bridge's balance; it should be increased by 500.
• Wait: The Analog network takes a few minutes to achieve consensus and execute the message on the destination chain.
• On Arbitrum Sepolia: Switch your MetaMask to Arbitrum Sepolia. Check your MyToken balance there. After a few minutes, you should see it has increased by 500. You can also check the transaction history of your wallet on the Arbitrum Sepolia block explorer .

You have now successfully used an OATS-compliant bridge to transfer tokens from Ethereum Sepolia to Arbitrum Sepolia!