Building on World Chain

Deploy a sample contract on World Chain

In this tutorial, we will use the Solidity programming language to write the HelloWorldChain smart contract for World Chain. Solidity is a programming language that can compile to EVM (Ethereum Virtual Machine) bytecode which can be executed on the World Chain EVM. We will also be using the Foundry CLI toolkit, which has a lot of tools to help build, test and interact with Solidity programs.

Download development tools

First, we need to install the Foundry CLI toolkit and the Solidity compiler. Solidity comes with a compiler called solc which we will use to compile the HelloWorldChain contract. The Foundry CLI will automatically download the right version of the Solidity compiler for you during the compilation process using forge build.

curl -L https://foundry.paradigm.xyz | bash

Create a Foundry project

Open your terminal of choice, navigate to a directory where you want to create your project, and run the following command to create a new Foundry project:

forge init hello-world-chain && cd hello-world-chain

Now that you have created a new Foundry project, you can start writing your smart contract. All smart contracts in Foundry projects are stored in the src directory. If you are using VSCode, it should something look like this:

Write the HelloWorldChain contract

First, delete the template file called Counter.sol in the /src directory:

rm src/Counter.sol

Next, create a new file called HelloWorldChain.sol in the /src directory and add the following code to it:

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

contract HelloWorldChain {
    string private word;

    // Constructor that sets the initial word to "Hello World Chain!"
    constructor() {
        word = "Hello World Chain!";
    }

    // Setter function to update the word
    function setWord(string memory newWord) public {
        word = newWord;
    }

    // Getter function to return the current word
    function getWord() public view returns (string memory) {
        return word;
    }
}

This contract has a word variable that stores a string and two functions: setWord to update the word and getWord to return the current word.

Update Scripts and Tests

Since we deleted Counter.sol, we need to update or remove the scripts and tests that reference it to prevent compilation errors.

Delete the script directory

The script directory contains scripts that import Counter.sol. Since we no longer have Counter.sol, we can delete the entire script directory to avoid any compilation issues:

rm -rf script

Replace Counter.t.sol with HelloWorldChain.t.sol

In the test directory, delete the existing Counter.t.sol and create a new test file called HelloWorldChain.t.sol and add the following simple tests:

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

import "forge-std/Test.sol";
import "../src/HelloWorldChain.sol";

contract HelloWorldChainTest is Test {
    HelloWorldChain helloWorldChain;

    function setUp() public {
        helloWorldChain = new HelloWorldChain();
    }

    function testInitialWord() public view {
        string memory expected = "Hello World Chain!";
        string memory actual = helloWorldChain.getWord();
        assertEq(actual, expected);
    }

    function testSetWord() public {
        string memory newWord = "Hello Foundry!";
        helloWorldChain.setWord(newWord);
        string memory actual = helloWorldChain.getWord();
        assertEq(actual, newWord);
    }
}

Now You can Run tests:

forge test

Compile the contract

To compile the HelloWorldChain contract, run the following command:

forge build

The forge build command will compile the contract using the Solidity compiler and generate the necessary artifacts in the artifacts directory.

Generate a wallet

To deploy the HelloWorldChain contract to World Chain Sepolia, you will need a wallet with some World Chain Sepolia ETH. An easy way to generate a wallet using the Foundry CLI is to run the following command:

cast wallet new

cast is a versatile set of utility functions and commands for Solidity development. In this case, we are using one of its many built-in features to generate a wallet with one account.

The output of the command will look something like this:

Successfully created new keypair.
Address:     0xB815A0c4bC23930119324d4359dB65e27A846A2d
Private key: 0xcc1b30a6af68ea9a9917f1dda20c927704c5cdb2bbe0076901a8a0e40bf997c5

Fund your wallet

Now that you have a wallet, you need to fund it with some World Chain Sepolia ETH. You can get some World Chain Sepolia ETH from the World Chain Sepolia faucet operated by Alchemy. In the form on the faucet page, enter the address of your wallet which you generated above and click the "Send me ETH" button. If you have any issues please send us a message in the developer group chat on Telegram or Discord.

Deploy the contract

Now that you have a wallet and you funded it with World Chain Sepolia ETH, you can deploy the HelloWorldChain contract to World Chain Sepolia using the following forge create command:

forge create src/HelloWorldChain.sol:HelloWorldChain --rpc-url https://worldchain-sepolia.g.alchemy.com/public --private-key 0xcc1b30a6af68ea9a9917f1dda20c927704c5cdb2bbe0076901a8a0e40bf997c5

Here, we are using the <path>:<contractname> format to specify the contract. This tells Foundry where to find the contract file (src/HelloWorldChain.sol) and which contract within the file (HelloWorldChain) to deploy. We also use the --rpc-url flag to specify the RPC URL of the World Chain Sepolia network and the --private-key flag to specify the private key of the wallet we generated earlier. On top of this we can also provide other flags like -vvvvv to get more verbose output from the deployment process, --verify to verify the contract on Worldscan or Blockscout (alongside with an --etherscan-api-key flag) and several other flags to toggle different features that you can find more about in the Foundry documentation.

And that's it! You have successfully deployed a smart contract to World Chain Sepolia. You can interact with the contract using forge script scripts, using a block explorer or any other EVM library like ethers.js, alloy-rs, and many others.