Contract deployment
Building apps on Linea needn't be complicated. In this guide, we'll walk you through using Foundry to create a new project from scratch.
This involves:
- Creating a project
- Deploying and then verifying your contract.
Estimated time to complete: ~20 minutes.
Prerequisites
A Linea-compatible wallet with some Linea Sepolia ETH. We recommend using MetaMask.
Get some testnet ETH by heading to our Discord server and asking in
the #developer-chat channel. Our admins or other community members will help you out.
Create your project
To get started, we're going to use Foundry's forge init command to create a new project. forge
is the Foundry CLI tool.
Firstly, let's install Foundry:
curl -L https://foundry.paradigm.xyz | bash
Then initiate the new project, choosing whatever name you prefer. Make sure you're in the directory you want to create your project in:
forge init linea_test_project
Foundry will build out the file structure and create a git repository. It also installs one
dependency: forge-std, the Forge Standard Library, which enables you to test your project.
To get more familiar with your new project, it might help to open it in a code editor and inspect
the files.
You can also run forge build to compile your project, and then forge test to use the forge-std
testing library.
If you already have a project set up, clone the project and run forge install in the directory to
use Foundry. See the Foundry guide
for more information.
Deploy your contract
The default Foundry template comes with a simple placeholder contract, Counter.sol. You're likely
going to need something with a bit more functionality. You probably already have a idea of what
you want your app to do, and you might have the skills to write your own contract from scratch.
For simplicity, we're going to stick with Counter.sol, but you can use any template you want, or
refer to our contract templates section for more inspiration.
We'll use the forge create command to deploy the contract. First, we must get an RPC endpoint and
ensure we have a secure method for using a private key.
RPC endpoints
Get your RPC endpoint
To deploy a contract, you need to interact with the blockchain, which means you need an RPC endpoint to send those calls to.
To keep things simple, we're going to use the default public RPC endpoint for Linea Sepolia:
https://rpc.sepolia.linea.build.
Public endpoints such as this one are rate limited, and if you intend to deploy your app for public use, you'll need an endpoint better equipped to handle the load. We recommend heading to the MetaMask Developer Dashboard to get a private RPC endpoint (instructions).
You can also find alternative public and private RPC endpoints on our node providers page.
Update foundry.toml
Add the RPC endpoint to the foundry.toml file:
[profile.rpc-endpoints]
sepolia = "https://rpc.sepolia.linea.build"
Store your private key
Deploying a contract requires an account's private key, which means you need to either provide it in the command line when running the deployment command (not recommended) or store it securely and access it with alternative methods. See the MetaMask support guide to finding your private key.
We recommend creating a new account in MetaMask specifically for this project, and naming it something appropriate, such as "linea-project".
Even though we're working on a testnet, it's best to behave as if real assets were at stake, and work in a sandboxed context with a somewhat expendable account.
A standard approach is to store your private key as an environment variable in a .env file that
is only stored locally (i.e. listed in .gitignore file). However, we're going to use Foundry's
keystore system to encrypt and store the private key, and then access it with a password. This
ensures that you won't accidentally expose your private key—for example, in a GitHub repository.
To do this, we'll use Foundry's cast CLI tool; specifically,
the cast wallet import command.
cast wallet import --interactive test-account
The --interactive flag means that you'll be prompted to enter your private key in the terminal,
followed by a corresponding password. test-account is the name you want to give the account in
the keystore; choose whatever is suitable for your purposes here.
When you enter the private key and then your password, you'll get confirmation that it has been stored successfully:
`test-account` keystore was saved successfully. Address: <YOUR_PUBLIC_ADDRESS>
Run cast wallet list to see accounts in your keystore.
Deploy
Adjust Solidity version
By default, the forge init command we used originally creates the Counter.sol contract with the
following Solidity compiler version:
pragma solidity ^0.8.13;
This enables the compiler to use any version newer than Solidity v0.8.13. Linea is only compatible with Solidity 0.8.19 or lower, so we need to make some adjustments.
Add this line to [profile.default] in your foundry.toml file:
solc-version = 0.8.19
So that your [profile.default], which is applied universally, now looks like this:
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc-version = "0.8.19"
Run forge create
With your RPC endpoint to hand and your private key stored more securely, you're ready to deploy
using forge create.
Execute this command, then enter your password to use the private key when prompted:
forge create --rpc-url https://rpc.sepolia.linea.build --account test-account --broadcast src/Counter.sol:Counter
--rpc-urlis the RPC endpoint you want to use.--accountis the keystore account you want to use to deploy the contract.--broadcasttells Forge to send the transaction to the network. You can test the command by omitting this flag, but you won't actually deploy the contract.
The format of the contract you want to deploy is path/to/contract.sol:ContractName; in this case,
we want the Counter contract from src/Counter.sol.
If successful, you'll see this in the terminal:
Deployer: 0x ... // The address of the account used to deploy the contract
Deployed to: 0x ... // The address of the deployed contract
Transaction hash: 0x ... // The deployment transaction itself
You can copy each of these addresses and head to the block explorer to see the deployed contract.
Make sure to copy the Deployed to address, as you'll need it to verify the contract. It'll also
be useful in part two of this quickstart, where we'll need it to interact with the contract in our
app.
Verify your contract
Verifying a contract makes the source code publicly visible, and also confirms to others that it originated from a genuine source.
Verifying can be done with the forge verify-contract command, and requires a Lineascan API key.
Get a Lineascan API key
Get a Lineascan API key by creating an account.
Since it's best practice to avoid using API keys in the command line, add the API key to your
.env file:
LINEASCAN_API_KEY=YOUR_LINEASCAN_API_KEY
Then modify the foundry.toml configuration file to include the Lineascan API key, pulling it from
the .env file:
[etherscan]
linea-sepolia = { key = "${LINEASCAN_API_KEY}" }
Run forge verify-contract
Execute this command:
forge verify-contract --chain linea-sepolia YOUR_CONTRACT_ADDRESS path_to_contract:contract_name --watch
--watch automatically runs the forge verify-check command to report verification status in the
terminal until verification is complete.
You can also complete verification at the same time as deployment by adding the --verify and
--verifier-url flags to the forge create command, and providing your Lineascan API key.
For example:
forge create --rpc-url https://rpc.sepolia.linea.build --account test-account --broadcast --verify --verifier-url https://api-sepolia.lineascan.build/api --etherscan-api-key LINEASCAN_API_KEY src/Counter.sol:Counter
Now you've successfully deployed and verified your contract! It's recorded on the blockchain and ready to receive calls from your app.
Next steps
Proceed to part two of this quickstart, where we'll build a simple web app for interacting with the counter contract.
Help and resources
If you get stuck at any point in this guide, head to our Discord and
visit the #developer-chat channel.