DEV Community: Taylor Caldwell

Accessing real-time asset data on Abstract using Pyth Price Feeds

Taylor Caldwell — Sat, 01 Feb 2025 02:44:37 +0000

This tutorial will guide you through the process of creating a smart contract on Abstract that utilizes Pyth Network oracles to consume a price feed.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Abstract using Foundry
Install the Pyth smart contracts
Consume a Pyth Network price feed within your smart contract
Deploy and test your smart contracts on Abstract

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Metamask Wallet

In order to deploy a smart contract, you will first need a crypto wallet. You can create a wallet by downloading the Metamask browser extension.

Download Metamask

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Abstract Sepolia test network. You can fund your wallet with Abstract Sepolia ETH using a bridge or faucet.

What is Pyth Network?

Pyth Network focuses on ultra-low latency and real-time data, making it suitable for financial applications that require sub-second updates. Pyth's design emphasizes performance, and it is designed to provide data for a range of traditional and DeFi assets.

Creating a project

Before you can begin writing smart contracts for Abstract and consuming Pyth price feeds, you need to set up your development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project, which has the following basic layout:

.
├── foundry.toml
├── script
 │   └── Counter.s.sol
├── src
 │   └── Counter.sol
└── test
    └── Counter.t.sol

Installing Pyth smart contracts

To use Pyth price feeds within your project, you need to install Pyth oracle contracts as a project dependency using forge install.

To install Pyth oracle contracts, run:

forge install pyth-network/pyth-sdk-solidity@v2.2.0 --no-git --no-commit

Once installed, update your foundry.toml file by appending the following line:

remappings = ['@pythnetwork/pyth-sdk-solidity/=lib/pyth-sdk-solidity']

Writing and compiling the Smart Contract

Once your project has been created and dependencies have been installed, you can now start writing a smart contract.

The Solidity code below defines a smart contract named ExampleContract. The code uses the IPyth interface from the Pyth Solidity SDK.

An instance ofIPyth is defined within the contract that provides functions for consuming Pyth price feeds. The constructor for the IPyth interface expects a contract address to be provided. This address provided in the code example below (0x47F2A9BDAd52d65b66287253cf5ca0D2b763b486) corresponds to the Pyth contract address for the Abstract Sepolia testnet.

Info: Pyth also supports other EVM networks, such as Abstract Mainnet. For a list of all network contract addresses, visit the Pyth documentation.

The contract also contains a function named getLatestPrice. This function takes a provided priceUpdateData that is used to get updated price data, and returns the price given a priceId of a price feed. The smart contract provided below uses a priceId of 0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace, which corresponds to the price feed for ETH / USD.

Info: Pyth provides a number of price feeds. For a list of available price feeds, visit the Pyth documentation.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract ExampleContract {
  IPyth pyth;

  /**
  * Network: Abstract Sepolia (testnet)
  * Address: 0x47F2A9BDAd52d65b66287253cf5ca0D2b763b486
  */
  constructor() {
    pyth = IPyth(0x47F2A9BDAd52d65b66287253cf5ca0D2b763b486);
  }

  function getLatestPrice(
    bytes[] calldata priceUpdateData
  ) public payable returns (PythStructs.Price memory) {
    // Update the prices to the latest available values and pay the required fee for it. The `priceUpdateData` data
    // should be retrieved from our off-chain Price Service API using the `pyth-evm-js` package.
    // See section "How Pyth Works on EVM Chains" below for more information.
    uint fee = pyth.getUpdateFee(priceUpdateData);
    pyth.updatePriceFeeds{ value: fee }(priceUpdateData);

    bytes32 priceID = 0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace;
    // Read the current value of priceID, aborting the transaction if the price has not been updated recently.
    // Every chain has a default recency threshold which can be retrieved by calling the getValidTimePeriod() function on the contract.
    // Please see IPyth.sol for variants of this function that support configurable recency thresholds and other useful features.
    return pyth.getPrice(priceID);
  }
}

In your project, add the code provided above to a new file named src/ExampleContract.sol and delete the src/Counter.sol contract that was generated with the project (You can also delete the test/Counter.t.sol and script/Counter.s.sol files).

To compile the new smart contract, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to the Abstract network, you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Metamask, visit the Metamask Support page. It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables for Abstract Sepolia

To setup your environment for deploying to the Abstract network, create an .env file in the home directory of your project, and add the RPC URL for the Abstract Sepolia testnet:

ABSTRACT_SEPOLIA_RPC="https://api.testnet.abs.xyz"

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

Deploying the smart contract to Abstract Sepolia

With your contract compiled and environment setup, you are ready to deploy the smart contract to the Abstract Sepolia Testnet!

For deploying a single smart contract using Foundry, you can use the forge create command. The command requires you to specify the smart contract you want to deploy, an RPC URL of the network you want to deploy to, and the account you want to deploy with.

To deploy the ExampleContract smart contract to the Abstract Sepolia test network, run the following command:

forge create ./src/ExampleContract.sol:ExampleContract --rpc-url $ABSTRACT_SEPOLIA_RPC --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

Info: Your wallet must be funded with ETH on the Abstract Sepolia Testnet to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH for Abstract Sepolia, see the prerequisites.

After running the command above, the contract will be deployed on the Abstract Sepolia test network. You can view the deployment status and contract by using a block explorer.

Interacting with the Smart Contract

The getLatestPrice(bytes[]) function of the deployed contract takes a priceUpdateData argument that is used to get the latest price. This data can be fetched using the Hermes web service. Hermes allows users to easily query for recent price updates via a REST API. Make a curl request to fetch the priceUpdateData the priceId, 0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace:

curl https://hermes.pyth.network/api/latest_vaas?ids[]=0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace

Once you have the priceUpdateData, you can use Foundry’s cast command-line tool to interact with the smart contract and call the getLatestPrice(bytes[]) function to fetch the latest price of ETH.

To call the getLatestPrice(bytes[]) function of the smart contract, run the following command, replacing <DEPLOYED_ADDRESS> with the address of your deployed contract, and <PRICE_UPDATE_DATA> with the priceUpdateData returned by the Hermes endpoint:

cast call <DEPLOYED_ADDRESS> --rpc-url $ABSTRACT_SEPOLIA_RPC "getLatestPrice(bytes[])" <PRICE_UPDATE_DATA>

You should receive the latest ETH / USD price in hexadecimal form.

Conclusion

Congratulations! You have successfully deployed and interacted with a smart contract that consumes a Pyth Network oracle to access a real-time price feed on Abstract.

To learn more about Oracles and using Pyth Network price feeds within your smart contracts on Abstract, check out the following resources:

Sending messages from Abstract to other chains using LayerZero V2

Taylor Caldwell — Sat, 01 Feb 2025 02:00:22 +0000

This tutorial will guide you through the process of sending cross-chain message data from an Abstract smart contract to another smart contract on a different chain using LayerZero V2.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Abstract using Foundry
Install the LayerZero smart contracts as a dependency
Use LayerZero to send messages and from smart contracts on Abstract to smart contracts on different chains
Deploy and test your smart contracts on Abstract testnet

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Metamask Wallet

In order to deploy a smart contract, you will first need a crypto wallet. You can create a wallet by downloading the Metamask browser extension.

Download Metamask

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Abstract Sepolia test network. You can fund your wallet with Abstract Sepolia ETH using a bridge or faucet.

What is LayerZero?

LayerZero is an interoperability protocol that allows developers to build applications (and tokens) that can connect to multiple blockchains. LayerZero defines these types of applications as "omnichain" applications.

The LayerZero protocol is made up of immutable on-chain Endpoints, a configurable Security Stack, and a permissionless set of Executors that transfer messages between chains.

High-level concepts

Endpoints

Endpoints are immutable LayerZero smart contracts that implement a standardized interface for your own smart contracts to use and in order to manage security configurations and send and receive messages.

Security Stack (DVNs)

The Security Stack is a configurable set of required and optional Decentralized Verifier Networks (DVNs). The DVNs are used to verify message payloads to ensure integrity of your application's messages.

Executors

Executors are responsible for initiating message delivery. They will automatically execute the lzReceive function of the endpoint on the destination chain once a message has been verified by the Security Stack.

Creating a project

Before you begin, you need to set up your smart contract development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project with the following basic layout:

.
├── foundry.toml
├── script
├── src
└── test

Info: You can delete the src/Counter.sol, test/Counter.t.sol, and script/Counter.s.sol boilerplate files that were generated with the project, as you will not be needing them.

Installing the LayerZero smart contracts

To use LayerZero within your Foundry project, you need to install the LayerZero smart contracts and their dependencies using forge install.

To install LayerZero smart contracts and their dependencies, run the following commands:

forge install GNSPS/solidity-bytes-utils --no-commit
forge install OpenZeppelin/openzeppelin-contracts@v4.9.4 --no-commit
forge install LayerZero-Labs/LayerZero-v2 --no-commit

Once installed, update your foundry.toml file by appending the following lines:

remappings = [
    '@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts',
    'solidity-bytes-utils/=lib/solidity-bytes-utils',
    '@layerzerolabs/lz-evm-oapp-v2/=lib/LayerZero-v2/oapp',
    '@layerzerolabs/lz-evm-protocol-v2/=lib/LayerZero-v2/protocol',
    '@layerzerolabs/lz-evm-messagelib-v2/=lib/LayerZero-v2/messagelib',
]

Getting started with LayerZero

LayerZero provides a smart contract standard called OApp that is intended for omnichain messaging and configuration.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { OAppSender } from "./OAppSender.sol";
import { OAppReceiver, Origin } from "./OAppReceiver.sol";
import { OAppCore } from "./OAppCore.sol";

abstract contract OApp is OAppSender, OAppReceiver {
   constructor(address _endpoint) OAppCore(_endpoint, msg.sender) {}

   function oAppVersion() public pure virtual returns (uint64 senderVersion, uint64 receiverVersion) {
       senderVersion = SENDER_VERSION;
       receiverVersion = RECEIVER_VERSION;
   }
}

Info: You can view the source code for this contract on GitHub.

To get started using LayerZero, developers simply need to inherit from the OApp contract, and implement the following two inherited functions:

_lzSend: A function used to send an omnichain message
_lzReceive: A function used to receive an omnichain message

In this tutorial, you will be implementing the OApp standard into your own project to add the capability to send messages from a smart contract on Abstract to a smart contract on Arbitrum.

Info: An extension of the OApp contract standard known as OFT is also available for supporting omnichain fungible token transfers.

Info: For more information on transferring tokens across chains using LayerZero, visit the LayerZero documentation.

Writing the smart contract

To get started, create a new Solidity smart contract file in your project's src/ directory named ExampleContract.sol, and add the following content:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { OApp, Origin, MessagingFee } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/OApp.sol";

contract ExampleContract is OApp {
   constructor(address _endpoint, address _owner) OApp(_endpoint, _owner) {}
}

The code snippet above defines a new smart contract named ExampleContract that extends the OApp contract standard.

The contract's constructor expects two arguments:

_endpoint: The LayerZero Endpoint address for the chain the smart contract is deployed to.
_owner: The address of the owner of the smart contract.

Info: LayerZero Endpoints are smart contracts that expose an interface for OApp contracts to manage security configurations and send and receive messages via the LayerZero protocol.

Implementing message sending (`_lzSend`)

To send messages to another chain, your smart contract must call the _lzSend function inherited from the OApp contract.

Add a new custom function named sendMessage to your smart contract that has the following content:

/// @notice Sends a message from the source chain to the destination chain.
/// @param _dstEid The endpoint ID of the destination chain.
/// @param _message The message to be sent.
/// @param _options The message execution options (e.g. gas to use on destination).
function sendMessage(uint32 _dstEid, string memory _message, bytes calldata _options) external payable {
   bytes memory _payload = abi.encode(_message); // Encode the message as bytes
   _lzSend(
       _dstEid,
       _payload,
       _options,
       MessagingFee(msg.value, 0), // Fee for the message (nativeFee, lzTokenFee)
       payable(msg.sender) // The refund address in case the send call reverts
   );
}

The sendMessage function above calls the inherited _lzSend function, while passing in the following expected data:

Name	Type	Description
`_dstEid`	`uint32`	The endpoint ID of the destination chain to send the message to.
`_payload`	`bytes`	The message (encoded) to send.
`_options`	`bytes`	Additional options when sending the message, such as how much gas should be used when receiving the message.
`_fee`	`MessagingFee`	The calculated fee for sending the message.
`_refundAddress`	`address`	The `address` that will receive any excess fee values sent to the endpoint in case the `_lzSend` execution reverts.

Implementing gas fee estimation (`_quote`)

As shown in the table provided in the last section, the _lzSend function expects an estimated gas fee to be provided when sending a message (_fee).

Therefore, sending a message using the sendMessage function of your contract, you first need to estimate the associated gas fees.

There are multiple fees incurred when sending a message across chains using LayerZero, including: paying for gas on the source chain, fees paid to DVNs validating the message, and gas on the destination chain. Luckily, LayerZero bundles all of these fees together into a single fee to be paid by the msg.sender, and LayerZero Endpoints expose a _quote function to estimate this fee.

Add a new function to your ExampleContract contract called estimateFee that calls the _quote function, as shown below:

/// @notice Estimates the gas associated with sending a message.
/// @param _dstEid The endpoint ID of the destination chain.
/// @param _message The message to be sent.
/// @param _options The message execution options (e.g. gas to use on destination).
/// @return nativeFee Estimated gas fee in native gas.
/// @return lzTokenFee Estimated gas fee in ZRO token.
function estimateFee(
   uint32 _dstEid,
   string memory _message,
   bytes calldata _options
) public view returns (uint256 nativeFee, uint256 lzTokenFee) {
   bytes memory _payload = abi.encode(_message);
   MessagingFee memory fee = _quote(_dstEid, _payload, _options, false);
   return (fee.nativeFee, fee.lzTokenFee);
}

The estimateFee function above calls the inherited _quote function, while passing in the following expected data:

Name	Type	Description
`_dstEid`	`uint32`	The endpoint ID of the destination chain the message will be sent to.
`_payload`	`bytes`	The message (encoded) that will be sent.
`_options`	`bytes`	Additional options when sending the message, such as how much gas should be used when receiving the message.
`_payInLzToken`	`bool`	Boolean flag for which token to use when returning the fee (native or ZRO token).

Info: Your contract’s estimateFee function should always be called immediately before calling sendMessage to accurately estimate associated gas fees.

Implementing message receiving (`_lzReceive`)

To receive messages on the destination chain, your smart contract must override the _lzReceive function inherited from the OApp contract.

Add the following code snippet to your ExampleContract contract to override the _lzReceive function:

/// @notice Entry point for receiving messages.
/// @param _origin The origin information containing the source endpoint and sender address.
///  - srcEid: The source chain endpoint ID.
///  - sender: The sender address on the src chain.
///  - nonce: The nonce of the message.
/// @param _guid The unique identifier for the received LayerZero message.
/// @param _message The payload of the received message.
/// @param _executor The address of the executor for the received message.
/// @param _extraData Additional arbitrary data provided by the corresponding executor.
function _lzReceive(
   Origin calldata _origin,
   bytes32 _guid,
   bytes calldata payload,
   address _executor,
   bytes calldata _extraData
   ) internal override {
       data = abi.decode(payload, (string));
       // other logic
}

The overridden _lzReceive function receives the following arguments when receiving a message:

Name	Type	Description
`_origin`	`Origin`	The origin information containing the source endpoint and sender address.
`_guid`	`bytes32`	The unique identifier for the received LayerZero message.
`payload`	`bytes`	The payload of the received message (encoded).
`_executor`	`address`	The `address` of the Executor for the received message.
`_extraData`	`bytes`	Additional arbitrary data provided by the corresponding Executor.

Note that the overridden method decodes the message payload, and stores the string into a variable named data that you can read from later to fetch the latest message.

Add the data field as a member variable to your contract:

contract ExampleContract is OApp {

    // highlight-next-line
    string public data;

    constructor(address _endpoint) OApp(_endpoint, msg.sender) {}
}

Info: Overriding the _lzReceive function allows you to provide any custom logic you wish when receiving messages, including making a call back to the source chain by invoking _lzSend. Visit the LayerZero Message Design Patterns for common messaging flows.

Final code

Once you complete all of the steps above, your contract should look like this:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { OApp, Origin, MessagingFee } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/OApp.sol";

