Skip to main content
Base is an EVM-equivalent Ethereum L2. Smart contracts are written in Solidity or Vyper and deploy exactly as they do on Ethereum — the same bytecode, ABIs, and tooling apply.

​
Token Standards

Any token standard implemented as a smart contract deploys and behaves on Base as it does on Ethereum. That includes ERC-20, ERC-721, ERC-1155, ERC-4626 vaults, and permissioned-token standards such as ERC-3643. These are contracts that you or your provider deploy, upgrade, and maintain; the Base node does not implement them. B20 is Base’s native token standard. It runs as precompiles in the node and keeps full selector and behavior parity with ERC-20, so ERC-20 tooling works with B20 tokens unchanged. B20 logic changes only through network upgrades, and each change is listed in the B20 changelog.

​
How Base Differs

Base adds native precompiles at fixed addresses that extend the EVM with functionality built into the node itself, such as the B20 token standard, the PolicyRegistry, and the B20 Factory. These addresses hold no contract bytecode, so standard Foundry (forge, cast, anvil) cannot simulate calls to them and aborts with call to non-contract address. Base publishes base-anvil, a fork of Foundry that registers Base’s precompiles into its EVM. It installs base-forge, base-cast, and base-anvil alongside your existing Foundry toolchain without overwriting it, so contracts behave the same locally as they do on Base.
Use Base’s Foundry build (base-forge, base-cast, base-anvil) rather than standard Foundry (forge, cast, anvil) for Base development. A contract that reads or writes a Base precompile — for example one that deploys or calls a B20 token — will fail under standard Foundry.

​
Set Up Your Environment

  1. Create a new project directory
Terminal
  1. Install Base’s Foundry build
Terminal
This installs base-forge, base-cast, and base-anvil alongside your existing Foundry toolchain.
  1. Initialize a new Solidity project
Terminal
Your project is ready. You’ll find an example Counter contract in src/Counter.sol, which you can replace with your own contracts.
Base’s Foundry build provides the same tools as standard Foundry, with Base’s precompiles built in: base-forge (build and test), base-cast (interact with the chain), and base-anvil (run a local Base node). Learn more about base-anvil and the underlying Foundry toolchain.

​
Configure a Node Connection and Deployer Key

  1. Create a .env file in your project root and add the Base RPC URLs
.env
  1. Load the variables
Terminal
  1. Store your deployer private key in Foundry’s secure keystore
Terminal
Enter your private key and a password when prompted. The key is stored in ~/.foundry/keystores, which is not tracked by git.
Never share or commit your private key. Always keep it secure and handle it with care.
Base Sepolia is the test network for Base, used for the rest of this guide. Get free Base Sepolia ETH from one of the faucets listed here.

​
Deploy a Contract

  1. (Optional) Dry-run the deployment to confirm your configuration:
Terminal
This simulates the deployment without broadcasting. You’ll see the transaction details and contract ABI, but nothing is deployed.
  1. Deploy by adding the --broadcast flag:
Terminal
The contract path format is <contract-path>:<contract-name>.
  1. On success you’ll see the deployed address:
Example Output

​
Verify Your Deployment

  1. Check the transaction on Sepolia Basescan using the transaction hash.
  2. Read the contract’s state from the command line:
Terminal
This returns the initial value of the Counter contract’s number variable, 0.

​
Next Steps

B20 Token Standard

Launch Base’s native token standard, built in at the precompile level.

Connect to Base

Network details, RPC endpoints, and wallet configuration.
Use wagmi or viem to connect your frontend to your contracts, and see the Foundry scripting guide for command-line interaction.