Skip to content
On this page

Polaris EVM and Rollkit

This tutorial provides step-by-step instructions for running the Polaris EVM using Rollkit. Polaris EVM is a version of the Ethereum Virtual Machine (EVM) that is designed to run the Berachain network. This version has been modified to use Celestia as a data availability layer. This integration uses a local-celestia-devnet. Rollkit is used to deploy a Polaris EVM rollup without needing to set up a data availability and consensus network.


Learn how to restart your rollup.


Before you can run Polaris EVM using Rollkit, you need to have the following software installed on your machine:

  • Docker running on your machine
  • Go version >= 1.21.0

Run a local-celestia-devnet

Before you can start Polaris EVM, you need to start a local-celestia-devnet instance in a separate terminal:

docker run -t -i --platform linux/amd64 -p 26657:26657 -p 26658:26658 -p 26659:26659

Clone the repo

To get started, clone the Polaris repository and switch to the Rollkit branch:

cd $HOME
git clone
cd polaris && git checkout rollkit-main

Install Foundry

curl -L | bash

Start the Polaris EVM using Rollkit

Then start the chain in your first terminal:

cd $HOME/polaris && foundryup
make start


You now have a Polaris EVM Rollkit rollup running! The rollup logs will begin to look similar to this:

7:58PM INF submitting block to DA layer height=11 module=BlockManager 
7:58PM INF successfully submitted Rollkit block to DA layer daHeight=30 module=BlockManager rollkitHeight=11 
7:58PM INF prune start height=11 module=server
7:58PM INF prune end height=11 module=server
7:58PM INF indexed block events height=11 module=txindex
7:58PM INF Creating and publishing block height=12 module=BlockManager 
7:58PM INF preparing evm block module=polaris-geth seal_hash=0x314b131b1d4117445091b25240eaf420cdbdcf9f653eabd1d95aa0dab3cd1359
7:58PM INF finalizing evm block block_hash=0x5207a1ff35540dafe70565d3a95ed07f6c9b1ed9114f93c6c47ee0a1c0d4cc2e module=polaris-geth num_txs=0
7:58PM INF finalized block block_app_hash=AC959F089C21DC617275E0AB35E77DC3839C9597ECFDECDAD6C924EC49B1EB07 height=12 module=BlockManager num_txs_res=0 num_val_updates=0
7:58PM INF executed block app_hash="���\b�!�aru��5�}���������$�I��\a" height=12 module=BlockManager


The following private key has funds on your Polaris chain:

Address: 0x20f33CE90A13a4b5E7697E3544c3083B8F8A51D4
PrivateKey: 0xfffdbb37105441e14b0ee6330d855d8504ff39e705c3afa8f859ac9865f99306

Just deploy a smart contract to get started! If you'd like to learn how to deploy your own GM Portal (as an ooga booga portal) you can follow the remainder of this tutorial.


Now we will make a frontend with a smart contract on our Polaris EVM rollup. First, clone the GM Portal repository and check out to the Polaris branch (ooga booga portal):

cd $HOME
git clone
cd gm-portal && git checkout polaris

Deploy the ooga booga portal contract

Next, you will deploy the smart contract. Export the funded private key and RPC URL:

export PRIVATE_KEY=0xfffdbb37105441e14b0ee6330d855d8504ff39e705c3afa8f859ac9865f99306
export RPC_URL=http://localhost:8545

Use Foundry to deploy the contract to your EVM:

cd contracts
forge script script/GmPortal.s.sol:GmPortalScript --rpc-url $RPC_URL --private-key $PRIVATE_KEY --broadcast

A successful deployment's output will look similar to:

forge script script/GmPortal.s.sol:GmPortalScript --rpc-url $RPC_URL --private-key $PRIVATE_KEY --broadcast
[] Compiling...
[] Compiling 18 files with 0.8.20
[] Solc 0.8.20 finished in 1.52s
Compiler run successful!
Script ran successfully.