contract ExampleContract is OApp {

 string public data;

  constructor(address _endpoint) OApp(_endpoint, msg.sender) {}

  /// @notice Sends a message from the source chain to the destination chain.
  /// @param _dstEid The endpoint ID of the destination chain.
  /// @param _message The message to be sent.
  /// @param _options The message execution options (e.g. gas to use on destination).
  function sendMessage(uint32 _dstEid, string memory _message, bytes calldata _options) external payable {
     bytes memory _payload = abi.encode(_message); // Encode the message as bytes
     _lzSend(
           _dstEid,
           _payload,
           _options,
           MessagingFee(msg.value, 0), // Fee for the message (nativeFee, lzTokenFee)
           payable(msg.sender) // The refund address in case the send call reverts
     );
  }

  /// @notice Estimates the gas associated with sending a message.
  /// @param _dstEid The endpoint ID of the destination chain.
  /// @param _message The message to be sent.
  /// @param _options The message execution options (e.g. gas to use on destination).
  /// @return nativeFee Estimated gas fee in native gas.
  /// @return lzTokenFee Estimated gas fee in ZRO token.
  function estimateFee(
     uint32 _dstEid,
     string memory _message,
     bytes calldata _options
  ) public view returns (uint256 nativeFee, uint256 lzTokenFee) {
     bytes memory _payload = abi.encode(_message);
     MessagingFee memory fee = _quote(_dstEid, _payload, _options, false);
     return (fee.nativeFee, fee.lzTokenFee);
  }

  /// @notice Entry point for receiving messages.
  /// @param _origin The origin information containing the source endpoint and sender address.
  ///  - srcEid: The source chain endpoint ID.
  ///  - sender: The sender address on the src chain.
  ///  - nonce: The nonce of the message.
  /// @param _guid The unique identifier for the received LayerZero message.
  /// @param _message The payload of the received message.
  /// @param _executor The address of the executor for the received message.
  /// @param _extraData Additional arbitrary data provided by the corresponding executor.
  function _lzReceive(
     Origin calldata _origin,
     bytes32 _guid,
     bytes calldata payload,
     address _executor,
     bytes calldata _extraData
     ) internal override {
        data = abi.decode(payload, (string));
  }
}

Compiling the smart contract

Compile the smart contract to ensure it builds without any errors.

To compile your smart contract, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to various chains you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Metamask, visit the Metamask Support page.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables

To setup your environment, create an .env file in the home directory of your project, and add the RPC URLs and LayerZero Endpoint information for both Abstract Sepolia Testnet and Arbitrum Sepolia Testnet:

ABSTRACT_TESTNET_RPC="https://api.testnet.abs.xyz"
ABSTRACT_TESTNET_LZ_ENDPOINT=0x16c693A3924B947298F7227792953Cd6BBb21Ac8
ABSTRACT_TESTNET_LZ_ENDPOINT_ID=40313

ARBITRUM_TESTNET_RPC="https://sepolia-rollup.arbitrum.io/rpc"
ARBITRUM_TESTNET_LZ_ENDPOINT=0x6EDCE65403992e310A62460808c4b910D972f10f
ARBITRUM_TESTNET_LZ_ENDPOINT_ID=40231

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

With your contract compiled and environment setup, you are now ready to deploy the smart contract to different networks.

Deploying the smart contract to Abstract Testnet

To deploy a smart contract using Foundry, you can use the forge create command. The command requires you to specify the smart contract you want to deploy, an RPC URL of the network you want to deploy to, and the account you want to deploy with.

Info: Your wallet must be funded with ETH on the Abstract Testnet and Arbitrum Testnet to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH, see the prerequisites.

To deploy the ExampleContract smart contract to the Abstract Sepolia testnet, run the following command:

forge create ./src/ExampleContract.sol:ExampleContract --rpc-url $ABSTRACT_TESTNET_RPC --constructor-args $ABSTRACT_TESTNET_LZ_ENDPOINT --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

After running the command above, the contract will be deployed on the Abstract Sepolia testnet. You can view the deployment status and contract by using a block explorer.

Deploying the smart contract to Arbitrum Testnet

To deploy the ExampleContract smart contract to the Arbitrum Sepolia testnet, run the following command:

forge create ./src/ExampleContract.sol:ExampleContract --rpc-url $ARBITRUM_TESTNET_RPC --constructor-args $ARBITRUM_TESTNET_LZ_ENDPOINT --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

After running the command above, the contract will be deployed on the Arbitrum Sepolia testnet. You can view the deployment status and contract by using the Arbitrum Sepolia block explorer.

Opening the messaging channels

Once your contract has been deployed to Abstract Sepolia and Arbitrum Sepolia, you will need to open the messaging channels between the two contracts so that they can send and receive messages from one another. This is done by calling the setPeer function on the contract.

The setPeer function expects the following arguments:

Name	Type	Description
`_eid`	`uint32`	The endpoint ID of the destination chain.
`_peer`	`bytes32`	The contract address of the OApp contract on the destination chain.

Setting the peers

Foundry provides the cast command-line tool that can be used to interact with deployed smart contracts and call their functions.

To set the peer of your ExampleContract contracts, you can use cast to call the setPeer function while providing the endpoint ID and address (in bytes) of the deployed contract on the respective destination chain.

To set the peer of the Abstract Sepolia contract to the Arbitrum Sepolia contract, run the following command:

cast send <ABSTRACT_TESTNET_CONTRACT_ADDRESS> --rpc-url $ABSTRACT_TESTNET_RPC "setPeer(uint32, bytes32)" $ARBITRUM_TESTNET_LZ_ENDPOINT_ID <ARBITRUM_TESTNET_CONTRACT_ADDRESS> --account deployer

Info: Replace <ABSTRACT_TESTNET_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Abstract Sepolia, and<ARBITRUM_TESTNET_CONTRACT_ADDRESS> with the contract address (as bytes) of your deployed ExampleContract contract on Arbitrum Sepolia before running the provided cast command.

To set the peer of the Arbitrum Sepolia contract to the Abstract Sepolia contract, run the following command:

cast send <ARBITRUM_TESTNET_CONTRACT_ADDRESS> --rpc-url $ARBITRUM_TESTNET_RPC "setPeer(uint32, bytes32)" $ABSTRACT_TESTNET_LZ_ENDPOINT_ID <ABSTRACT_TESTNET_CONTRACT_ADDRESS> --account deployer

Info: Replace <ARBITRUM_TESTNET_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Arbitrum Sepolia, and<ABSTRACT_TESTNET_CONTRACT_ADDRESS> with the contract address (as bytes) of your deployed ExampleContract contract on Abstract Sepolia before running the provided cast command.

Sending messages

Once peers have been set on each contract, they are now able to send and receive messages from one another.

Sending a message using the newly created ExampleContract contract can be done in three steps:

Build message options to specify logic associated with the message transaction
Call the estimateFee function to estimate the gas fee for sending a message
Call the sendMessage function to send a message

Building message options

The estimateFee and sendMessage custom functions of the ExampleContract contract both require a message options (_options) argument to be provided.

Message options allow you to specify arbitrary logic as part of the message transaction, such as the gas amount the Executor pays for message delivery, the order of message execution, or dropping an amount of gas to a destination address.

LayerZero provides a Solidity library and TypeScript SDK for building these message options.

As an example, below is a Foundry script that uses OptionsBuilder from the Solidity library to generate message options (as bytes) that set the gas amount that the Executor will pay upon message delivery to 200000 wei:

pragma solidity ^0.8.0;

import {Script, console2} from "forge-std/Script.sol";
import { OptionsBuilder } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/libs/OptionsBuilder.sol";

contract OptionsScript is Script {
    using OptionsBuilder for bytes;

    function setUp() public {}

    function run() public {
        bytes memory options = OptionsBuilder.newOptions().addExecutorLzReceiveOption(200000, 0);
        console2.logBytes(options);
    }
}

The output of this script results in:

0x00030100110100000000000000000000000000030d40

For this tutorial, rather than building and generating your own message options, you can use the bytes output provided above.

Info: Covering all of the different message options in detail is out of scope for this tutorial. If you are interested in learning more about the different message options and how to build them, visit the LayerZero developer documentation.

Estimating the gas fee

Before you can send a message from your contract on Abstract Sepolia, you need to estimate the fee associated with sending the message. You can use the cast command to call the estimateFee() function of the ExampleContract contract.

To estimate the gas fee for sending a message from Abstract Sepolia to Arbitrum Sepolia, run the following command:

cast send <ABSTRACT_TESTNET_CONTRACT_ADDRESS> --rpc-url $ABSTRACT_TESTNET_RPC "estimateFee(uint32, string, bytes)" $ARBITRUM_TESTNET_LZ_ENDPOINT_ID "Hello World" 0x00030100110100000000000000000000000000030d40 --account deployer

Info: Replace <ABSTRACT_TESTNET_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Abstract Sepolia before running the provided cast command.

The command above calls estimateFee(uint32, string, bytes, bool), while providing the required arguments, including: the endpoint ID of the destination chain, the text to send, and the message options (generated in the last section).

Sending the message

Once you have fetched the estimated gas for sending your message, you can now call sendMessage and provide the value returned as the msg.value.

For example, to send a message from Abstract Sepolia to Arbitrum Sepolia with an estimated gas fee, run the following command:

cast send <ABSTRACT_TESTNET_CONTRACT_ADDRESS> --rpc-url $ABSTRACT_TESTNET_RPC --value <GAS_ESTIMATE_IN_WEI> "sendMessage(uint32, string, bytes)" $ARBITRUM_TESTNET_LZ_ENDPOINT_ID "Hello World" 0x00030100110100000000000000000000000000030d40 --account deployer

Info: Replace <ABSTRACT_TESTNET_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Abstract Sepolia, and <GAS_ESTIMATE_IN_WEI> with the gas estimate (in wei) returned by the call to estimateFee, before running the provided cast command.

You can view the status of your cross-chain transaction on LayerZero Scan.

Receiving the message

Once the message has been sent and received on the destination chain, the _Receive function will be called on the ExampleContract and the message payload will be stored in the contract's public data variable.

You can use the cast command to read the latest message received by the ExampleContract stored in the data variable.

To read the latest received message data that was sent to Arbitrum Sepolia from Abstract Sepolia, run the following command:

cast send <ARBITRUM_TESTNET_CONTRACT_ADDRESS> --rpc-url $ARBITRUM_TESTNET_RPC "data" --account deployer

The returned data should match the message text payload you sent in your message.

You can view the status of your cross-chain transaction on LayerZero Scan.

Conclusion

Congratulations! You have successfully learned how to perform cross-chain messaging between Abstract and other chains (i.e. Arbitrum) using LayerZero V2.

To learn more about cross-chain messaging and LayerZero V2, check out the following resources:

LayerZero V2

Deploying a smart contract to Abstract using Hardhat

Taylor Caldwell — Mon, 27 Jan 2025 06:17:43 +0000

This tutorial will guide you through deploying an NFT smart contract (ERC-721) on the Abstract test network using Hardhat.

Hardhat is a developer tool that provides a simple way to deploy, test, and debug smart contracts.

Objectives

By the end of this tutorial, you should be able to do the following:

Setup Hardhat for Abstract
Create an NFT smart contract for Abstract
Compile a smart contract for Abstract
Deploy a smart contract to Abstract
Interact with a smart contract deployed on Abstract

Prerequisites

Node v18+

This tutorial requires you have Node version 18+ installed.

Download Node v18+

If you are using nvm to manage your node versions, you can just run nvm install 18.

Metamask Wallet

In order to deploy a smart contract, you will first need a crypto wallet. You can create a wallet by downloading the Metamask browser extension.

Download Metamask

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Abstract Sepolia test network. You can fund your wallet with Abstract Sepolia ETH using a bridge or faucet.

Creating a project

Before you can begin deploying smart contracts to Abstract, you need to set up your development environment by creating a Node.js project.

To create a new Node.js project, run:

npm init --y

Next, you will need to install Hardhat and create a new Hardhat project

To install Hardhat, run:

npm install --save-dev hardhat

To create a new Hardhat project, run:

npx hardhat init

Select Create a TypeScript project then press enter to confirm the project root.

Select y for both adding a .gitignore and loading the sample project. It will take a moment for the project setup process to complete.

Configuring Hardhat with Abstract

In order to deploy smart contracts to the Abstract network, you will need to configure your Hardhat project and add the Abstract network.

To configure Hardhat to use Abstract, add Abstract as a network to your project's hardhat.config.ts file:

import { HardhatUserConfig } from 'hardhat/config';
import '@nomicfoundation/hardhat-toolbox';

require('dotenv').config();

