Verifying ERC20 Transfer Events on L1: A Solidity Example

In this article, we'll explore how to verify an ERC20 transfer event on Ethereum's Layer 2 (L2) network using a Solidity smart contract. We'll assume that Alice transferred 100 USDC to Bob in a Transaction T of Block B.

The Problem: L1-Ethic Transactions on L2

When transferring assets between different blockchains, such as from L1 to L2, the transaction is executed on L1 and then propagated to L2 through a series of Etherscan transactions. However, this process can be inefficient due to network latency and gas costs.

The ERC20 standard, which governs the transfer of tokens between accounts, has been updated to include support for L1-ETH transfers. However, verifying these events is still a challenge due to the decentralized nature of blockchain networks.

Our Solution: A Solidity Contract

We'll create a simple smart contract in Solidity that demonstrates how to verify an ERC20 transfer event on L1 using an L2 network (Arbitrum One or Optimism). The contract will track all transactions involving Bob and identify those with specific conditions, such as the sender being Alice and the recipient having transferred 100 USDC.

pragma solidity ^0.8.0;


import "


contract L1ToL2Verifier {

    // Mapping of accounts to their transaction history

    mapping(address => TransactionHistory) public transactions;


    struct TransactionHistory {

        uint256 blockNumber;

        address fromAddress;

        address toAddress;

        uint256 amount;

    }


    event TransactionCreated(address indexed sender, address indexed recipient, uint256 amount);

    event TransferEvent(address indexed from, address indexed to, uint256 amount);


    function createTransactionHistory() public pure returns (TransactionHistory) {

        return TransactionHistory(block.timestamp, msg.sender, 0, 100  10*18);

    }


    function sendTransaction(address _recipient, uint256 _amount) public payable {

        // Create a transaction history for the sender

        transactions[msg.sender].blockNumber = block.number;

        transactions[msg.sender].fromAddress = _recipient;


        // Update the recipient's transaction history

        transactions[_recipient].amount += _amount;

    }


    function verifyTransactionEvent(address _sender, address _recipient) public returns (bool) {

        // Get the sender and recipient of the transfer from the L1 account's history

        TransactionHistory sender = transactions[msg.sender];

        TransactionHistory recipient = transactions[_recipient];


        // Check if the sender is Alice

        require(sender.fromAddress == "0x..." , "Invalid sender");


        // Check if the recipient has transferred 100 USDC

        require(recipient.amount >= 100  10*18, "Recipient did not transfer enough tokens");


        // Create a new event for the transfer occurrence (not shown in this example)

        emit TransferEvent(sender.fromAddress, _recipient, 100  10*18);


        return true;

    }

}

Explanation

This Solidity contract consists of three main functions:

• createTransactionHistory: Creates a new transaction history for an account.

• sendTransaction: Sends a transaction from one address to another and updates their transaction histories.

• verifyTransactionEvent: Verifies if a specific transfer event occurs on the L1 network (Ethereum) using the provided sender and recipient addresses.

The contract uses mapping to store all transactions involving Bob, including his transaction history.

Deployment

To deploy this contract, you'll need to:

• Set up an Ethereum faucet account.

2.

solana what solana validator