== Logs ==
  i am a smart contract on Polaris EVM x Rollkit. gm!


Waiting for receipts.
 [00:00:00] [######################] 1/1 receipts (0.0s)
##### 2061
  [Success]Hash: 0xa174e9389633972458e6dce431d84736e0709e9406c1c3b14b5fa9ae0cdd6860
Contract Address: 0x18Df82C7E422A42D47345Ed86B0E935E9718eBda 
Block: 682
Paid: 0.001528707003566983 ETH (509569 gas * 3.000000007 gwei)


From the contract deployment output, export your contract address:

export CONTRACT_ADDRESS=0x18Df82C7E422A42D47345Ed86B0E935E9718eBda

Interact with the contract

Send an "ooga booga" to the contract:

"gm(string)" "ooga booga" \
--private-key $PRIVATE_KEY \
--rpc-url $RPC_URL

Get total (hex-encoded) GMs (ooga boogas):

cast call $CONTRACT_ADDRESS "getTotalGms()" --rpc-url $RPC_URL

Start and update the frontend

Now, change into the frontend directory:

cd $HOME/gm-portal/frontend
yarn && yarn dev


Now, your frontend is running! We'll display and interact with our smart contract on our frontend.

First, you will need to change the contract address on gm-portal/frontend/src/App.tsx to your contract address from above before you can interact with the contract on the frontend:


Only if you changed the contract, you will need to update the ABI in gm-portal/frontend/GmPortal.json from gm-portal/contracts/out/GmPortal.sol/GmPortal.json. This can be done with:

cd $HOME
cp gm-portal/contracts/out/GmPortal.sol/GmPortal.json gm-portal/frontend

Interact with the frontend

In order to interact with the contract on the frontend, you'll need to fund an account that you have in your Ethereum wallet or add the private key from above into your wallet.

To transfer to an external account, use this command:

export RECEIVER=<receiver ETH address>
cast send --private-key $PRIVATE_KEY $RECEIVER --value 1ether --rpc-url $RPC_URL

If you are in a different terminal than the one you set the private key in originally, you may need to set it again.

Now, login with your wallet that you funded, and post a ooga booga on your ooga booga portal!


Running Polaris EVM with a Celestia light node

In this portion of the tutorial, we will go over running Polaris x Rollkit using a Celestia light node to post data to Mocha testnet. These steps can be used for Mainnet Beta and Arabica devnet, too, you'll just need to change the network in the string flag.


Before using RPC methods through the CLI, you'll need to set your auth token.

In order to successfully post and retrieve data to and from Celestia's Mocha testnet, your light node will need to be fully synced. You can check the status by using the das.SamplingStats method using the CLI.

Your node will also need to be funded with testnet TIA, which you can obtain by retrieving your account address and visiting a faucet.

Start your light node

First, you'll need to start your light node, connected to a consensus core endpoint. This will allow you to post data to the network.

Start the node:

celestia light start --core.ip mocha

Setup Polaris script

First, ensure you're on the correct branch of Polaris:

cd $HOME/polaris && git checkout rollkit-main

Before starting your rollup, you'll want to make changes in $HOME/polaris/e2e/testapp/

# set the auth token for DA bridge node
AUTH_TOKEN=$(docker exec $(docker ps -q)  celestia bridge /home/celestia/bridge/ auth admin) 
AUTH_TOKEN=$(celestia light auth admin mocha) 

# set the data availability layer's block height from local-celestia-devnet
DA_BLOCK_HEIGHT=$(docker exec $(docker ps -q) celestia header local-head --token $AUTH_TOKEN | jq '.result.header.height' -r) 
DA_BLOCK_HEIGHT=$(curl |jq -r '.result.block.header.height') 

Start the EVM rollup

Change into the Polaris directory in your terminal:

cd $HOME/polaris
make start

Congratulations! Your light node is now posting your rollup's data to Celestia's Mocha testnet.

Released under the APACHE-2.0 License