const config: HardhatUserConfig = {
  solidity: {
    version: '0.8.23',
  },
  networks: {
    // for mainnet
    'abstract-mainnet': {
      url: 'https://api.mainnet.abs.xyz',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
    // for testnet
    'abstract-testnet': {
      url: 'https://api.testnet.abs.xyz',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
    // for local dev environment
    'abstract-local': {
      url: 'http://localhost:8545',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
  },
  defaultNetwork: 'hardhat',
};

export default config;

Install Hardhat toolbox

The above configuration uses the @nomicfoundation/hardhat-toolbox plugin to bundle all the commonly used packages and Hardhat plugins recommended to start developing with Hardhat.

To install @nomicfoundation/hardhat-toolbox, run:

npm install --save-dev @nomicfoundation/hardhat-toolbox

Loading environment variables

The above configuration also uses dotenv to load the WALLET_KEY environment variable from a .env file to process.env.WALLET_KEY. You should use a similar method to avoid hardcoding your private keys within your source code.

To install dotenv, run:

npm install --save-dev dotenv

Once you have dotenv installed, you can create a .env file with the following content:

WALLET_KEY="<YOUR_PRIVATE_KEY>"

Substituting <YOUR_PRIVATE_KEY> with the private key for your wallet.

Caution: WALLET_KEY is the private key of the wallet to use when deploying a contract. For instructions on how to get your private key from Metamask, visit the Metamask Support page. It is critical that you do NOT commit this to a public repo.

Local Networks

For quick testing, such as if you want to add unit tests to the below NFT contract, you may wish to leave the defaultNetwork as 'hardhat'.

Compiling the smart contract

Below is a simple NFT smart contract (ERC-721) written in the Solidity programming language:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract NFT is ERC721 {
    uint256 public currentTokenId;

    constructor() ERC721("NFT Name", "NFT") {}

    function mint(address recipient) public payable returns (uint256) {
        uint256 newItemId = ++currentTokenId;
        _safeMint(recipient, newItemId);
        return newItemId;
    }
}

The Solidity code above defines a smart contract named NFT. The code uses the ERC721 interface provided by the OpenZeppelin Contracts library to create an NFT smart contract. OpenZeppelin allows developers to leverage battle-tested smart contract implementations that adhere to official ERC standards.

To add the OpenZeppelin Contracts library to your project, run:

npm install --save @openzeppelin/contracts

In your project, delete the contracts/Lock.sol contract that was generated with the project and add the above code in a new file called contracts/NFT.sol. (You can also delete the test/Lock.ts test file, but you should add your own tests ASAP!).

To compile the contract using Hardhat, run:

npx hardhat compile

Deploying the smart contract

Once your contract has been successfully compiled, you can deploy the contract to the Abstract Sepolia test network.

To deploy the contract to the Abstract Sepolia test network, you'll need to modify the scripts/deploy.ts in your project:

import { ethers } from 'hardhat';

async function main() {
  const nft = await ethers.deployContract('NFT');

  await nft.waitForDeployment();

  console.log('NFT Contract Deployed at ' + nft.target);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

You'll also need testnet ETH in your wallet. See the prerequisites if you haven't done that yet. Otherwise, the deployment attempt will fail.

Finally, run:

npx hardhat run scripts/deploy.ts --network abstract-testnet

The contract will be deployed on the Abstract Sepolia test network. You can view the deployment status and contract by using a block explorer and searching for the address returned by your deploy script. If you've deployed an exact copy of the NFT contract above, it will already be verified and you'll be able to read and write to the contract using the web interface.

Info: If you'd like to deploy to mainnet, you'll modify the command like so:
npx hardhat run scripts/deploy.ts --network abstract-mainnet

Regardless of the network you're deploying to, if you're deploying a new or modified contract, you'll need to verify it first.

Verifying the Smart Contract

If you want to interact with your contract on the block explorer, you, or someone, needs to verify it first. The above contract has already been verified, so you should be able to view your version on a block explorer already. For the remainder of this tutorial, we'll walk through how to verify your contract on Abstract Sepolia testnet.

In hardhat.config.ts, configure Abstract Sepolia as a custom network. Add the following to your HardhatUserConfig:

etherscan: {
   apiKey: {
    "abstract-testnet": "PLACEHOLDER_STRING"
   },
   customChains: [
     {
       network: "abstract-testnet",
       chainId: 11124,
       urls: {
        apiURL: "https://api-sepolia.abscan.org/api",
        browserURL: "https://sepolia.abscan.org/"
       }
     }
   ]
 },

Info: You can get your AbsScan API key from abscan.org when you sign up for an account.

Now, you can verify your contract. Grab the deployed address and run:

npx hardhat verify --network abstract-testnet <deployed address>

You should see an output similar to:

Nothing to compile
No need to generate any newer typings.
Successfully submitted source code for contract
contracts/NFT.sol:NFT at 0x1234567890ABCDEF01234567890ABCDEF0123456
for verification on the block explorer. Waiting for verification result...

Successfully verified contract NFT on Etherscan.

Info: You can't re-verify a contract identical to one that has already been verified. If you attempt to do so, such as verifying the above contract, you'll get an error similar to:
Error in plugin @nomiclabs/hardhat-etherscan: The API responded with an unexpected message.
Contract verification may have succeeded and should be checked manually.
Message: Already Verified

Search for your contract on AbsScan to confirm it is verified.

Interacting with the Smart Contract

If you verified on AbsScan, you can use the Read Contract and Write Contract tabs to interact with the deployed contract. You'll need to connect your wallet first, by clicking the Connect button.

Deploying a smart contract to Abstract using Foundry

Taylor Caldwell — Mon, 27 Jan 2025 06:04:48 +0000

This article will provide an overview of the Foundry development toolchain, and show you how to deploy a contract to Abstract Sepolia testnet.

Foundry is a powerful suite of tools to develop, test, and debug your smart contracts. It comprises several individual tools:

forge: the main workhorse of Foundry — for developing, testing, compiling, and deploying smart contracts
cast: a command-line tool for performing Ethereum RPC calls (e.g., interacting with contracts, sending transactions, and getting onchain data)
anvil: a local testnet node, for testing contract behavior from a frontend or over RPC
chisel: a Solidity REPL, for trying out Solidity snippets on a local or forked network

Foundry offers extremely fast feedback loops (due to the under-the-hood Rust implementation) and less context switching — because you'll be writing your contracts, tests, and deployment scripts All in Solidity!

Info: For production / mainnet deployments the steps below in this tutorial will be almost identical, however, you'll want to ensure that you've configured Abstract (mainnet) as the network rather than Abstract Sepolia (testnet).

Objectives

By the end of this tutorial, you should be able to do the following:

Setup Foundry for Abstract
Create an NFT smart contract for Abstract
Compile a smart contract for Abstract (using forge)
Deploy a smart contract to Abstract (also with forge)
Interact with a smart contract deployed on Abstract (using cast)

Prerequisites

Foundry

This tutorial requires you have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Metamask Wallet

In order to deploy a smart contract, you will first need a crypto wallet. You can create a wallet by downloading the Metamask browser extension.

Download Metamask

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Abstract Sepolia test network. You can fund your wallet with Abstract Sepolia ETH using a bridge or faucet.

Creating a project

Before you can begin deploying smart contracts to Abstract, you need to set up your development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project, which has the following basic layout:

.
├── foundry.toml
├── script
 │   └── Counter.s.sol
├── src
 │   └── Counter.sol
└── test
    └── Counter.t.sol

Compiling the smart contract

Below is a simple NFT smart contract (ERC-721) written in the Solidity programming language:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "openzeppelin-contracts/contracts/token/ERC721/ERC721.sol";

contract NFT is ERC721 {
    uint256 public currentTokenId;

    constructor() ERC721("NFT Name", "NFT") {}

    function mint(address recipient) public payable returns (uint256) {
        uint256 newItemId = ++currentTokenId;
        _safeMint(recipient, newItemId);
        return newItemId;
    }
}

To add the OpenZeppelin Contracts library to your project, run:

forge install openzeppelin/openzeppelin-contracts

In your project, delete the src/Counter.sol contract that was generated with the project and add the above code in a new file called src/NFT.sol. (You can also delete the test/Counter.t.sol and script/Counter.s.sol files, but you should add your own tests ASAP!).

To compile our basic NFT contract using Foundry, run:

forge build

Configuring Foundry with Abstract

Next, you will configure your Foundry project to deploy smart contracts to the Abstract network. First you'll store your private key in an encrypted keystore, then you'll add Abstract as a network.

Storing your private key

The following command will import your private key to Foundry's secure keystore. You will be prompted to enter your private key, as well as a password for signing transactions:

cast wallet import deployer --interactive

Caution: For instructions on how to get your private key from Metamask, visit the Metamask Support page. It is critical that you do NOT commit this to a public repo.

Run this command to confirm that the 'deployer' account is setup in Foundry:

cast wallet list

Adding Abstract as a network

When verifying a contract with AbsScan, you need an API key. You can get your AbsScan API key from here after you sign up for an account.

Caution: Although they're made by the same folks, Etherscan API keys will not work on AbsScan!

Now create a .env file in the home directory of your project to add the Abstract network and an API key for verifying your contract on AbsScan:

ABSTRACT_MAINNET_RPC="https://api.mainnet.abs.xyz"
ABSTRACT_TESTNET_RPC="https://api.testnet.abs.xyz"
ETHERSCAN_API_KEY="<YOUR API KEY>"

Note: Even though you're using AbsScan your block explorer, Foundry expects the API key to be defined as ETHERSCAN_API_KEY.

Loading environment variables

Now that you've created the above .env file, run the following command to load the environment variables in the current command line session:

source .env

Deploying the smart contract

With your contract compiled and your environment configured, you are ready to deploy to the Abstract Sepolia test network!

Today, you'll use the forge create command, which is a straightforward way to deploy a single contract at a time. In the future, you may want to look into forge script, which enables scripting onchain transactions and deploying more complex smart contract projects.

You'll need testnet ETH in your wallet. See the prerequisites if you haven't done that yet. Otherwise, the deployment attempt will fail.

To deploy the contract to the Abstract Sepolia test network, run the following command. You will be prompted to enter the password that you set earlier, when you imported your private key:

forge create ./src/NFT.sol:NFT --rpc-url $ABSTRACT_TESTNET_RPC --account deployer

Info: If you'd like to deploy to mainnet, you'll modify the command like so:

forge create ./src/NFT.sol:NFT --rpc-url $ABSTRACT_MAINNET_RPC --account deployer

Regardless of the network you're deploying to, if you're deploying a new or modified contract, you'll need to verify it.

Verifying the Smart Contract

In web3, it's considered best practice to verify your contracts so that users and other developers can inspect the source code, and be sure that it matches the deployed bytecode on the blockchain.

Further, if you want to allow others to interact with your contract using the block explorer, it first needs to be verified. The above contract has already been verified, so you should be able to view your version on a block explorer already, but we'll still walk through how to verify a contract on Abstract Sepolia testnet.

Info: Remember, you need an API key from AbsScan to verify your contracts. You can get your API key from the AbsScan site after you sign up for an account.

Grab the deployed address and run:

forge verify-contract <DEPLOYED_ADDRESS> ./src/NFT.sol:NFT --chain 11124 --watch

You should see an output similar to:

Start verifying contract `0x1234567890ABCDEF01234567890ABCDEF0123456` deployed on abstract-testnet

Submitting verification for [src/NFT.sol:NFT] 0x1234567890ABCDEF01234567890ABCDEF0123456.
Submitted contract for verification:
        Response: `OK`
        https://sepolia.abscan.org/address/0x1234567890ABCDEF01234567890ABCDEF0123456
Contract verification status:
Response: `NOTOK`
Details: `Pending in queue`
Contract verification status:
Response: `OK`
Details: `Pass - Verified`
Contract successfully verified

Search for your contract on AbsScan to confirm it is verified.

Info: You can't re-verify a contract identical to one that has already been verified. If you attempt to do so, such as verifying the above contract, you'll get an error similar to:
Start verifying contract `0x1234567890ABCDEF01234567890ABCDEF0123456` deployed on abstract-testnet

Contract [src/NFT.sol:NFT] "0x1234567890ABCDEF01234567890ABCDEF0123456" is already verified. Skipping verification.

Interacting with the Smart Contract

If you verified on AbsScan, you can use the Read Contract and Write Contract sections under the Contract tab to interact with the deployed contract. To use Write Contract, you'll need to connect your wallet first, by clicking the Connect to Web3 button (sometimes this can be a little finicky, and you'll need to click Connect twice before it shows your wallet is successfully connected).

To practice using the cast command-line tool which Foundry provides, you'll perform a call without publishing a transaction (a read), then sign and publish a transaction (a write).

Performing a call

A key component of the Foundry toolkit, cast enables us to interact with contracts, send transactions, and get onchain data using Ethereum RPC calls. First you will perform a call from your account, without publishing a transaction.

From the command-line, run:

cast call <DEPLOYED_ADDRESS> --rpc-url $ABSTRACT_TESTNET_RPC "balanceOf(address)" <YOUR_ADDRESS_HERE>

You should receive 0x0000000000000000000000000000000000000000000000000000000000000000 in response, which equals 0 in hexadecimal. And that makes sense — while you've deployed the NFT contract, no NFTs have been minted yet and therefore your account's balance is zero.

Signing and publishing a transaction

Now, sign and publish a transaction, calling the mint(address) function on the NFT contract you just deployed.

Run the following command:

cast send <DEPLOYED_ADDRESS> --rpc-url=$ABSTRACT_TESTNET_RPC "mint(address)" <YOUR_ADDRESS_HERE> --account deployer

Info: Note that in this cast send command, you had to include your private key, but this is not required for cast call, because that's for calling view-only contract functions and therefore you don't need to sign anything.

If successful, Foundry will respond with information about the transaction, including the blockNumber, gasUsed, and transactionHash.

Finally, let's confirm that you did indeed mint yourself one NFT. If you run the first cast call command again, you should see that your balance increased from 0 to 1:

cast call <DEPLOYED_ADDRESS> --rpc-url $ABSTRACT_TESTNET_RPC "balanceOf(address)" <YOUR_ADDRESS_HERE>

And the response: 0x0000000000000000000000000000000000000000000000000000000000000001 (1 in hex) — congratulations, you deployed a contract and minted an NFT with Foundry!

Conclusion

Phew, that was a lot! You learned how to setup a project, deploy to Abstract, and interact with our smart contract using Foundry. The process is the same for real networks, just more expensive — and of course, you'll want to invest time and effort testing your contracts, to reduce the likelihood of user-impacting bugs before deploying.

For all things Foundry, check out the Foundry book, or head to the official Telegram dev chat or support chat.

Generating random numbers contracts on Base using Supra dVRF

Taylor Caldwell — Mon, 27 Jan 2025 04:29:13 +0000

This tutorial will guide you through the process of creating a smart contract on Base that utilizes Supra dVRF to serve random numbers using an onchain randomness generation mechanism directly within your smart contracts.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Base using Foundry
Install the Supra dVRF as a dependency
Use Supra dVRF within your smart contract
Deploy and test your smart contracts on Base

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Coinbase Wallet

In order to deploy a smart contract, you will first need a wallet. You can create a wallet by downloading the Coinbase Wallet browser extension.

Download Coinbase Wallet

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Base Sepolia test network. You can fund your wallet with Base Sepolia ETH using one of the faucets listed on the Base Network Faucets page.

Supra wallet registration

Caution: Supra dVRF V2 requires subscription to the service with a customer controlled wallet address to act as the main reference.

Therefore you must register your wallet with the Supra team if you plan to consume Supra dVRF V2 within your smart contracts.

Please refer to the Supra documentation for the latest steps on how to register your wallet for their service.

What is a Verifiable Random Function (VRF)?

A Verifiable Random Function (VRF) provides a solution for generating random outcomes in a manner that is both decentralized and verifiably recorded onchain. VRFs are crucial for applications where randomness integrity is paramount, such as in gaming or prize drawings.

Supra dVRF provides a decentralized VRF that ensures that the outcomes are not only effectively random but also responsive, scalable, and easily verifiable, thereby addressing the unique needs of onchain applications for trustworthy and transparent randomness.

Creating a project

Before you can begin writing smart contracts for Base, you need to set up your development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project, which has the following basic layout:

.
├── foundry.toml
├── script
 │   └── Counter.s.sol
├── src
 │   └── Counter.sol
└── test
    └── Counter.t.sol

Writing the Smart Contract

Once your Foundry project has been created, you can now start writing a smart contract.

The Solidity code below defines a basic contract named RNGContract. The smart contract's constructor takes in a single address and assigns it to a member variable named supraAddr. This address corresponds to the contract address of the Supra Router Contract that will be used to generate random numbers. The contract address of the Supra Router Contract on Base Sepolia testnet is 0x99a021029EBC90020B193e111Ae2726264a111A2.

The contract also assigns the contract deployer (msg.sender) to a member variable named supraClientAddress. This should be the client wallet address that is registered and whitelisted to use Supra VRF (see: Prerequisites).

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract RNGContract {
    address supraAddr;
    address supraClientAddress;

    constructor(address supraSC) {
        supraAddr = supraSC;
        supraClientAddress = msg.sender;
    }
}

In your project, add the code provided above to a new file named src/ExampleContract.sol, and delete the src/Counter.sol contract that was generated with the project. (you can also delete the test/Counter.t.sol and script/Counter.s.sol files).

The following sections will guide you step-by-step on how to update your contract to generate random numbers using the Supra Router contract.

Adding the Supra Router Contract interface

In order to help your contract (the requester contract) interact with the Supra Router contract and understand what methods it can call, you will need to add the following interface to your contract file.

interface ISupraRouter {
    function generateRequest(string memory _functionSig, uint8 _rngCount, uint256 _numConfirmations, uint256 _clientSeed, address _clientWalletAddress) external returns(uint256);
    function generateRequest(string memory _functionSig, uint8 _rngCount, uint256 _numConfirmations, address _clientWalletAddress) external returns(uint256);
}

The ISupraRouter interface defines a generateRequest function. This function is used to create a request for random numbers. The generateRequest function is defined twice, because one of the definitions allows for an optional _clientSeed (defaults to 0) for additional unpredictability.

Info: Alternatively, you can add the ISupraRouter interface in a separate interface file and inherit the interface in your contract.

Adding a request function

Once you have defined the ISupraRouter, you are ready to add the logic to your smart contract for requesting random numbers.

For Supra dVRF, adding logic for requesting random numbers requires two functions:

A request function
A callback function

The request function is a custom function defined by the developer. There are no requirements when it comes to the signature of the request function.

The following code is an example of a request function named rng that requests random numbers using the Supra Router Contract. Add this function to your smart contract:

function rng() external returns (uint256) {
    // Amount of random numbers to request
    uint8 rngCount = 5;
    // Amount of confirmations before the request is considered complete/final
    uint256 numConfirmations = 1;
    uint256 nonce = ISupraRouter(supraAddr).generateRequest(
        "requestCallback(uint256,uint256[])",
        rngCount,
        numConfirmations,
        supraClientAddress
    );
    return nonce;
    // store nonce if necessary (e.g., in a hashmap)
    // this can be used to track parameters related to the request in a lookup table
    // these can be accessed inside the callback since the response from supra will include the nonce
}

The rng function above requests 5 random numbers (defined by rngCount), and waits 1 confirmation (defined by numConfirmations) before considering the result to be final. It makes this request by calling the generateRequest function of the Supra Router contract, while providing a callback function with the signature requestCallback(uint256,uint256[]).

Adding a callback function

As seen in the previous section, the generateRequest method of the Supra Router contract expects a signature for a callback function. This callback function must be of the form: uint256 nonce, uint256[] calldata rngList, and must include validation code, such that only the Supra Router contract can call the function.

To do this, add the following callback function (requestCallback) to your smart contract:

function requestCallback(uint256 _nonce ,uint256[] _rngList) external {
    require(msg.sender == supraAddr, "Only the Supra Router can call this function.");
    uint8 i = 0;
    uint256[] memory x = new uint256[](rngList.length);
    rngForNonce[nonce] = x;
    for(i=0; i<rngList.length;i++){
        rngForNonce[nonce][i] = rngList[i] % 100;
    }
}

Once a random number is generated, requestCallback is executed by the Supra Router. The code above stores the resulting random numbers list in a map named rngForNonce using the _nonce argument. Because of this, you will need to add the following mapping to your contract:

mapping (uint256 => uint256[] ) rngForNonce;

Adding a function to view the result

To fetch resulting random numbers based on their associated nonce, you add a third function:

function viewRngForNonce(uint256 nonce) external view returns (uint256[] memory) {
    return rngForNonce[nonce];
}

Final smart contract code

After following all the steps above, your smart contract code should look like the following:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface ISupraRouter {
    function generateRequest(string memory _functionSig, uint8 _rngCount, uint256 _numConfirmations, uint256 _clientSeed, address _clientWalletAddress) external returns (uint256);
    function generateRequest(string memory _functionSig, uint8 _rngCount, uint256 _numConfirmations, address _clientWalletAddress) external returns (uint256);
}

contract RNGContract {
    address supraAddr;
    address supraClientAddress;

    mapping (uint256 => uint256[]) rngForNonce;

    constructor(address supraSC) {
        supraAddr = supraSC;
        supraClientAddress = msg.sender;
    }

    function rng() external returns (uint256) {
        // Amount of random numbers to request
        uint8 rngCount = 5;
        // Amount of confirmations before the request is considered complete/final
        uint256 numConfirmations = 1;
        uint256 nonce = ISupraRouter(supraAddr).generateRequest(
            "requestCallback(uint256,uint256[])",
            rngCount,
            numConfirmations,
            supraClientAddress
        );
        return nonce;
    }

    function requestCallback(uint256 _nonce, uint256[] memory _rngList) external {
        require(msg.sender == supraAddr, "Only the Supra Router can call this function.");
        uint8 i = 0;
        uint256[] memory x = new uint256[](_rngList.length);
        rngForNonce[_nonce] = x;
        for (i = 0; i < _rngList.length; i++) {
            rngForNonce[_nonce][i] = _rngList[i] % 100;
        }
    }

    function viewRngForNonce(uint256 nonce) external view returns (uint256[] memory) {
        return rngForNonce[nonce];
    }
}

Caution: You must whitelist this smart contract under the wallet address you registered with Supra, and deposit funds to be paid for the gas fees associated with transactions for your callback function.

Follow the guidance steps provided by Supra for whitelisting your contract and depositing funds.

If you have not yet registered your wallet with Supra, see the Prerequisites section.

Compiling the Smart Contract

To compile your smart contract code, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to the Base network, you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Coinbase Wallet, visit the Coinbase Wallet documentation.

It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables for Base Sepolia

To setup your environment for deploying to the Base network, create an .env file in the home directory of your project, and add the RPC URL for the Base Sepolia testnet, as well as the Supra Router contract address for Base Sepolia testnet:

BASE_SEPOLIA_RPC="https://sepolia.base.org"
ISUPRA_ROUTER_ADDRESS=0x99a021029EBC90020B193e111Ae2726264a111A2

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

Deploying the smart contract to Base Sepolia

With your contract compiled and environment setup, you are ready to deploy the smart contract to the Base Sepolia Testnet!

To deploy the RNGContract smart contract to the Base Sepolia test network, run the following command:

forge create ./src/RNGContract.sol:RNGContract --rpc-url $BASE_SEPOLIA_RPC --constructor-args $ISUPRA_ROUTER_ADDRESS --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet’s private key.

Info: Your wallet must be funded with ETH on the Base Sepolia Testnet to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH for Base Sepolia, see the prerequisites.

After running the command above, the contract will be deployed on the Base Sepolia test network. You can view the deployment status and contract by using a block explorer.

Interacting with the Smart Contract

Foundry provides the cast command-line tool that can be used to interact with the smart contract that was deployed and call the getLatestPrice() function to fetch the latest price of ETH.

To call the getLatestPrice() function of the smart contract, run:

cast call <DEPLOYED_ADDRESS> --rpc-url $BASE_SEPOLIA_RPC "rng()"

You should receive a nonce value.

You can use this nonce value to call the viewRngForNonce(uint256) function to get the resulting list of randomly generated numbers:

cast call <DEPLOYED_ADDRESS> --rpc-url $BASE_SEPOLIA_RPC "viewRngForNonce(uint256)" <NONCE>

Conclusion

Congratulations! You have successfully deployed and interacted with a smart contract that generates a list of random numbers using Supra dVRF on the Base blockchain network.

To learn more about VRF and using Supra dVRF to generate random numbers within your smart contracts on Base, check out the following resources:

Accessing real-time asset data on Base using Pyth Price Feeds

Taylor Caldwell — Mon, 27 Jan 2025 04:29:05 +0000

This tutorial will guide you through the process of creating a smart contract on Base that utilizes Pyth Network oracles to consume a price feed.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Base using Foundry
Install the Pyth smart contracts
Consume a Pyth Network price feed within your smart contract
Deploy and test your smart contracts on Base

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Coinbase Wallet

In order to deploy a smart contract, you will first need a wallet. You can create a wallet by downloading the Coinbase Wallet browser extension.

Download Coinbase Wallet

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Base Sepolia test network. You can fund your wallet with Base Sepolia ETH using one of the faucets listed on the Base Network Faucets page.

What is Pyth Network?

Creating a project

Before you can begin writing smart contracts for Base and consuming Pyth price feeds, you need to set up your development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project, which has the following basic layout:

.
├── foundry.toml
├── script
 │   └── Counter.s.sol
├── src
 │   └── Counter.sol
└── test
    └── Counter.t.sol

Installing Pyth smart contracts

To use Pyth price feeds within your project, you need to install Pyth oracle contracts as a project dependency using forge install.

To install Pyth oracle contracts, run:

forge install pyth-network/pyth-sdk-solidity@v2.2.0 --no-git --no-commit

Once installed, update your foundry.toml file by appending the following line:

remappings = ['@pythnetwork/pyth-sdk-solidity/=lib/pyth-sdk-solidity']

Writing and compiling the Smart Contract

Once your project has been created and dependencies have been installed, you can now start writing a smart contract.

The Solidity code below defines a smart contract named ExampleContract. The code uses the IPyth interface from the Pyth Solidity SDK.

An instance ofIPyth is defined within the contract that provides functions for consuming Pyth price feeds. The constructor for the IPyth interface expects a contract address to be provided. This address provided in the code example below (0xA2aa501b19aff244D90cc15a4Cf739D2725B5729) corresponds to the Pyth contract address for the Base Sepolia testnet.

Info: Pyth also supports other EVM networks, such as Base Mainnet. For a list of all network contract addresses, visit the Pyth documentation.

Info: Pyth provides a number of price feeds. For a list of available price feeds, visit the Pyth documentation.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract ExampleContract {
  IPyth pyth;

  /**
  * Network: Base Sepolia (testnet)
  * Address: 0xA2aa501b19aff244D90cc15a4Cf739D2725B5729
  */
  constructor() {
    pyth = IPyth(0xA2aa501b19aff244D90cc15a4Cf739D2725B5729);
  }

  function getLatestPrice(
    bytes[] calldata priceUpdateData
  ) public payable returns (PythStructs.Price memory) {
    // Update the prices to the latest available values and pay the required fee for it. The `priceUpdateData` data
    // should be retrieved from our off-chain Price Service API using the `pyth-evm-js` package.
    // See section "How Pyth Works on EVM Chains" below for more information.
    uint fee = pyth.getUpdateFee(priceUpdateData);
    pyth.updatePriceFeeds{ value: fee }(priceUpdateData);

    bytes32 priceID = 0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace;
    // Read the current value of priceID, aborting the transaction if the price has not been updated recently.
    // Every chain has a default recency threshold which can be retrieved by calling the getValidTimePeriod() function on the contract.
    // Please see IPyth.sol for variants of this function that support configurable recency thresholds and other useful features.
    return pyth.getPrice(priceID);
  }
}

To compile the new smart contract, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to the Base network, you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Coinbase Wallet, visit the Coinbase Wallet documentation.

It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables for Base Sepolia

To setup your environment for deploying to the Base network, create an .env file in the home directory of your project, and add the RPC URL for the Base Sepolia testnet:

BASE_SEPOLIA_RPC="https://sepolia.base.org"

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

Deploying the smart contract to Base Sepolia

With your contract compiled and environment setup, you are ready to deploy the smart contract to the Base Sepolia Testnet!

To deploy the ExampleContract smart contract to the Base Sepolia test network, run the following command:

forge create ./src/ExampleContract.sol:ExampleContract --rpc-url $BASE_SEPOLIA_RPC --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

Info: Your wallet must be funded with ETH on the Base Sepolia Testnet to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH for Base Sepolia, see the prerequisites.

After running the command above, the contract will be deployed on the Base Sepolia test network. You can view the deployment status and contract by using a block explorer.

Interacting with the Smart Contract

curl https://hermes.pyth.network/api/latest_vaas?ids[]=0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace

cast call <DEPLOYED_ADDRESS> --rpc-url $BASE_SEPOLIA_RPC "getLatestPrice(bytes[])" <PRICE_UPDATE_DATA>

You should receive the latest ETH / USD price in hexadecimal form.

Conclusion

Congratulations! You have successfully deployed and interacted with a smart contract that consumes a Pyth Network oracle to access a real-time price feed on Base.

To learn more about Oracles and using Pyth Network price feeds within your smart contracts on Base, check out the following resources:

Accessing real-world data on Base using Chainlink Data Feeds

Taylor Caldwell — Mon, 27 Jan 2025 04:28:56 +0000

This tutorial will guide you through the process of creating a smart contract on Base that utilizes Chainlink Data Feeds to access real-world data, such as asset prices, directly from your smart contracts.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Base using Foundry
Install the Chainlink smart contracts
Consume a Chainlink price data feed within your smart contract
Deploy and test your smart contracts on Base

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Coinbase Wallet

In order to deploy a smart contract, you will first need a wallet. You can create a wallet by downloading the Coinbase Wallet browser extension.

Download Coinbase Wallet

Wallet funds

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Base Goerli test network. You can fund your wallet with Base Goerli ETH using one of the faucets listed on the Base Network Faucets page.

What are Chainlink Data Feeds?

Accurate price data is essential in DeFi applications. However, blockchain networks lack the capability to directly fetch external real-world data, leading to the "Oracle Problem".

Chainlink Data Feeds offer a solution to this problem by serving as a secure middleware layer that bridges the gap between real-world asset prices and onchain smart contracts.

Creating a project

Before you can begin writing smart contracts for Base and consuming Chainlink data feeds, you need to set up your development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project, which has the following basic layout:

.
├── foundry.toml
├── script
 │   └── Counter.s.sol
├── src
 │   └── Counter.sol
└── test
    └── Counter.t.sol

Installing Chainlink smart contracts

To use Chainlink's data feeds within your project, you need to install Chainlink smart contracts as a project dependency using forge install.

To install Chainlink smart contracts, run:

forge install smartcontractkit/chainlink --no-commit

Once installed, update your foundry.toml file by appending the following line:

remappings = ['@chainlink/contracts/=lib/chainlink/contracts']

Writing and compiling the Smart Contract

Once your project has been created and dependencies have been installed, you can now start writing a smart contract.

The Solidity code below defines a smart contract named DataConsumerV3. The code uses the AggregatorV3Interface interface from the Chainlink contracts library to provide access to price feed data.

The smart contract passes an address to AggregatorV3Interface. This address (0xcD2A119bD1F7DF95d706DE6F2057fDD45A0503E2) corresponds to the ETH/USD price feed on the Base Goerli network.

Info: Chainlink provides a number of price feeds for Base. For a list of available price feeds on Base, visit the Chainlink documentation.

   // SPDX-License-Identifier: MIT
   pragma solidity ^0.8.0;

   import "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";

   contract DataConsumerV3 {
       AggregatorV3Interface internal priceFeed;

      /**
       * Network: Base Goerli
       * Aggregator: ETH/USD
       * Address: 0xcD2A119bD1F7DF95d706DE6F2057fDD45A0503E2
       */
       constructor() {
           priceFeed = AggregatorV3Interface(0xcD2A119bD1F7DF95d706DE6F2057fDD45A0503E2);
       }

       function getLatestPrice() public view returns (int) {
           (
               /* uint80 roundID */,
               int price,
               /* uint startedAt */,
               /* uint timeStamp */,
               /* uint80 answeredInRound */
           ) = priceFeed.latestRoundData();
           return price;
       }
   }

In your project, add the code provided above to a new file named src/DataConsumerV3.sol, and delete the src/Counter.sol contract that was generated with the project. (you can also delete the test/Counter.t.sol and script/Counter.s.sol files).

To compile the new smart contract, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to the Base network, you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Coinbase Wallet, visit the Coinbase Wallet documentation.

It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables for Base Goerli

To setup your environment for deploying to the Base network, create an .env file in the home directory of your project, and add the RPC URL for the Base Goerli testnet:

BASE_GOERLI_RPC="https://goerli.base.org"

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

Deploying the smart contract to Base Goerli

With your contract compiled and environment setup, you are ready to deploy the smart contract to the Base Goerli Testnet!

To deploy the DataConsumerV3 smart contract to the Base Goerli test network, run the following command:

forge create ./src/DataConsumerV3.sol:DataConsumerV3 --rpc-url $BASE_GOERLI_RPC --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

Info: Your wallet must be funded with ETH on the Base Goerli Testnet to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH for Base Goerli, see the prerequisites.

After running the command above, the contract will be deployed on the Base Goerli test network. You can view the deployment status and contract by using a block explorer.

Interacting with the Smart Contract

Foundry provides the cast command-line tool that can be used to interact with the smart contract that was deployed and call the getLatestPrice() function to fetch the latest price of ETH.

To call the getLatestPrice() function of the smart contract, run:

cast call <DEPLOYED_ADDRESS> --rpc-url $BASE_GOERLI_RPC "getLatestPrice()"

You should receive the latest ETH / USD price in hexadecimal form.

Conclusion

Congratulations! You have successfully deployed and interacted with a smart contract that consumes a Chainlink price feed on the Base blockchain network.

To learn more about Oracles and using Chainlink to access real-world data within your smart contracts on Base, check out the following resources:

Sending messages from Base to other chains using LayerZero V2

Taylor Caldwell — Mon, 27 Jan 2025 04:28:48 +0000

This tutorial will guide you through the process of sending cross-chain message data from a Base smart contract to another smart contract on a different chain using LayerZero V2.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Base using Foundry
Install the LayerZero smart contracts as a dependency
Use LayerZero to send messages and from smart contracts on Base to smart contracts on different chains
Deploy and test your smart contracts on Base testnet

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Coinbase Wallet

In order to deploy a smart contract, you will first need a wallet. You can create a wallet by downloading the Coinbase Wallet browser extension.

Download Coinbase Wallet

Wallet funds

To complete this tutorial, you will need to fund a wallet with ETH on Base Goerli and Optimism Goerli.

The ETH is required for covering gas fees associated with deploying smart contracts to each network.

To fund your wallet with ETH on Base Goerli, visit a faucet listed on the Base Faucets page.
To fund your wallet with ETH on Optimism Goerli, visit a faucet listed on the Optimism Faucets page.

What is LayerZero?

The LayerZero protocol is made up of immutable on-chain Endpoints, a configurable Security Stack, and a permissionless set of Executors that transfer messages between chains.

High-level concepts

Endpoints

Security Stack (DVNs)

Executors

Creating a project

Before you begin, you need to set up your smart contract development environment by creating a Foundry project.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project with the following basic layout:

.
├── foundry.toml
├── script
├── src
└── test

Info: You can delete the src/Counter.sol, test/Counter.t.sol, and script/Counter.s.sol boilerplate files that were generated with the project, as you will not be needing them.

Installing the LayerZero smart contracts

To use LayerZero within your Foundry project, you need to install the LayerZero smart contracts and their dependencies using forge install.

To install LayerZero smart contracts and their dependencies, run the following commands:

forge install GNSPS/solidity-bytes-utils --no-commit
forge install OpenZeppelin/openzeppelin-contracts@v4.9.4 --no-commit
forge install LayerZero-Labs/LayerZero-v2 --no-commit

Once installed, update your foundry.toml file by appending the following lines:

remappings = [
    '@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts',
    'solidity-bytes-utils/=lib/solidity-bytes-utils',
    '@layerzerolabs/lz-evm-oapp-v2/=lib/LayerZero-v2/oapp',
    '@layerzerolabs/lz-evm-protocol-v2/=lib/LayerZero-v2/protocol',
    '@layerzerolabs/lz-evm-messagelib-v2/=lib/LayerZero-v2/messagelib',
]

Getting started with LayerZero

LayerZero provides a smart contract standard called OApp that is intended for omnichain messaging and configuration.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { OAppSender } from "./OAppSender.sol";
import { OAppReceiver, Origin } from "./OAppReceiver.sol";
import { OAppCore } from "./OAppCore.sol";

abstract contract OApp is OAppSender, OAppReceiver {
   constructor(address _endpoint) OAppCore(_endpoint, msg.sender) {}

   function oAppVersion() public pure virtual returns (uint64 senderVersion, uint64 receiverVersion) {
       senderVersion = SENDER_VERSION;
       receiverVersion = RECEIVER_VERSION;
   }
}

Info: You can view the source code for this contract on GitHub.

To get started using LayerZero, developers simply need to inherit from the OApp contract, and implement the following two inherited functions:

_lzSend: A function used to send an omnichain message
_lzReceive: A function used to receive an omnichain message

In this tutorial, you will be implementing the OApp standard into your own project to add the capability to send messages from a smart contract on Base to a smart contract on Optimism.

Info: An extension of the OApp contract standard known as OFT is also available for supporting omnichain fungible token transfers.

Info: For more information on transferring tokens across chains using LayerZero, visit the LayerZero documentation.

Writing the smart contract

To get started, create a new Solidity smart contract file in your project's src/ directory named ExampleContract.sol, and add the following content:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { OApp, Origin, MessagingFee } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/OApp.sol";

contract ExampleContract is OApp {
   constructor(address _endpoint, address _owner) OApp(_endpoint, _owner) {}
}

The code snippet above defines a new smart contract named ExampleContract that extends the OApp contract standard.

The contract's constructor expects two arguments:

_endpoint: The LayerZero Endpoint address for the chain the smart contract is deployed to.
_owner: The address of the owner of the smart contract.

Info: LayerZero Endpoints are smart contracts that expose an interface for OApp contracts to manage security configurations and send and receive messages via the LayerZero protocol.

Implementing message sending (`_lzSend`)

To send messages to another chain, your smart contract must call the _lzSend function inherited from the OApp contract.

Add a new custom function named sendMessage to your smart contract that has the following content:

/// @notice Sends a message from the source chain to the destination chain.
/// @param _dstEid The endpoint ID of the destination chain.
/// @param _message The message to be sent.
/// @param _options The message execution options (e.g. gas to use on destination).
function sendMessage(uint32 _dstEid, string memory _message, bytes calldata _options) external payable {
   bytes memory _payload = abi.encode(_message); // Encode the message as bytes
   _lzSend(
       _dstEid,
       _payload,
       _options,
       MessagingFee(msg.value, 0), // Fee for the message (nativeFee, lzTokenFee)
       payable(msg.sender) // The refund address in case the send call reverts
   );
}

The sendMessage function above calls the inherited _lzSend function, while passing in the following expected data:

Name	Type	Description
`_dstEid`	`uint32`	The endpoint ID of the destination chain to send the message to.
`_payload`	`bytes`	The message (encoded) to send.
`_options`	`bytes`	Additional options when sending the message, such as how much gas should be used when receiving the message.
`_fee`	`MessagingFee`	The calculated fee for sending the message.
`_refundAddress`	`address`	The `address` that will receive any excess fee values sent to the endpoint in case the `_lzSend` execution reverts.

Implementing gas fee estimation (`_quote`)

As shown in the table provided in the last section, the _lzSend function expects an estimated gas fee to be provided when sending a message (_fee).

Therefore, sending a message using the sendMessage function of your contract, you first need to estimate the associated gas fees.

Add a new function to your ExampleContract contract called estimateFee that calls the _quote function, as shown below:

/// @notice Estimates the gas associated with sending a message.
/// @param _dstEid The endpoint ID of the destination chain.
/// @param _message The message to be sent.
/// @param _options The message execution options (e.g. gas to use on destination).
/// @return nativeFee Estimated gas fee in native gas.
/// @return lzTokenFee Estimated gas fee in ZRO token.
function estimateFee(
   uint32 _dstEid,
   string memory _message,
   bytes calldata _options
) public view returns (uint256 nativeFee, uint256 lzTokenFee) {
   bytes memory _payload = abi.encode(_message);
   MessagingFee memory fee = _quote(_dstEid, _payload, _options, false);
   return (fee.nativeFee, fee.lzTokenFee);
}

The estimateFee function above calls the inherited _quote function, while passing in the following expected data:

Name	Type	Description
`_dstEid`	`uint32`	The endpoint ID of the destination chain the message will be sent to.
`_payload`	`bytes`	The message (encoded) that will be sent.
`_options`	`bytes`	Additional options when sending the message, such as how much gas should be used when receiving the message.
`_payInLzToken`	`bool`	Boolean flag for which token to use when returning the fee (native or ZRO token).

Info: Your contract’s estimateFee function should always be called immediately before calling sendMessage to accurately estimate associated gas fees.

Implementing message receiving (`_lzReceive`)

To receive messages on the destination chain, your smart contract must override the _lzReceive function inherited from the OApp contract.

Add the following code snippet to your ExampleContract contract to override the _lzReceive function:

/// @notice Entry point for receiving messages.
/// @param _origin The origin information containing the source endpoint and sender address.
///  - srcEid: The source chain endpoint ID.
///  - sender: The sender address on the src chain.
///  - nonce: The nonce of the message.
/// @param _guid The unique identifier for the received LayerZero message.
/// @param _message The payload of the received message.
/// @param _executor The address of the executor for the received message.
/// @param _extraData Additional arbitrary data provided by the corresponding executor.
function _lzReceive(
   Origin calldata _origin,
   bytes32 _guid,
   bytes calldata payload,
   address _executor,
   bytes calldata _extraData
   ) internal override {
       data = abi.decode(payload, (string));
       // other logic
}

The overridden _lzReceive function receives the following arguments when receiving a message:

Name	Type	Description
`_origin`	`Origin`	The origin information containing the source endpoint and sender address.
`_guid`	`bytes32`	The unique identifier for the received LayerZero message.
`payload`	`bytes`	The payload of the received message (encoded).
`_executor`	`address`	The `address` of the Executor for the received message.
`_extraData`	`bytes`	Additional arbitrary data provided by the corresponding Executor.

Note that the overridden method decodes the message payload, and stores the string into a variable named data that you can read from later to fetch the latest message.

Add the data field as a member variable to your contract:

contract ExampleContract is OApp {

    // highlight-next-line
    string public data;

    constructor(address _endpoint) OApp(_endpoint, msg.sender) {}
}

Info: Overriding the _lzReceive function allows you to provide any custom logic you wish when receiving messages, including making a call back to the source chain by invoking _lzSend. Visit the LayerZero Message Design Patterns for common messaging flows.

Final code

Once you complete all of the steps above, your contract should look like this:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { OApp, Origin, MessagingFee } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/OApp.sol";

contract ExampleContract is OApp {

 string public data;

  constructor(address _endpoint) OApp(_endpoint, msg.sender) {}

  /// @notice Sends a message from the source chain to the destination chain.
  /// @param _dstEid The endpoint ID of the destination chain.
  /// @param _message The message to be sent.
  /// @param _options The message execution options (e.g. gas to use on destination).
  function sendMessage(uint32 _dstEid, string memory _message, bytes calldata _options) external payable {
     bytes memory _payload = abi.encode(_message); // Encode the message as bytes
     _lzSend(
           _dstEid,
           _payload,
           _options,
           MessagingFee(msg.value, 0), // Fee for the message (nativeFee, lzTokenFee)
           payable(msg.sender) // The refund address in case the send call reverts
     );
  }

  /// @notice Estimates the gas associated with sending a message.
  /// @param _dstEid The endpoint ID of the destination chain.
  /// @param _message The message to be sent.
  /// @param _options The message execution options (e.g. gas to use on destination).
  /// @return nativeFee Estimated gas fee in native gas.
  /// @return lzTokenFee Estimated gas fee in ZRO token.
  function estimateFee(
     uint32 _dstEid,
     string memory _message,
     bytes calldata _options
  ) public view returns (uint256 nativeFee, uint256 lzTokenFee) {
     bytes memory _payload = abi.encode(_message);
     MessagingFee memory fee = _quote(_dstEid, _payload, _options, false);
     return (fee.nativeFee, fee.lzTokenFee);
  }

  /// @notice Entry point for receiving messages.
  /// @param _origin The origin information containing the source endpoint and sender address.
  ///  - srcEid: The source chain endpoint ID.
  ///  - sender: The sender address on the src chain.
  ///  - nonce: The nonce of the message.
  /// @param _guid The unique identifier for the received LayerZero message.
  /// @param _message The payload of the received message.
  /// @param _executor The address of the executor for the received message.
  /// @param _extraData Additional arbitrary data provided by the corresponding executor.
  function _lzReceive(
     Origin calldata _origin,
     bytes32 _guid,
     bytes calldata payload,
     address _executor,
     bytes calldata _extraData
     ) internal override {
        data = abi.decode(payload, (string));
  }
}

Compiling the smart contract

Compile the smart contract to ensure it builds without any errors.

To compile your smart contract, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to various chains you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Coinbase Wallet, visit the Coinbase Wallet documentation. It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables

To setup your environment, create an .env file in the home directory of your project, and add the RPC URLs and LayerZero Endpoint information for both Base Goerli and Optimism Goerli testnets:

BASE_GOERLI_RPC="https://goerli.base.org"
BASE_GOERLI_LZ_ENDPOINT=0x464570adA09869d8741132183721B4f0769a0287
BASE_GOERLI_LZ_ENDPOINT_ID=40184

OPTIMISM_GOERLI_RPC="https://goerli.optimism.io"
OPTIMISM_GOERLI_LZ_ENDPOINT=0x464570adA09869d8741132183721B4f0769a0287
OPTIMISM_GOERLI_LZ_ENDPOINT_ID=40132

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

With your contract compiled and environment setup, you are now ready to deploy the smart contract to different networks.

Deploying the smart contract to Base Goerli

Info: Your wallet must be funded with ETH on the Base Goerli and Optimism Goerli to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH, see the prerequisites.

To deploy the ExampleContract smart contract to the Base Goerli testnet, run the following command:

forge create ./src/ExampleContract.sol:ExampleContract --rpc-url $BASE_GOERLI_RPC --constructor-args $BASE_GOERLI_LZ_ENDPOINT --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

After running the command above, the contract will be deployed on the Base Goerli test network. You can view the deployment status and contract by using a block explorer.

Deploying the smart contract to Optimism Goerli

To deploy the ExampleContract smart contract to the Optimism Goerli testnet, run the following command:

forge create ./src/ExampleContract.sol:ExampleContract --rpc-url $OPTIMISM_GOERLI_RPC --constructor-args $OPTIMISM_GOERLI_LZ_ENDPOINT --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

After running the command above, the contract will be deployed on the Optimism Goerli test network. You can view the deployment status and contract by using the OP Goerli block explorer.

Opening the messaging channels

Once your contract has been deployed to Base Goerli and Optimism Goerli, you will need to open the messaging channels between the two contracts so that they can send and receive messages from one another. This is done by calling the setPeer function on the contract.

The setPeer function expects the following arguments:

Name	Type	Description
`_eid`	`uint32`	The endpoint ID of the destination chain.
`_peer`	`bytes32`	The contract address of the OApp contract on the destination chain.

Setting the peers

Foundry provides the cast command-line tool that can be used to interact with deployed smart contracts and call their functions.

To set the peer of the Base Goerli contract to the Optimism Goerli contract, run the following command:

cast send <BASE_GOERLI_CONTRACT_ADDRESS> --rpc-url $BASE_GOERLI_RPC "setPeer(uint32, bytes32)" $OPTIMISM_GOERLI_LZ_ENDPOINT_ID <OPTIMISM_GOERLI_CONTRACT_ADDRESS> --account deployer

Info: Replace <BASE_GOERLI_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Base Goerli, and<OPTIMISM_GOERLI_CONTRACT_ADDRESS> with the contract address (as bytes) of your deployed ExampleContract contract on Optimism Goerli before running the provided cast command.

To set the peer of the Optimism Goerli contract to the Base Goerli contract, run the following command:

cast send <OPTIMISM_GOERLI_CONTRACT_ADDRESS> --rpc-url $OPTIMISM_GOERLI_RPC "setPeer(uint32, bytes32)" $BASE_GOERLI_LZ_ENDPOINT_ID <BASE_GOERLI_CONTRACT_ADDRESS> --account deployer

Info: Replace <OPTIMISM_GOERLI_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Optimism Goerli, and<BASE_GOERLI_CONTRACT_ADDRESS> with the contract address (as bytes) of your deployed ExampleContract contract on Base Goerli before running the provided cast command.

Sending messages

Once peers have been set on each contract, they are now able to send and receive messages from one another.

Sending a message using the newly created ExampleContract contract can be done in three steps:

Build message options to specify logic associated with the message transaction
Call the estimateFee function to estimate the gas fee for sending a message
Call the sendMessage function to send a message

Building message options

The estimateFee and sendMessage custom functions of the ExampleContract contract both require a message options (_options) argument to be provided.

LayerZero provides a Solidity library and TypeScript SDK for building these message options.

pragma solidity ^0.8.0;

import {Script, console2} from "forge-std/Script.sol";
import { OptionsBuilder } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/libs/OptionsBuilder.sol";

contract OptionsScript is Script {
    using OptionsBuilder for bytes;

    function setUp() public {}

    function run() public {
        bytes memory options = OptionsBuilder.newOptions().addExecutorLzReceiveOption(200000, 0);
        console2.logBytes(options);
    }
}

The output of this script results in:

0x00030100110100000000000000000000000000030d40

For this tutorial, rather than building and generating your own message options, you can use the bytes output provided above.

Info: Covering all of the different message options in detail is out of scope for this tutorial. If you are interested in learning more about the different message options and how to build them, visit the LayerZero developer documentation.

Estimating the gas fee

Before you can send a message from your contract on Base Goerli, you need to estimate the fee associated with sending the message. You can use the cast command to call the estimateFee() function of the ExampleContract contract.

To estimate the gas fee for sending a message from Base Goerli to Optimism Goerli, run the following command:

cast send <BASE_GOERLI_CONTRACT_ADDRESS> --rpc-url $BASE_GOERLI_RPC "estimateFee(uint32, string, bytes)" $OPTIMISM_GOERLI_LZ_ENDPOINT_ID "Hello World" 0x00030100110100000000000000000000000000030d40 --account deployer

Info: Replace <BASE_GOERLI_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Base Goerli before running the provided cast command.

Sending the message

Once you have fetched the estimated gas for sending your message, you can now call sendMessage and provide the value returned as the msg.value.

For example, to send a message from Base Goerli to Optimism Goerli with an estimated gas fee, run the following command:

cast send <BASE_GOERLI_CONTRACT_ADDRESS> --rpc-url $BASE_GOERLI_RPC --value <GAS_ESTIMATE_IN_WEI> "sendMessage(uint32, string, bytes)" $OPTIMISM_GOERLI_LZ_ENDPOINT_ID "Hello World" 0x00030100110100000000000000000000000000030d40 --account deployer

Info: Replace <BASE_GOERLI_CONTRACT_ADDRESS> with the contract address of your deployed ExampleContract contract on Base Goerli, and <GAS_ESTIMATE_IN_WEI> with the gas estimate (in wei) returned by the call to estimateFee, before running the provided cast command.

You can view the status of your cross-chain transaction on LayerZero Scan.

Receiving the message

You can use the cast command to read the latest message received by the ExampleContract stored in the data variable.

To read the latest received message data that was sent to Optimism Goerli from Base Goerli, run the following command:

cast send <OPTIMISM_GOERLI_CONTRACT_ADDRESS> --rpc-url $OPTIMISM_GOERLI_RPC "data" --account deployer

The returned data should match the message text payload you sent in your message.

You can view the status of your cross-chain transaction on LayerZero Scan.

Conclusion

Congratulations! You have successfully learned how to perform cross-chain messaging between Base and other chains (i.e. Optimism) using LayerZero V2.

To learn more about cross-chain messaging and LayerZero V2, check out the following resources:

Sending messages and tokens from Base to other chains using Chainlink CCIP

Taylor Caldwell — Mon, 27 Jan 2025 04:28:40 +0000

This tutorial will guide you through the process of sending messages and tokens from a Base smart contract to another smart contract on a different chain using Chainlink's Cross-chain Interoperability Protocol (CCIP).

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Base using Foundry
Install Chainlink CCIP as a dependency
Use Chainlink CCIP within your smart contract to send messages and/or tokens to contracts on other different chains
Deploy and test your smart contracts on Base testnet

Info: Chainlink CCIP is in an “Early Access” development stage, meaning some of the functionality described within this tutorial is under development and may change in later versions.

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Coinbase Wallet

In order to deploy a smart contract, you will first need a wallet. You can create a wallet by downloading the Coinbase Wallet browser extension.

Download Coinbase Wallet

Wallet funds

For this tutorial you will need to fund your wallet with both ETH and LINK on Base Goerli and Optimism Goerli.

The ETH is required for covering gas fees associated with deploying smart contracts to the blockchain, and the LINK token is required to pay for associated fees when using CCIP.

To fund your wallet with ETH on Base Goerli, visit a faucet listed on the Base Faucets page.
To fund your wallet with ETH on Optimism Goerli, visit a faucet listed on the Optimism Faucets page.
To fund your wallet with LINK, visit the Chainlink Faucet.

Info: If you are interested in building on Mainnet, you will need to apply for Chainlink CCIP mainnet access.

What is Chainlink CCIP?

Chainlink CCIP (Cross-chain Interoperability Protocol) provides a solution for sending message data and transferring tokens across different chains.

The primary way for users to interface with Chainlink CCIP is through smart contracts known as Routers. A Router contract is responsible for initiating cross-chain interactions.

Users can interact with Routers to perform the following cross-chain capabilities:

Capability	Description	Supported receivers
Arbitrary messaging	Send arbitrary (encoded) data from one chain to another.	Smart contracts only
Token transfers	Send tokens from one chain to another.	Smart contracts or EOAs
Programmable token transfers	Send tokens and arbitrary (encoded) data from one chain to another, in a single transaction.	Smart contracts only

Danger: Externally owned accounts (EOAs) on EVM blockchains are unable to receive message data, because of this, only smart contracts are supported as receivers when sending arbitrary messages or programmable token transfers. Any attempt to send a programmable token transfer (data and tokens) to an EOA, will result in only the tokens being received.

High-level concepts

Although Routers are the primary interface users will interact with when using CCIP, this section will cover what happens after instructions for a cross-chain interaction are sent to a Router.

OnRamps

Once a Router receives an instruction for a cross-chain interaction, it passes it on to another contract known as an OnRamp. OnRamps are responsible for a variety of tasks, including: verifying message size and gas limits, preserving the sequencing of messages, managing any fee payments, and interacting with the token pool to lock or burn tokens if a token transfer is being made.

OffRamps

The destination chain will have a contract known as an OffRamp. OffRamps are responsible for a variety of tasks, including: ensuring the authenticity of a message, making sure each transaction is only executed once, and transmitting received messages to the Router contract on the destination chain.

Token pools

A token pool is an abstraction layer over ERC-20 tokens that facilitates OnRamp and OffRamp token-related operations. They are configured to use either a Lock and Unlock or Burn and Mint mechanism, depending on the type of token.

For example, because blockchain-native gas tokens (i.e. ETH, MATIC, AVAX) can only be minted on their native chains, a Lock and Mint mechanism must be used. This mechanism locks the token at the source chain, and mints a synthetic asset on the destination chain.

In contrast, tokens that can be minted on multiple chains (i.e. USDC, USDT, FRAX, etc.), token pools can use a Burn and Mint mechanism, where the token is burnt on the source chain and minted on the destination chain.

Risk Management Network

Between instructions for a cross-chain interaction making its way from an OnRamp on the source chain to an OffRamp on the destination chain, it will pass through the Risk Management Network.

The Risk Management Network is a secondary validation service built using a variety of offchain and onchain components, with the responsibilities of monitoring all chains against abnormal activities.

Info: A deep-dive on the technical details of each of these components is too much to cover in this tutorial, but if interested you can learn more by visiting the Chainlink documentation.

Creating a project

Before you begin, you need to set up your smart contract development environment. You can setup a development environment using tools like Hardhat or Foundry. For this tutorial you will use Foundry.

To create a new Foundry project, first create a new directory:

mkdir myproject

Then run:

cd myproject
forge init

This will create a Foundry project with the following basic layout:

.
├── foundry.toml
├── script
├── src
└── test

Info: You can delete the src/Counter.sol, test/Counter.t.sol, and script/Counter.s.sol boilerplate files that were generated with the project, as you will not be needing them.

Installing Chainlink smart contracts

To use Chainlink CCIP within your Foundry project, you need to install Chainlink CCIP smart contracts as a project dependency using forge install.

To install Chainlink CCIP smart contracts, run:

forge install smartcontractkit/ccip --no-commit

Once installed, update your foundry.toml file by appending the following line:

remappings = ['@chainlink/contracts-ccip/=lib/ccip/contracts']

Writing the smart contracts

The most basic use case for Chainlink CCIP is to send data and/or tokens between smart contracts on different blockchains.

To accomplish this, in this tutorial, you will need to create two separate smart contracts:

Sender contract: A smart contract that interacts with CCIP to send data and tokens.
Receiver contract: A smart contract that interacts with CCIP to receive data and tokens.

Creating a Sender contract

The code snippet below is for a basic smart contract that uses CCIP to send data:

pragma solidity ^0.8.0;

import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {OwnerIsCreator} from "@chainlink/contracts-ccip/src/v0.8/shared/access/OwnerIsCreator.sol";
import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {IERC20} from "@chainlink/contracts-ccip/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";

contract Sender is OwnerIsCreator {

   IRouterClient private router;
   IERC20 private linkToken;

   /// @notice Initializes the contract with the router and LINK token address.
   /// @param _router The address of the router contract.
   /// @param _link The address of the link contract.
   constructor(address _router, address _link) {
       router = IRouterClient(_router);
       linkToken = IERC20(_link);
   }

   /// @notice Sends data to receiver on the destination chain.
   /// @param destinationChainSelector The identifier (aka selector) for the destination blockchain.
   /// @param receiver The address of the recipient on the destination blockchain.
   /// @param text The string text to be sent.
   /// @return messageId The ID of the message that was sent.
   function sendMessage(
       uint64 destinationChainSelector,
       address receiver,
       string calldata text
   ) external onlyOwner returns (bytes32 messageId) {
       Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
           receiver: abi.encode(receiver), // Encode receiver address
           data: abi.encode(text), // Encode text to send
           tokenAmounts: new Client.EVMTokenAmount[](0), // Empty array indicating no tokens are being sent
           extraArgs: Client._argsToBytes(
               Client.EVMExtraArgsV1({gasLimit: 200_000}) // Set gas limit
           ),
           feeToken: address(linkToken) // Set the LINK as the feeToken address
       });

       // Get the fee required to send the message
       uint256 fees = router.getFee(
           destinationChainSelector,
           message
       );

       // Revert if contract does not have enough LINK tokens for sending a message
       require(linkToken.balanceOf(address(this)) > fees, "Not enough LINK balance");

       // Approve the Router to transfer LINK tokens on contract's behalf in order to pay for fees in LINK
       linkToken.approve(address(router), fees);

       // Send the message through the router
       messageId = router.ccipSend(destinationChainSelector, message);

       // Return the messageId
       return messageId;
   }
}

Create a new file under your project's src/ directory named Sender.sol and copy the code above into the file.

Code walkthrough

The sections below provide a detailed explanation for the code for the Sender contract provided above.

Initializing the contract

In order to send data using CCIP, the Sender contract will need access to the following dependencies:

The Router contract: This contract serves as the primary interface when using CCIP to send and receive messages and tokens.
The fee token contract: This contract serves as the contract for the token that will be used to pay fees when sending messages and tokens. For this tutorial, the contract address for LINK token is used.

The Router contract address and LINK token address are passed in as parameters to the contract's constructor and stored as member variables for later for sending messages and paying any associated fees.

contract Sender is OwnerIsCreator {

   IRouterClient private router;
   IERC20 private linkToken;

   /// @notice Initializes the contract with the router and LINK token address.
   /// @param _router The address of the router contract.
   /// @param _link The address of the link contract.
   constructor(address _router, address _link) {
       router = IRouterClient(_router);
       linkToken = IERC20(_link);
   }

The Router contract provides two important methods that can be used when sending messages using CCIP:

getFee: Given a chain selector and message, returns the fee amount required to send the message.
ccipSend: Given a chain selector and message, sends the message through the router and returns an associated message ID.

The next section describes how these methods are utilized to send a message to another chain.

Sending a message

The Sender contract defines a custom method named sendMessage that utilizes the methods described above in order to:

Construct a message using the EVM2AnyMessage method provided by the Client CCIP library, using the following data:
1. receiver: The receiver contract address (encoded).
2. data: The text data to send with the message (encoded).
3. tokenAmounts: The amount of tokens to send with the message. For sending just an arbitrary message this field is defined as an empty array (new Client.EVMTokenAmount[](0)), indicating that no tokens will be sent.
4. extraArgs: Extra arguments associated with the message, such as gasLimit.
5. feeToken: The address of the token to be used for paying fees.
Get the fees required to send the message using the getFee method provided by the Router contract.
Check that the contract holds an adequate amount of tokens to cover the fee. If not, revert the transaction.
Approve the Router contract to transfer tokens on the Sender contracts behalf in order to cover the fees.
Send the message to a specified chain using the Router contract's ccipSend method.
Return a unique ID associated with the sent message.

/// @param receiver The address of the recipient on the destination blockchain.
/// @param text The string text to be sent.
/// @return messageId The ID of the message that was sent.
function sendMessage(
    uint64 destinationChainSelector,
    address receiver,
    string calldata text
) external onlyOwner returns (bytes32 messageId) {
    Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
        receiver: abi.encode(receiver), // Encode receiver address
        data: abi.encode(text), // Encode text to send
        tokenAmounts: new Client.EVMTokenAmount[](0), // Empty array indicating no tokens are being sent
        extraArgs: Client._argsToBytes(
            Client.EVMExtraArgsV1({gasLimit: 200_000}) // Set gas limit
        ),
        feeToken: address(linkToken) // Set the LINK as the feeToken address
    });

    // Get the fee required to send the message
    uint256 fees = router.getFee(
        destinationChainSelector,
        message
    );

    // Revert if contract does not have enough LINK tokens for sending a message
    require(linkToken.balanceOf(address(this)) > fees, "Not enough LINK balance");

    // Approve the Router to transfer LINK tokens on contract's behalf in order to pay for fees in LINK
    linkToken.approve(address(router), fees);
    // Send the message through the router
    messageId = router.ccipSend(destinationChainSelector, message);

    // Return the messageId
    return messageId;
}

