Deploy on Base

Set up a Foundry project, point it at Base, and deploy a contract to Base Sepolia in a single end-to-end workflow.

Base is EVM-equivalent, so Solidity and Vyper contracts carry over from Ethereum unchanged — same bytecode, same ABIs, same tooling. The one place that equivalence stops is the precompiles.

Caution

Use Base’s Foundry build, not stock Foundry. Base exposes native precompiles at fixed addresses — the B20 token standard, the PolicyRegistry, and the B20 Factory among them. Those addresses carry no bytecode, so forge, cast, and anvil cannot simulate a call into them and give up with call to non-contract address. Any contract that touches one of them — minting a B20 token, say, or reading its supply — breaks under stock Foundry. base-anvil is Base’s fork, and it teaches the EVM about those addresses.

What you build

By the end of this guide you will have:

• A development environment running Base’s Foundry build
• A smart contract deployed to Base Sepolia
• A connection pattern your frontend can reuse against your contracts

Tip

Base is a fast, low-cost, builder-friendly Ethereum L2 designed to bring the next billion users onchain. Following this guide plugs you into a wide ecosystem of developers, creators, and operators building the global onchain economy.

Set up your development environment

1. Create a project directory.

mkdir my-base-project && cd my-base-project

2. Install Base’s Foundry build, used throughout this guide.

curl -L https://raw.githubusercontent.com/base/base-anvil/HEAD/foundryup/install | bash
base-foundryup

This lands base-forge, base-cast, and base-anvil next to whatever Foundry you already have. Nothing is overwritten, and the two toolchains coexist.

3. Initialize a Solidity project.

base-forge init

The project is ready. The starter contract sits at src/Counter.sol — this guide uses that contract as the deployment target.

Tip

The Base build mirrors stock Foundry one for one, with the precompiles registered: base-forge builds and tests, base-cast talks to the chain, and base-anvil runs a local Base node. See base-anvil for the fork itself and the Foundry Book for the underlying tooling.

Configure the toolchain for Base

Deploying to Base requires two pieces:

1. An RPC connection to the network
2. A funded private key for signing the deployment transaction

1. Set up your RPC connection

1. Create a .env file at the project root.
2. Add the Base RPC URLs.

BASE_RPC_URL="https://mainnet.base.org"
BASE_SEPOLIA_RPC_URL="https://sepolia.base.org"

3. Load the variables into your shell.

source .env

Tip

Base Sepolia serves as the Base test network, and the rest of this guide runs against it. Free Base Sepolia ETH is available from the faucets list.

2. Secure your private key

1. Import your private key into the encrypted keystore.

base-cast wallet import deployer --interactive

2. Paste the key when prompted and set a password.

The encrypted key is stored at ~/.foundry/keystores, which is excluded from git.

Caution

Never share or commit a private key. Treat it as a credential and store it accordingly.

Deploy your contract

With the environment configured, deploy to Base Sepolia.

1. (Optional) Run a dry run first to confirm the deployment is well-formed.

base-forge create ./src/Counter.sol:Counter --rpc-url $BASE_SEPOLIA_RPC_URL --account deployer

This simulates the deploy without broadcasting. You will see the transaction details and ABI; nothing is written onchain.

2. Add --broadcast to actually deploy.

base-forge create ./src/Counter.sol:Counter --rpc-url $BASE_SEPOLIA_RPC_URL --account deployer --broadcast

Tip

The --broadcast flag is required to send the transaction. Without it, the run stops at simulation.

The contract argument follows the format <contract-path>:<contract-name>.

3. A successful deploy prints output similar to:

Deployer: 0x...
Deployed to: 0x...  <-- YOUR CONTRACT ADDRESS
Transaction hash: 0x...

4. Save the deployed address into .env.

COUNTER_CONTRACT_ADDRESS="0x..."

Replace 0x... with the address from the output.

5. Reload the variables.

source .env

Tip

Re-run source .env after every change to load new variables into the current shell.

Verify your deployment

To confirm the contract is live:

1. Look up the transaction hash on Sepolia Basescan.
2. Read the contract directly with base-cast:

base-cast call $COUNTER_CONTRACT_ADDRESS "number()(uint256)" --rpc-url $BASE_SEPOLIA_RPC_URL

Tip

The command requires COUNTER_CONTRACT_ADDRESS in .env and a fresh source .env. Otherwise the variable expands to nothing and the call fails.

The call returns the initial value of the Counter’s number storage slot, which is 0.

The contract is now live on Base Sepolia.

Next steps

• Launch a token on Base’s native standard, built in at the precompile level — see B20 and the B20 precompile reference.
• Wire a frontend to your contracts using wagmi or viem.
• Drive deployments from scripts with the Foundry scripting guide.