Creating a Receiver contract

The code snippet below is for a basic smart contract that uses CCIP to receive data:

pragma solidity ^0.8.0;

import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {CCIPReceiver} from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";

contract Receiver is CCIPReceiver {

   bytes32 private _messageId;
   string private _text;

   /// @notice Constructor - Initializes the contract with the router address.
   /// @param router The address of the router contract.
   constructor(address router) CCIPReceiver(router) {}

   /// @notice Handle a received message
   /// @param message The cross-chain message being received.
   function _ccipReceive(
       Client.Any2EVMMessage memory message
   ) internal override {
       _messageId = message.messageId; // Store the messageId
       _text = abi.decode(message.data, (string)); // Decode and store the message text
   }

    /// @notice Gets the last received message.
    /// @return messageId The ID of the last received message.
    /// @return text The last received text.
    function getMessage()
        external
        view
        returns (bytes32 messageId, string memory text)
    {
        return (_messageId, _text);
    }
}

Create a new file under your project’s src/ directory named Receiver.sol and copy the code above into the file.

Code walkthrough

The sections below provide a detailed explanation for the code for the Receiver contract provided above.

Initializing the contract

In order to receive data using CCIP, the Receiver contract will need to extend to theCCIPReceiver interface. Extending this interface allows the Receiver contract to initialize the contract with the router address from the constructor, as seen below:

import {CCIPReceiver} from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";

contract Receiver is CCIPReceiver {

   /// @notice Constructor - Initializes the contract with the router address.
   /// @param router The address of the router contract.
   constructor(address router) CCIPReceiver(router) {}
}

Receiving a message

Extending the CCIPReceiver interface also allows the Receiver contract to override the _ccipReceive handler method for when a message is received and define custom logic.

/// @notice Handle a received message
/// @param message The cross-chain message being received.
function _ccipReceive(
    Client.Any2EVMMessage memory message
) internal override {
    // Add custom logic here
}

The Receiver contract in this tutorial provides custom logic that stores the messageId and text (decoded) as member variables.

contract Receiver is CCIPReceiver {

   bytes32 private _messageId;
   string private _text;

   /// @notice Constructor - Initializes the contract with the router address.
   /// @param router The address of the router contract.
   constructor(address router) CCIPReceiver(router) {}

   /// @notice Handle a received message
   /// @param message The cross-chain message being received.
   function _ccipReceive(
       Client.Any2EVMMessage memory message
   ) internal override {
       _messageId = message.messageId; // Store the messageId
       _text = abi.decode(message.data, (string)); // Decode and store the message text
   }
}

Retrieving a message

The Receiver contract defines a custom method named getMessage that returns the details of the last received message _messagId and _text. This method can be called to fetch the message data details after the _ccipReceive receives a new message.

/// @notice Gets the last received message.
/// @return messageId The ID of the last received message.
/// @return text The last received text.
function getMessage()
    external
    view
    returns (bytes32 messageId, string memory text)
{
    return (_messageId, _text);
}

Compiling the smart contracts

To compile your smart contracts, run:

forge build

Deploying the smart contract

Setting up your wallet as the deployer

Before you can deploy your smart contract to the Base network, you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Coinbase Wallet, visit the Coinbase Wallet documentation. It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Setting up environment variables

To setup your environment, create an .env file in the home directory of your project, and add the RPC URLs, CCIP chain selectors, CCIP router addresses, and LINK token addresses for both Base Goerli and Optimism Goerli testnets:

BASE_GOERLI_RPC="https://goerli.base.org"
OPTIMISM_GOERLI_RPC="https://goerli.optimism.io"

BASE_GOERLI_CHAIN_SELECTOR=5790810961207155433
OPTIMISM_GOERLI_CHAIN_SELECTOR=2664363617261496610

BASE_GOERLI_ROUTER_ADDRESS="0x80AF2F44ed0469018922c9F483dc5A909862fdc2"
OPTIMISM_GOERLI_ROUTER_ADDRESS="0xcc5a0B910D9E9504A7561934bed294c51285a78D"

BASE_GOERLI_LINK_ADDRESS="0x6D0F8D488B669aa9BA2D0f0b7B75a88bf5051CD3"
OPTIMISM_GOERLI_LINK_ADDRESS="0xdc2CC710e42857672E7907CF474a69B63B93089f"

Once the .env file has been created, run the following command to load the environment variables in the current command line session:

source .env

Deploying the smart contracts

With your contracts compiled and environment setup, you are ready to deploy the smart contracts.

Info: Your wallet must be funded with ETH on the Base Goerli and Optimism Goerli to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH for Base Goerli and Optimism Goerli, see the prerequisites.

Deploying the Sender contract to Base Goerli

To deploy the Sender smart contract to the Base Goerli testnet, run the following command:

forge create ./src/Sender.sol:Sender --rpc-url $BASE_GOERLI_RPC --constructor-args $BASE_GOERLI_ROUTER_ADDRESS $BASE_GOERLI_LINK_ADDRESS --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

After running the command above, the contract will be deployed on the Base Goerli test network. You can view the deployment status and contract by using a block explorer.

Deploying the Receiver contract to Optimism Goerli

To deploy the Receiver smart contract to the Optimism Goerli testnet, run the following command:

forge create ./src/Receiver.sol:Receiver --rpc-url $OPTIMISM_GOERLI_RPC --constructor-args $OPTIMISM_GOERLI_ROUTER_ADDRESS --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet's private key.

After running the command above, the contract will be deployed on the Optimism Goerli test network. You can view the deployment status and contract by using the OP Goerli block explorer.

Funding your smart contracts

In order to pay for the fees associated with sending messages, the Sender contract will need to hold a balance of LINK tokens.

Fund your contract directly from your wallet, or by running the following cast command:

cast send $BASE_GOERLI_LINK_ADDRESS --rpc-url $BASE_GOERLI_RPC "transfer(address,uint256)" <SENDER_CONTRACT_ADDRESS> 5 --account deployer

The above command sends 5 LINK tokens on Base Goerli testnet to the Sender contract.

Info: Replace <SENDER_CONTRACT_ADDRESS> with the contract address of your deployed Sender contract before running the provided cast command.

Interacting with the smart contract

Foundry provides the cast command-line tool that can be used to interact with deployed smart contracts and call their functions.

Sending data

The cast command can be used to call the sendMessage(uint64, address, string) function on the Sender contract deployed to Base Goerli in order to send message data to the Receiver contract on Optimism Goerli.

To call the sendMessage(uint64, address, string) function of the Sender smart contract, run:

cast send <SENDER_CONTRACT_ADDRESS> --rpc-url $BASE_GOERLI_RPC "sendMessage(uint64, address, string)" $OPTIMISM_GOERLI_CHAIN_SELECTOR <RECEIVER_CONTRACT_ADDRESS> "Based" --account deployer

The command above calls the sendMessage(uint64, address, string) to send a message. The parameters passed in to the method include: The chain selector to the destination chain (Optimism Goerli), the Receiver contract address, and the text data to be included in the message (Based).

Info: Replace <SENDER_CONTRACT_ADDRESS> and <RECEIVER_CONTRACT_ADDRESS> with the contract addresses of your deployed Sender and Receiver contracts respectively before running the provided cast command.

After running the command, a unique messageId should be returned.

Once the transaction has been finalized, it will take a few minutes for CCIP to deliver the data to Optimism Goerli and call the ccipReceive function on the Receiver contract.

Info: You can use the CCIP explorer to see the status of the CCIP transaction.

Receiving data

The cast command can also be used to call the getMessage() function on the Receiver contract deployed to Optimism Goerli in order to read the received message data.

To call the getMessage() function of the Receiver smart contract, run:

cast send <RECEIVER_CONTRACT_ADDRESS> --rpc-url $OPTIMISM_GOERLI_RPC "getMessage()" --account deployer

Info: Replace <RECEIVER_CONTRACT_ADDRESS> with the contract addresses of your deployed Receiver contract before running the provided cast command.

After running the command, the messageId and text of the last received message should be returned.

If the transaction fails, ensure the status of your ccipSend transaction has been finalized. You can using the CCIP explorer.

Conclusion

Congratulations! You have successfully learned how to perform cross-chain messaging on Base using Chainlink CCIP.

To learn more about cross-chain messaging and Chainlink CCIP, check out the following resources:

Account Abstraction on Base using Biconomy

Taylor Caldwell — Mon, 27 Jan 2025 04:28:32 +0000

This tutorial will guide you through the process of implementing Account Abstraction in your Base projects using Biconomy paymasters, bundlers, and smart accounts.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to do the following:

Set up a smart contract project for Base using Foundry
Set up a Next.js frontend project using create next-app
Setup user login and authentication using Particle Network
Setup a Biconomy paymaster and bundler
Create a gasless transaction

Prerequisites

Foundry

This tutorial requires you to have Foundry installed.

From the command-line (terminal), run: curl -L https://foundry.paradigm.xyz | bash
Then run foundryup, to install the latest (nightly) build of Foundry

For more information, see the Foundry Book installation guide.

Coinbase Wallet

This tutorial requires you to have a wallet. You can create a wallet by downloading the Coinbase Wallet browser extension:

Download Coinbase Wallet

Wallet funds

To complete this tutorial, you will need to fund a wallet with ETH on Base Goerli.

The ETH is required for covering gas fees associated with deploying smart contracts to the network.

To fund your wallet with ETH on Base Goerli, visit a faucet listed on the Base Faucets page.

What is Biconomy?

Biconomy is a toolkit that offers a full-stack solution for Account Abstraction, including smart accounts, paymasters for sponsoring gas fees, and bundlers for bundling user operations into a single transaction.

High-level concepts

Account Abstraction

Account Abstraction (ERC-4337) allows users to use Smart Contract wallets instead of traditional Externally Owned Account (EOA) wallets.

Smart Accounts

A smart account (also known as a smart contract wallet) is a wallet that stores and manages digital assets (ERC-20 tokens, NFTs, etc.) using a smart contract.

User Operations

A user operation is a pseudo-transaction object sent by a smart account that describes a transaction to be sent. Multiple user operations are eventually bundled together and initiated as a single real transaction by a bundler.

Paymaster

A paymaster is a special smart contract that allows applications to “sponsor user operations”, meaning it will pay for the gas fees associated with the resulting transaction.

Bundler

A special node that monitors a mempool of user operations and bundles multiple user operations into a single transaction.

Info: To learn more about Account Abstraction and the concepts outlined above, see ERC-4337.

Creating and deploying a smart contract

Before you begin, you need to set up a smart contract development environment using Foundry.

To create a new project, first create a new directory named myproject, and change it to your current working directory:

mkdir myproject
cd myproject

Creating a Foundry project

Next, within the myproject directory create a new directory named contracts, and change it to your current working directory:

mkdir contracts
cd contracts

Then create a new Foundry project by running the following command:

forge init

This will create a Foundry project with the following basic layout:

.
├── foundry.toml
├── script
├── src
└── test

Info:: The command creates a boilerplate Solidity smart contract file named src/Counter.sol. This is the primary contract you will use for this tutorial.

Compiling the smart contract

Compile the smart contract to ensure it builds without any errors.

To compile your smart contract, run:

forge build

Setting up a wallet as the deployer

Before you can deploy your smart contract to various chains you will need to set up a wallet to be used as the deployer.

To do so, you can use the cast wallet import command to import the private key of the wallet into Foundry's securely encrypted keystore:

cast wallet import deployer --interactive

After running the command above, you will be prompted to enter your private key, as well as a password for signing transactions.

Caution: For instructions on how to get your private key from Coinbase Wallet, visit the Coinbase Wallet documentation. It is critical that you do NOT commit this to a public repo.

To confirm that the wallet was imported as the deployer account in your Foundry project, run:

cast wallet list

Deploying the smart contract

To deploy the smart contract, you can use the forge create command. The command requires you to specify the smart contract you want to deploy, an RPC URL of the network you want to deploy to, and the account you want to deploy with.

Info: Your wallet must be funded with ETH on the Base Goerli testnet to cover the gas fees associated with the smart contract deployment. Otherwise, the deployment will fail.

To get testnet ETH, see the prerequisites.

To deploy the smart contract to the Base Goerli testnet, run the following command:

forge create ./src/Counter.sol:Counter --rpc-url https://goerli.base.org --account deployer

When prompted, enter the password that you set earlier, when you imported your wallet’s private key.

After running the command above, the contract will be deployed on the Base Goerli test network. You can view the deployment status and contract by using a block explorer.

Setting up the Paymaster and Bundler

To setup the paymaster and bundler for your project, you will need to visit the Biconomy Dashboard and complete the following steps.

Registering a paymaster

Add and register a Paymaster by completing the following steps:

Visit the sign in to the Biconomy Dashboard
From the dashboard, select the Paymasters tab and click Add your first Paymaster
Provide a Name for your paymaster
Select Base Goerli from the Network dropdown
Click Register

You should now have a registered Biconomy paymaster.

Info: The API Key and Paymaster URL for the paymaster are provided under the Overview tab in the Biconomy Dashboard.

Setting up the paymaster gas tank

Set up and fund the paymaster's gas tank by completing the following steps:

From the dashboard, navigate to the Paymasters tab
Click Setup gas tank on the paymaster
Navigate to Gas-Tank > Deposit, and click Set up gas tank
Sign the message with your connected wallet to set up the gas tank
Click Go to deposit
Enter the amount of ETH you wish to deposit
Click Deposit

ETH should now be deposited into the gas tank for your paymaster. You can visit the Withdraw tab at a later time if you wish to withdraw the funds.

Setting up the paymaster policies

Set up and fund the paymaster's gas tank by completing the following steps:

From the dashboard, navigate to the Paymasters tab
Select the paymaster to configure
Navigate to Policies > Contracts, and click Add your first contract
Add the Name and the Smart contract address for your contract
Select the increment and setNumber write methods as methods to sponsor
Click Add Smart Contract

Setting up a bundler

Visit the sign in to the Biconomy Dashboard
From the dashboard, select the Bundlers tab

Info: At the time of writing this tutorial, the Bundler service is still under development, however a Bundler URL is provided for testing out UserOperations on test networks. You can specify the chain ID 84531 to use the Bundler URL on Base Goerli testnet.

Setting up the frontend

Creating a Next.js project

After you set up your paymaster and bundler from the Biconomy Dashboard, the next step is to create a Next.js project for your app's frontend.

From the root of the myproject directory of your project, create a new Next.js project by running the following command:

yarn create next-app
cd my-app

Installing the dependencies

To use the paymaster and bundler that were setup from the Biconomy Dashboard, you will need to add a few dependencies to your Next.js project.

To install Biconomy as a dependency to your project, run the following command:

yarn add @biconomy/account @biconomy/bundler @biconomy/common @biconomy/core-types @biconomy/paymaster ethers@5.7.2

Creating Biconomy smart accounts requires a signer from an EIP-1193 provider. Biconomy works with a variety of different social login and embedded wallet onboarding solutions that provide access to a signer that can be used for creating smart accounts. In this tutorial, you will use Particle Network for user authentication and getting a smart account signer.

To install Particle Network as a dependency to your project, run the following command:

yarn add @biconomy/particle-auth

Updating the boilerplate code

The main page (page.tsx) of the Next.js project created when running the yarn create next-app command contains a Home component. This component comes with a lot of code that is unnecessary for this tutorial.

Replace the content of the page.tsx file with the following simplified code:

'use client';

import styles from './page.module.css';

export default function Home() {
  return (
    <main className={styles.main}>
      <div></div>
    </main>
  );
}

Adding social login using Particle Network

Setting up Particle Network

To get started adding social login into the app using Particle Network, import and initialize the Biconomy Particle Auth module in the page.tsx file as shown below:

'use client';

import styles from './page.module.css';
// highlight-next-line
import { ParticleAuthModule, ParticleProvider } from '@biconomy/particle-auth';

// highlight-start
const PARTICLE_PROJECT_ID = 'YOUR_PARTICLE_PROJECT_ID';
const PARTICLE_CLIENT_ID = 'YOUR_PARTICLE_CLIENT_ID';
const PARTICLE_APP_ID = 'YOUR_PARTICLE_APP_ID';

const particle = new ParticleAuthModule.ParticleNetwork({
  projectId: PARTICLE_PROJECT_ID,
  clientKey: PARTICLE_CLIENT_ID,
  appId: PARTICLE_APP_ID,
  wallet: {
    displayWalletEntry: true,
  },
});
// highlight-end

export default function Home() {
  return (
    <main className={styles.main}>
      <div></div>
    </main>
  );
}

Info: You will need to sign up for a Particle Network account and replace the values of PARTICLE_PROJECT_ID, PARTICLE_CLIENT_ID, and PARTICLE_APP_ID with your own project ID, client ID, and app ID respectively. You can find this information on the Particle Network Dashboard.

Adding login functionality

Next, add a Login button and login function that triggers the Particle Network login flow and gets a Web3Provider:

'use client';

import styles from './page.module.css';
import { ParticleAuthModule, ParticleProvider } from '@biconomy/particle-auth';
// highlight-next-line
import { ethers } from 'ethers';

const PARTICLE_PROJECT_ID = 'YOUR_PARTICLE_PROJECT_ID';
const PARTICLE_CLIENT_ID = 'YOUR_PARTICLE_CLIENT_ID';
const PARTICLE_APP_ID = 'YOUR_PARTICLE_APP_ID';

const particle = new ParticleAuthModule.ParticleNetwork({
  projectId: PARTICLE_PROJECT_ID,
  clientKey: PARTICLE_CLIENT_ID,
  appId: PARTICLE_APP_ID,
  wallet: {
    displayWalletEntry: true,
  },
});

export default function Home() {
  // highlight-start
  const login = async () => {
    try {
      const userInfo = await particle.auth.login();
      const particleProvider = new ParticleProvider(particle.auth);
      const web3Provider = new ethers.providers.Web3Provider(particleProvider, 'any');
    } catch (error) {
      console.error(error);
    }
  };
  // highlight-end

  return (
    <main className={styles.main}>
      <div>
        // highlight-next-line
        <button onClick={login}>Login</button>
      </div>
    </main>
  );
}

Creating Smart Accounts using Biconomy

Initializing the paymaster and bundler

Before you can implement the rest of the login flow and create a smart account for the logged in user, you will need to specify a paymaster and bundler.

To initialize the paymaster and bundler, add the following lines of code:

'use client';

import styles from './page.module.css';
import { ParticleAuthModule, ParticleProvider } from '@biconomy/particle-auth';
import { ethers } from 'ethers';

// highlight-start
import { IBundler, Bundler } from '@biconomy/bundler';
import { IPaymaster, BiconomyPaymaster } from '@biconomy/paymaster';
import { ChainId } from '@biconomy/core-types';
import { DEFAULT_ENTRYPOINT_ADDRESS } from '@biconomy/account';
// highlight-end

const PARTICLE_PROJECT_ID = 'YOUR_PARTICLE_PROJECT_ID';
const PARTICLE_CLIENT_ID = 'YOUR_PARTICLE_CLIENT_ID';
const PARTICLE_APP_ID = 'YOUR_PARTICLE_APP_ID';

// highlight-start
const PAYMASTER_URL = 'YOUR_PAYMASTER_URL';
const BUNDLER_URL = 'YOUR_BUNDLER_URL';
// highlight-end

const particle = new ParticleAuthModule.ParticleNetwork({
  projectId: PARTICLE_PROJECT_ID,
  clientKey: PARTICLE_CLIENT_ID,
  appId: PARTICLE_APP_ID,
  wallet: {
    displayWalletEntry: true,
  },
});

// highlight-start
const paymaster: IPaymaster = new BiconomyPaymaster({
  paymasterUrl: PAYMASTER_URL,
});

const bundler: IBundler = new Bundler({
  chainId: ChainId.BASE_GOERLI_TESTNET,
  entryPointAddress: DEFAULT_ENTRYPOINT_ADDRESS,
  bundlerUrl: BUNDLER_URL,
});
// highlight-end

export default function Home() {
  const login = async () => {
    try {
      const userInfo = await particle.auth.login();
      const particleProvider = new ParticleProvider(particle.auth);
      const web3Provider = new ethers.providers.Web3Provider(particleProvider, 'any');
    } catch (error) {
      console.error(error);
    }
  };

  return (
    <main className={styles.main}>
      <div>
        <button onClick={login}>Login</button>
      </div>
    </main>
  );
}

Info: Replace the values of PAYMASTER_URL, BUNDLER_URL with the URLs for your paymaster and bundler respectively. You can find this information on the Biconomy Dashboard

Creating the smart account

Once the paymaster and bundler instances have been created, you’re ready to create a smart account for the user that is logging in.

You can use the BiconomySmartAccountV2.create function to create a new smart account for the user.

To create a smart account for the user on Base Goerli testnet that uses the Biconomy paymaster and bundler add the following code:

...
import {
// highlight-start
  BiconomySmartAccountV2,
// highlight-end
  DEFAULT_ENTRYPOINT_ADDRESS,
} from '@biconomy/account';
// highlight-start
 import {
  ECDSAOwnershipValidationModule,
  DEFAULT_ECDSA_OWNERSHIP_MODULE,
} from '@biconomy/modules';
// highlight-end

...

export default function Home() {

...

  const login = async () => {
    try {
      const userInfo = await particle.auth.login();
      const particleProvider = new ParticleProvider(particle.auth);
      const web3Provider = new ethers.providers.Web3Provider(
        particleProvider,
        'any',
      );

      // highlight-start
      const validationModule = await ECDSAOwnershipValidationModule.create({
        signer: web3Provider.getSigner(),
        moduleAddress: DEFAULT_ECDSA_OWNERSHIP_MODULE,
      });

      let biconomySmartAccount = await BiconomySmartAccountV2.create({
        chainId: ChainId.BASE_GOERLI_TESTNET,
        bundler: bundler,
        paymaster: paymaster,
        entryPointAddress: DEFAULT_ENTRYPOINT_ADDRESS,
        defaultValidationModule: validationModule,
        activeValidationModule: validationModule,
      });

      const accountAddress = await biconomySmartAccount.getAccountAddress();
      // highlight-end
    } catch (error) {
      console.error(error);
    }
   };


  return (
    <main className={styles.main}>
      <div>
      <button onClick={login}>Login</button>
      </div>
    </main>
  );
}

Saving the provider and smart account to state

Later in this tutorial, you will use the provider and user’s smartAccount to execute transactions on the deployed smart contract. Store the provider and smartAccount to React state so you can use it later.

To store the provider and smartAccount, add the following code:

...
// highlight-next-line
import { useState } from 'react';

...

export default function Home() {

  // highlight-start
  const [loading, setLoading] = useState(false);
  const [provider, setProvider] = useState(null);
  const [smartAccount, setSmartAccount] = useState(null);
  const [address, setAddress] = useState('');
  // highlight-end
...

  const login = async () => {
    try {
      setLoading(true);
      const userInfo = await particle.auth.login();
      const particleProvider = new ParticleProvider(particle.auth);
      const web3Provider = new ethers.providers.Web3Provider(
        particleProvider,
        'any',
      );

      const validationModule = await ECDSAOwnershipValidationModule.create({
        signer: web3Provider.getSigner(),
        moduleAddress: DEFAULT_ECDSA_OWNERSHIP_MODULE,
      });


      let biconomySmartAccount = await BiconomySmartAccountV2.create({
        chainId: ChainId.BASE_GOERLI_TESTNET,
        bundler: bundler,
        paymaster: paymaster,
        entryPointAddress: DEFAULT_ENTRYPOINT_ADDRESS,
        defaultValidationModule: validationModule,
        activeValidationModule: validationModule,
      });

      const accountAddress = await biconomySmartAccount.getAccountAddress();
      // highlight-start
      setProvider(web3Provider);
      setSmartAccount(biconomySmartAccount);
      setAddress(accountAddress);
      setLoading(false);
      // highlight-end
    } catch (error) {
      console.error(error);
    }
   };

   return (
    <main className={styles.main}>
      <div>
      // highlight-start
      {!loading && !address && <button onClick={login}>Login</button>}
      {loading && <p>Loading...</p>}
      {address && <h2>Smart Account Address: {address}</h2>}
      // highlight-end
      </div>
    </main>
  );
}

Info: The code above is also updated to hide and display the login button and smart account address of the user, depending on if the user is logged in or not.

Executing a gasless transaction

Now that the app is able to create smart accounts for each logged in user, lets provide the ability for a user to interact with the deployed smart contract.

Creating a Counter component

To allow users to interact with the deployed Counter smart contract, create a new directory named src/components and create a new file named Counter.tsx with the following content:

'use client';

import React, { useState, useEffect } from 'react';
import { ethers } from 'ethers';
import { PaymasterMode } from '@biconomy/paymaster';
import abi from '../utils/abi.json';

const CONTRACT_ADDRESS = 'YOUR_CONTRACT_ADDRESS';

export default function Counter({ smartAccount, provider }) {
  const [number, setNumber] = useState(0);
  const [contract, setContract] = useState(null);

  useEffect(() => {
    const counterContract = new ethers.Contract(CONTRACT_ADDRESS, abi, provider);
    setContract(counterContract);
  }, []);

  const getNumber = async () => {
    const currentNumber = await contract.number();
    setNumber(currentNumber.toNumber());
  };

  const increment = async () => {
    const incrementTx = new ethers.utils.Interface(['function increment()']);
    const data = incrementTx.encodeFunctionData('increment');

    const transaction = {
      to: CONTRACT_ADDRESS,
      data: data,
    };

    try {
      const userOp = await smartAccount.buildUserOp([transaction], {
        paymasterServiceData: {
          mode: PaymasterMode.SPONSORED,
        },
      });
      const userOpResponse = await smartAccount.sendUserOp(userOp);
      const transactionDetails = await userOpResponse.wait();
      console.log('Transaction details:', transactionDetails);
      console.log('Transaction hash:', transactionDetails.receipt.transactionHash);
    } catch (e) {
      console.error('Error executing transaction:', e);
    }
  };

  return (
    <>
      <div>Current number: {number}</div>
      <button onClick={() => increment()}>Increment</button>
    </>
  );
}

Info: Replace the value of CONTRACT_ADDRESS with the address for your deployed Counter.sol contract.

Code explanation

The code above is a simple React component that interacts with the deployed Counter smart contract.

A contract instance is initialized and stored in React state when the component first renders

useEffect(() => {
  const counterContract = new ethers.Contract(contractAddress, abi, provider);
  setContract(counterContract);
}, []);

The component also has two functions called getNumber and increment. getNumber reads the number member variable of the smart contract, and increment makes a call to the increment function of the smart contract:

const getNumber = async () => {
  const currentNumber = await contract.number();
  setNumber(currentNumber.toNumber());
};

const increment = async () => {
  const incrementTx = new ethers.utils.Interface(['function increment()']);
  const data = incrementTx.encodeFunctionData('increment');

  const transaction = {
    to: contractAddress,
    data: data,
  };

  try {
    const userOp = await smartAccount.buildUserOp([transaction], {
      paymasterServiceData: {
        mode: PaymasterMode.SPONSORED,
      },
    });
    const userOpResponse = await smartAccount.sendUserOp(userOp);
    const transactionDetails = await userOpResponse.wait();
  } catch (e) {
    console.error('Error executing transaction:', e);
  }
};

Adding the contract ABI

Initializing a contract instance requires the contract's Application Binary Interface (ABI) to be provided. The code for the Counter component in the previous section imports a file called abi.json:

import abi from '../utils/abi.json';

This file does not exist yet, so you will need to add it.

To add the ABI, create a new directory named src/utils and create a new file named abi.json with the following content:

[
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newNumber",
        "type": "uint256"
      }
    ],
    "name": "setNumber",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "increment",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "number",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  }
]

Info: If your deployed contract is verified, you can also get the ABI for the contract from BaseScan.

Updating the Home component

Now that the Counter component has been created, add it to the Home component, and pass it the provider and user's smartAccount:

...
// highlight-next-line
import Counter from '@/component/Counter';

export default function Home() {

...

   return (
    <main>
      <div>
      {!loading && !address && <button onClick={login}>Login</button>}
      {loading && <p>Loading...</p>}
      {address && <h2>Smart Account Address: {address}</h2>}
      // highlight-next-line
      <Counter smartAccount={smartAccount} provider={provider}/>
      </div>
    </main>
  );
}

Executing the transaction

With all of the components set up, you are ready to run and test the app by logging in and executing a gasless transaction.

Perform the following steps:

Run the application by running yarn dev
Click the Login button to login and create a smart account
Once logged in, click the Increment button to execute the increment() function of the smart contract
Upon a successful transaction, observe the number update.

Conclusion

Congratulations! You have successfully learned how to implement Account Abstraction in your Base projects using Biconomy.

To learn more about Account Abstraction and Biconomy, check out the following resources:

Building an onchain app on Base using thirdweb

Taylor Caldwell — Mon, 27 Jan 2025 04:28:22 +0000

In this tutorial you will learn how to build an app on Base using the thirdweb platform.

To achieve this, you will deploy a smart contract for a NFT collection and create an NFT gallery app for viewing the metadata details of each NFT within the collection.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial, you should be able to:

Create an NFT collection and mint new NFTs using thirdweb.
Develop an NFT gallery app using a prebuilt thirdweb templates.

Prerequisites

1. Setting Up a Coinbase Wallet

To begin developing an app on Base, you first need to set up a web3 wallet. We recommend using the Coinbase Wallet, which can be easily created by downloading the Coinbase Wallet browser extension.

Download Coinbase Wallet

2. Wallet Funding

Blockchain transactions, including deploying smart contracts, necessitate a gas fee. Therefore, you will need to fund your wallet with ETH to cover those gas fees.

For this tutorial, you will be deploying a contract to the Base Sepolia test network. You can fund your wallet with Base Sepolia ETH using one of the faucets listed on the Base Network Faucets page.

Creating an NFT Collection

Before developing an app, you need to create an NFT collection via thirdweb.

Follow these steps to set up your NFT collection:

Visit the thirdweb dashboard.
Click the Connect Wallet button located in the upper right corner to connect your wallet.
From the dashboard, select Browse contracts to explore a list of deployable smart contracts.
Navigate to the NFTs section and select the NFT Collection smart contract.
Click the Deploy now button.
Provide the required details for your NFT collection:
1. Contract metadata (i.e. image, name, symbol, description)
2. Network (Choose Base Sepolia Testnet)
Click Deploy Now.

Info: For production / mainnet deployments select Base (mainnet) as the network rather than Base Sepolia.

Post-deployment, you can manage your smart contract via the thirdweb dashboard.

Currently, your NFT Collection lacks NFTs. To populate our upcoming NFT Gallery app, we will need to create several NFTs.

Follow the steps below to mint new NFTs:

Visit the thirdweb dashboard.
From the dashboard, select View contracts to view all your previously deployed contracts.
Select the NFT Collection smart contract you deployed.
Navigate to the NFTs tab on the left-hand sidebar.
Click Mint.
Fill in the metadata details for the NFT (name, media, description, properties).
Click Mint NFT.

Repeat these steps to mint as many NFTs as you'd like.

Building an NFT Gallery App

With an NFT Collection in place, it's time to construct an NFT Gallery App. The thirdweb CLI provides various prebuilt and starter templates for popular app use-cases, which can significantly expedite your app development process.

In this tutorial, we'll use the thirdweb CLI to generate a new app project using the NFT Gallery template.

Run the following command:

npx thirdweb create --template nft-gallery

By default, the template is configured for an NFT collection on the Ethereum Mainnet. We will modify the code to adapt our NFT collection on the Base Sepolia Testnet.

Follow these steps to update the template:

Open the project using your preferred code editor.
Open the src/consts/parameters.ts file.
1. Update the contractAddress variable to your NFT collection's contract address (found on the thirdweb dashboard).
2. Update the chain variable to base-sepolia.
3. Update the blockExplorer variable to https://sepolia.basescan.org.
Open the src/main.tsx file.
Replace the file contents with the following code:

    import React from "react";
import ReactDOM from "react-dom/client";
import App from "./App";
import "./index.css";
import { ThirdwebProvider } from "@thirdweb-dev/react";
import { BaseSepoliaTestnet } from "@thirdweb-dev/chains";


ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
  <React.StrictMode>
    <ThirdwebProvider activeChain={BaseSepoliaTestnet}>
      <App />
    </ThirdwebProvider>
  </React.StrictMode>,
);

The above code imports and uses BaseSepoliaTestnet to be the activeChain.

Info: For production / mainnet deployments, update the information above so that the chain variable is base (step ii), the blockExplorer is https://basescan.org (step iii), and update both instances of BaseSepoliaTestnet to Base in the example javascript code.

Running the Application

With the updated Base Sepolia Testnet chain and your NFT collection's address, you can view your NFT collection from the application.

To start the application, run the following command from the root directory:

yarn dev

Conclusion

Congratulations on reaching the end of this tutorial! You've now learned how to create an NFT collection using Thirdweb, mint new NFTs, and build an NFT gallery app on the Base blockchain!

As a next step, check out other prebuilt smart contracts and starter templates provided by the thirdweb platform that can help you build your next onchain app on Base.

Running a Base Node

Taylor Caldwell — Mon, 27 Jan 2025 04:28:12 +0000

This tutorial will walk you through setting up your own Base Node.

Note: This tutorial was originally published and authored by @taycaldwell on https://docs.base.org. You can find the original tutorial here.

Objectives

By the end of this tutorial you should be able to:

Deploy and sync a Base node

Prerequisites

Caution: Running a node is time consuming, resource expensive, and potentially costly. If you don't already know why you want to run your own node, you probably don't need to.

If you're just getting started and need an RPC URL, you can use our free endpoints:

Mainnet: https://mainnet.base.org

Testnet (Sepolia): https://sepolia.base.org

Note: Our RPCs are rate-limited, they are not suitable for production apps.

If you're looking to harden your app and avoid rate-limiting for your users, please check out one of our partners.

Hardware requirements

We recommend you have this configuration to run a node:

8-Core CPU
at least 16 GB RAM
a locally attached NVMe SSD drive
adequate storage capacity to accommodate both the snapshot restoration process (if restoring from snapshot) and chain data, ensuring a minimum of (2 * current_chain_size) + snapshot_size + 20%_buffer

Info: If utilizing Amazon Elastic Block Store (EBS), ensure timing buffered disk reads are fast enough in order to avoid latency issues alongside the rate of new blocks added to Base during the initial synchronization process; io2 block express is recommended.

Docker

This tutorial assumes you are familiar with Docker and have it running on your machine.

L1 RPC URL

You'll need your own L1 RPC URL. This can be one that you run yourself, or via a third-party provider, such as our partners.

Running a Node

Clone the repo.
Ensure you have an Ethereum L1 full node RPC available (not Base), and set OP_NODE_L1_ETH_RPC & OP_NODE_L1_BEACON (in the .env.* file if using docker-compose). If running your own L1 node, it needs to be synced before Base will be able to fully sync.
Uncomment the line relevant to your network (.env.sepolia, or .env.mainnet) under the 2 env_file keys in docker-compose.yml.
Run docker compose up. Confirm you get a response from:

curl -d '{"id":0,"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["latest",false]}' \
  -H "Content-Type: application/json" http://localhost:8545

Caution: Syncing your node may take days and will consume a vast amount of your requests quota. Be sure to monitor usage and up your plan if needed.

Snapshots

If you're a prospective or current Base Node operator and would like to restore from a snapshot to save time on the initial sync, it's possible to always get the latest available snapshot of the Base chain on mainnet and/or testnet by using the following CLI commands. The snapshots are updated every week.

Restoring from snapshot

In the home directory of your Base Node, create a folder named geth-data or reth-data. If you already have this folder, remove it to clear the existing state and then recreate it. Next, run the following code and wait for the operation to complete.

Info: Public Geth Archive Snapshots were deprecated on December 15th, 2024 and recommend switching to Reth going forward. We will continue to maintain the Reth archive snapshot.

Network	Client	Snapshot Type	Command
Testnet	Geth	Full	`wget https://sepolia-full-snapshots.base.org/$(curl https://sepolia-full-snapshots.base.org/latest)`
Testnet	Geth	Archive	No longer supported
Testnet	Reth	Archive	`wget https://sepolia-reth-archive-snapshots.base.org/$(curl https://sepolia-reth-archive-snapshots.base.org/latest)`
Mainnet	Geth	Full	`wget https://mainnet-full-snapshots.base.org/$(curl https://mainnet-full-snapshots.base.org/latest)`
Mainnet	Geth	Archive	No longer supported
Mainnet	Reth	Archive	`wget https://mainnet-reth-archive-snapshots.base.org/$(curl https://mainnet-reth-archive-snapshots.base.org/latest)`

You'll then need to untar the downloaded snapshot and place the geth or reth subfolder inside of it in the geth-data or reth-data folder you created (unless you changed the location of your data directory).

Return to the root of your Base node folder and start your node.

cd ..
docker compose up --build

Your node should begin syncing from the last block in the snapshot.

Check the latest block to make sure you're syncing from the snapshot and that it restored correctly. If so, you can remove the snapshot archive that you downloaded.

Syncing

You can monitor the progress of your sync with:

echo Latest synced block behind by: $((($(date +%s)-$( \
  curl -d '{"id":0,"jsonrpc":"2.0","method":"optimism_syncStatus"}' \
  -H "Content-Type: application/json" http://localhost:7545 | \
  jq -r .result.unsafe_l2.timestamp))/60)) minutes

You'll also know that the sync hasn't completed if you get Error: nonce has already been used if you try to deploy using your node.

DEV Community: Taylor Caldwell

Accessing real-time asset data on Abstract using Pyth Price Feeds

Objectives

Prerequisites

Foundry

Metamask Wallet

Wallet funds

What is Pyth Network?

Creating a project

Installing Pyth smart contracts

Writing and compiling the Smart Contract

Deploying the smart contract

Setting up your wallet as the deployer

Setting up environment variables for Abstract Sepolia

Deploying the smart contract to Abstract Sepolia

Interacting with the Smart Contract

Conclusion

Sending messages from Abstract to other chains using LayerZero V2

Objectives

Prerequisites

Foundry

Metamask Wallet

Wallet funds

What is LayerZero?

High-level concepts

Endpoints

Security Stack (DVNs)

Executors

Creating a project

Installing the LayerZero smart contracts

Getting started with LayerZero

Writing the smart contract

Implementing message sending (_lzSend)

Implementing gas fee estimation (_quote)

Implementing message receiving (_lzReceive)

Final code

Compiling the smart contract

Deploying the smart contract

Setting up your wallet as the deployer

Setting up environment variables

Deploying the smart contract to Abstract Testnet

Deploying the smart contract to Arbitrum Testnet

Opening the messaging channels

Setting the peers

Sending messages

Building message options

Estimating the gas fee

Sending the message

Receiving the message

Conclusion

Deploying a smart contract to Abstract using Hardhat

Objectives

Prerequisites

Node v18+

Metamask Wallet

Wallet funds

Creating a project

Configuring Hardhat with Abstract

Install Hardhat toolbox

Loading environment variables

Local Networks

Compiling the smart contract

Deploying the smart contract

Verifying the Smart Contract

Interacting with the Smart Contract

Deploying a smart contract to Abstract using Foundry

Objectives

Prerequisites

Foundry

Metamask Wallet

Wallet funds

Creating a project

Compiling the smart contract

Configuring Foundry with Abstract

Storing your private key

Adding Abstract as a network

Loading environment variables

Deploying the smart contract

Verifying the Smart Contract

Interacting with the Smart Contract

Implementing message sending (`_lzSend`)

Implementing gas fee estimation (`_quote`)

Implementing message receiving (`_lzReceive`)