chore(testing): allow PoL deployment over devnet

POL_DEPLOYMENT_OVER_DEVNET.md

@@ -0,0 +1,110 @@
+# PoL deployment on devnet
+
+We will need two repositories:
+
+- BeaconKit repo, `main` [branch](https://github.com/berachain/beacon-kit/tree/main).
+- Contracts repo, `main` [branch](https://github.com/berachain/contracts/tree/main), to deploy PoL smart contracts.
+
+## Run BeaconKit
+
+Compile and run BeaconKit from the branch mentioned above, with the usual `make start` and `make start-geth` or `make start-reth`.
+
+When deploying PoL from scratch make sure that:
+
+- `<BGT_CONTRACT_ADDRESS>` matches with `specData.EVMInflationAddressDeneb1`
+- `<DISTRIBUTOR_ADDRESS>` matches with `polDistributorAddress` in `testing\files\eth-genesis.json`
+
+## Deploy PoL contracts
+
+On the contracts repo, run the following commands:
+
+```bash
+export FOUNDRY_PROFILE="deploy";
+export IS_TESTNET=false;
+export USE_SOFTWARE_WALLET=true;
+export ETH_FROM="0x20f33ce90a13a4b5e7697e3544c3083b8f8a51d4";
+export RPC_URL="http://localhost:8545";
+export ETH_FROM_PK="0xfffdbb37105441e14b0ee6330d855d8504ff39e705c3afa8f859ac9865f99306";
+```
+
+where `ETH_FROM` and `ETH_FROM_PK` are the preloaded EVM keys as described in `BeaconKit` [README](https://github.com/berachain/beacon-kit/blob/main/README.md).
+
+First off check address for relevant commands. Run
+
+```bash
+forge script script/pol/POLPredictAddresses.s.sol -vv
+```
+
+and copy the output in the file `script/pol/POLAddresses.sol` file. Usually just two contracts addresses, `BERACHEF_ADDRESS` and `REWARD_VAULT_FACTORY_ADDRESS` should have changed, but there may be more.
+
+**Very important check**: before deploying PoL make sure you are using the right BGT contract address is specified in BeaconKit chain specs.
+Run
+
+```bash
+cast balance <BGT_CONTRACT_ADDRESS> --rpc-url $RPC_URL
+```
+
+and observe the balance going up every time the validator produces a block.
+
+Once that is done run the following commands:
+
+```bash
+forge script script/pol/deployment/2_DeployBGT.s.sol --private-key $ETH_FROM_PK --sender $ETH_FROM --rpc-url $RPC_URL --broadcast -vv;
+forge script script/pol/deployment/3_DeployPoL.s.sol --private-key $ETH_FROM_PK --sender $ETH_FROM --rpc-url $RPC_URL --broadcast -vv;
+forge script script/pol/actions/ChangePOLParameters.s.sol --private-key $ETH_FROM_PK --sender $ETH_FROM --rpc-url $RPC_URL --broadcast -vv;
+```
+
+Now we need to generate 5 tokens to be associated with the 5 reward vaults we will have in the default reward allocations. Run:
+
+```bash
+forge script script/misc/testnet/DeployToken.s.sol --sig "deployBST(uint256)" 1 --sender $ETH_FROM --private-key $ETH_FROM_PK --rpc-url $RPC_URL --broadcast;
+forge script script/misc/testnet/DeployToken.s.sol --sig "deployBST(uint256)" 2 --sender $ETH_FROM --private-key $ETH_FROM_PK --rpc-url $RPC_URL --broadcast;
+forge script script/misc/testnet/DeployToken.s.sol --sig "deployBST(uint256)" 3 --sender $ETH_FROM --private-key $ETH_FROM_PK --rpc-url $RPC_URL --broadcast;
+forge script script/misc/testnet/DeployToken.s.sol --sig "deployBST(uint256)" 4 --sender $ETH_FROM --private-key $ETH_FROM_PK --rpc-url $RPC_URL --broadcast;
+forge script script/misc/testnet/DeployToken.s.sol --sig "deployBST(uint256)" 5 --sender $ETH_FROM --private-key $ETH_FROM_PK --rpc-url $RPC_URL --broadcast;
+```
+
+and for each command note down the token address, which is indicated in the logs at the line `BST deployed at: <TOKEN_ADDRESS>`.
+
+These addresses must be written in `script/pol/actions/DeployRewardVault.s.sol`. You will find in the script tokens named `LP_BERA_HONEY`, `LP_BERA_ETH`, ... `LP_BEE_HONEY`[^1]. Finally run:
+
+```bash
+forge script script/pol/actions/DeployRewardVault.s.sol --private-key $ETH_FROM_PK --sender $ETH_FROM --rpc-url $RPC_URL --broadcast -vv;
+```
+
+Once you run this file note down the Reward Vaults addresses, which should have appear in the log lines like: `RewardVault deployed at <REWARD_VAULT_ADDRESS> for staking token <TOKEN_ADDRESS>`.
+
+Now consider `script/pol/actions/WhitelistRewardVault.s.sol`. On this file:
+
+- Drop anything related to `REWARD_VAULT_USDS_HONEY`, since we only need 5 tokens.
+- Assign the reward vaults addresses from above to `REWARD_VAULT_BERA_HONEY/ETH/WBTC...`[^2].
+
+Finally run:
+
+```bash
+forge script script/pol/actions/WhitelistRewardVault.s.sol --private-key $ETH_FROM_PK --sender $ETH_FROM --rpc-url $RPC_URL --broadcast -vv;
+cast send <BERACHEF_ADDRESS> "setMaxWeightPerVault(uint96)" 2000 --private-key $ETH_FROM_PK --rpc-url $RPC_URL -vv;
+```
+
+Now consider `script/pol/actions/SetDefaultRewardAllocation`. On this file:
+
+- Replace `REWARD_VAULT_BERA_HONEY/ETH/WBTC`... with `REWARD_VAULT_1/2/3`... for every variable and variable content in the file.
+- Set `REWARD_VAULT_BERA_HONEY/ETH/WBTC..._WEIGHT`s to `2000`.
+- Assign reward vaults addresses from above in `REWARD_VAULT_BERA_HONEY/ETH/WBTC...`
+
+Finally run:
+
+```bash
+forge script script/pol/actions/SetDefaultRewardAllocation.s.sol:WhitelistIncentiveTokenScript --private-key $ETH_FROM_PK --sender $ETH_FROM --rpc-url $RPC_URL --broadcast -vv;
+```
+
+## Check BGT distribution is carried out
+
+Post Pectra11 fork, BGT distribution is automatically carried out by the execution layer. A way to check distribution is happening is checking that the validator producing blocks is receiving its base-rate BGTs via
+
+```bash
+cast call <BGT_CONTRACT_ADDRESS> "balanceOf(address)(uint256)" <OPERATOR_ADDRESS> --rpc-url $RPC_URL  
+```
+
+[^1]: You may consider renaming the tokens with `LP_TOKEN_1`, `LP_TOKEN_2`, ... `LP_TOKEN_5`.
+[^2]: Again you may consider renaming the Reward vaults with `REWARD_VAULT_1/2/3/4/5`.

cli/commands/genesis/storage.go

@@ -22,7 +22,9 @@ package genesis
 
 import (
 	"bytes"
+	"encoding/hex"
 	"encoding/json"
+	"fmt"
 	"math/big"
 	"path/filepath"
 
@@ -32,12 +34,13 @@ import (
 	ctypes "github.com/berachain/beacon-kit/consensus-types/types"
 	"github.com/berachain/beacon-kit/errors"
 	gethprimitives "github.com/berachain/beacon-kit/geth-primitives"
-	libcommon "github.com/berachain/beacon-kit/primitives/common"
+	"github.com/berachain/beacon-kit/primitives/crypto"
 	cmtcfg "github.com/cometbft/cometbft/config"
 	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	"golang.org/x/crypto/sha3"
 )
 
 // SetDepositStorageCmd sets deposit contract storage in genesis alloc file.
@@ -99,10 +102,6 @@ func SetDepositStorage(
 	}
 	deposits := beaconState.Deposits
 
-	// Set the storage of the deposit contract with deposits count and root.
-	count := big.NewInt(int64(len(deposits)))
-	root := deposits.HashTreeRoot()
-
 	// Unmarshal the genesis file.
 	elGenesis := &types.DefaultEthGenesisJSON{}
 	allocsKey := types.DefaultAllocsKey
@@ -111,7 +110,7 @@ func SetDepositStorage(
 	}
 
 	depositAddr := common.Address(chainSpec.DepositContractAddress())
-	allocs := writeDepositStorage(elGenesis, depositAddr, count, root)
+	allocs := writeDepositStorage(elGenesis, deposits, depositAddr)
 
 	// Get just the filename from the path
 	filename := filepath.Base(elGenesisFilePath)
@@ -127,13 +126,15 @@ func SetDepositStorage(
 
 func writeDepositStorage(
 	elGenesis types.EthGenesis,
+	deposits ctypes.Deposits,
 	depositAddr common.Address,
-	depositsCount *big.Int,
-	depositsRoot libcommon.Root,
 ) gethprimitives.GenesisAlloc {
 	slot0 := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000")
 	slot1 := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001")
 
+	depositsCount := big.NewInt(int64(len(deposits)))
+	depositsRoot := deposits.HashTreeRoot()
+
 	allocs := elGenesis.Alloc()
 	if entry, ok := allocs[depositAddr]; ok {
 		if entry.Storage == nil {
@@ -142,10 +143,55 @@ func writeDepositStorage(
 		entry.Storage[slot0] = common.BigToHash(depositsCount)
 		entry.Storage[slot1] = common.BytesToHash(depositsRoot[:])
 		allocs[depositAddr] = entry
+
+		// Store operators keys for each validator, reusing their BLS key
+		// TODO: this is good enough for testing over devnets, but we may
+		// want to extend the command to be able to explicitly pass a list
+		// of pre-arranged operator keys.
+		for i, d := range deposits {
+			storageKey := encodeSlot(d.Pubkey)
+			operatorAddr, err := crypto.GetAddressFromPubKey(d.Pubkey) // reuse val BLS key for simplicity
+			if err != nil {
+				panic(fmt.Errorf("failed getting address from validator %d pub key: %w", i, err))
+			}
+
+			k := common.BytesToHash(storageKey)
+			v := common.BytesToHash(operatorAddr)
+			entry.Storage[k] = v
+		}
 	}
 	return allocs
 }
 
+// encodeSlot mimics Solidity's keccak256(abi.encodePacked(...)) for:
+// - pubKey: 48-byte public key
+// - baseSlot: 32-byte storage slot
+//
+//nolint:mnd // TO BE FIXED
+func encodeSlot(pubkey crypto.BLSPubkey) []byte {
+	// Decode pubkey
+	pubKeyStr := pubkey.String()
+	packed, err := hex.DecodeString(pubKeyStr[2:])
+	if err != nil {
+		panic(err)
+	}
+	if len(packed) != 48 {
+		panic(fmt.Errorf("expected 48-byte pubkey, got %d", len(packed)))
+	}
+
+	// Convert mapping slot (uint256) to 32-byte left-padded value
+	const mappintStorageBaseSlot = 2
+	slotBytes := new(big.Int).SetUint64(mappintStorageBaseSlot).FillBytes(make([]byte, 32))
+
+	// abi.encodePacked => direct byte concatenation
+	packed = append(packed, slotBytes...)
+
+	// keccak256 hash
+	hash := sha3.NewLegacyKeccak256()
+	hash.Write(packed)
+	return hash.Sum(nil)
+}
+
 func writeGenesisAllocToFile(
 	depositAddr common.Address,
 	outputDocument string,

cli/commands/genesis/storage_test.go

@@ -29,7 +29,11 @@ import (
 	"github.com/berachain/beacon-kit/chain"
 	"github.com/berachain/beacon-kit/cli/commands/genesis"
 	servertypes "github.com/berachain/beacon-kit/cli/commands/server/types"
+	genesisutils "github.com/berachain/beacon-kit/cli/utils/genesis"
 	"github.com/berachain/beacon-kit/config/spec"
+	"github.com/berachain/beacon-kit/consensus-types/types"
+	"github.com/berachain/beacon-kit/primitives/bytes"
+	"github.com/berachain/beacon-kit/primitives/crypto"
 	"github.com/berachain/beacon-kit/primitives/encoding/json"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/ethereum/go-ethereum/common"
@@ -117,18 +121,24 @@ func setupMockCLGenesis(t *testing.T, tmpDir string) string {
 	require.NoError(t, os.MkdirAll(configDir, 0o755))
 	mockCLGenesisPath := filepath.Join(configDir, "genesis.json")
 
-	mockCLGenesis := map[string]interface{}{
-		"app_state": map[string]interface{}{
-			"beacon": map[string]interface{}{
-				"deposits": []interface{}{
-					map[string]interface{}{
-						"data": map[string]interface{}{
-							"amount":               "32000000000",
-							"pubkey":               "0x1234",
-							"withdrawal_address":   "0x5678",
-							"signature":            "0x9abc",
-							"deposit_message_root": "0xdef0",
-						},
+	pkBytes := []byte{
+		138, 238, 24, 44, 160, 141, 152, 10, 53, 122, 247, 15,
+		129, 25, 168, 67, 55, 148, 56, 108, 55, 192, 218, 25,
+		237, 85, 204, 12, 10, 149, 243, 239, 80, 219, 58, 74,
+		158, 219, 231, 105, 42, 97, 95, 186, 120, 53, 228, 51,
+	}
+	pk, err := bytes.ToBytes48(pkBytes)
+	require.NoError(t, err)
+
+	mockCLGenesis := genesisutils.Genesis{
+		AppState: genesisutils.AppState{
+			Beacon: genesisutils.Beacon{
+				Deposits: types.Deposits{
+					{
+						Pubkey:      pk,
+						Credentials: types.WithdrawalCredentials{},
+						Amount:      32000000000,
+						Signature:   crypto.BLSSignature{},
 					},
 				},
 			},

config/spec/devnet.go

@@ -27,9 +27,6 @@ import (
 )
 
 const (
-	// devnetEVMInflationAddress is the address of the EVM inflation contract.
-	devnetEVMInflationAddress = "0x6942069420694206942069420694206942069420"
-
 	// devnetEVMInflationPerBlock is the amount of native EVM balance (in units
 	// of Gwei) to be minted per EL block.
 	devnetEVMInflationPerBlock = 10 * params.GWei
@@ -51,10 +48,6 @@ const (
 	// devnet is configured to start on electra1.
 	devnetElectra1ForkTime = 0
 
-	// devnetEVMInflationAddressDeneb1 is the address of the EVM inflation contract
-	// after the Deneb1 fork.
-	devnetEVMInflationAddressDeneb1 = "0x4206942069420694206942069420694206942069"
-
 	// devnetEVMInflationPerBlockDeneb1 is the amount of native EVM balance (in units
 	// of Gwei) to be minted per EL block after the Deneb1 fork.
 	devnetEVMInflationPerBlockDeneb1 = 11 * params.GWei
@@ -81,11 +74,11 @@ func DevnetChainSpecData() *chain.SpecData {
 	specData.Electra1ForkTime = devnetElectra1ForkTime
 
 	// EVM inflation is different from mainnet to test.
-	specData.EVMInflationAddressGenesis = common.NewExecutionAddressFromHex(devnetEVMInflationAddress)
+	specData.EVMInflationAddressGenesis = common.NewExecutionAddressFromHex(defaultEVMInflationAddress)
 	specData.EVMInflationPerBlockGenesis = devnetEVMInflationPerBlock
 
 	// EVM inflation is different from mainnet for now, after the Deneb1 fork.
-	specData.EVMInflationAddressDeneb1 = common.NewExecutionAddressFromHex(devnetEVMInflationAddressDeneb1)
+	specData.EVMInflationAddressDeneb1 = common.NewExecutionAddressFromHex(mainnetEVMInflationAddressDeneb1)
 	specData.EVMInflationPerBlockDeneb1 = devnetEVMInflationPerBlockDeneb1
 
 	// Staking is different from mainnet for now.

kurtosis/main.star

@@ -62,19 +62,14 @@ def run(plan, network_configuration = {}, node_settings = {}, eth_json_rpc_endpo
     # 3. Perform genesis ceremony for the CL genesis deposits.
     stored_configs = beacond.perform_genesis_deposits_ceremony(plan, validators, jwt_file, chain_id, chain_spec)
 
-    # 4 a. Create genesis files only once and pass it to the node configs
+    # 4a. Create initial genesis files for running beacond commands
     genesis_files = nodes.create_genesis_files_part1(plan, chain_id)
 
-    # 4b. Modify the eth genesis file with the premined deposits && finalize CL genesis file.
-    # Get the deposit storage values stored in env variables
-    env_vars = beacond.modify_genesis_files_deposits(plan, validators, genesis_files, chain_id, chain_spec, stored_configs)
+    # 4b. Run beacond genesis commands to populate POL operator keys and create final genesis
+    genesis_with_storage_artifact = beacond.modify_genesis_files_deposits(plan, validators, genesis_files, chain_id, chain_spec, stored_configs)
 
-    # Extract values from env_vars
-    genesis_deposits_root = env_vars.get("GENESIS_DEPOSITS_ROOT")
-    genesis_deposit_count_hex = env_vars.get("GENESIS_DEPOSIT_COUNT_HEX")
-
-    # 4c. Modify the eth genesis files with the ENV VARS
-    genesis_files = nodes.create_genesis_files_part2(plan, chain_id, genesis_deposits_root, genesis_deposit_count_hex)
+    # 4c. Use the complete genesis file with POL operator keys
+    genesis_files = {"default": genesis_with_storage_artifact}
 
     el_enode_addrs = []
     metrics_enabled_services = metrics_enabled_services[:]
@@ -101,7 +96,7 @@ def run(plan, network_configuration = {}, node_settings = {}, eth_json_rpc_endpo
         metrics_enabled_services = execution.add_metrics(metrics_enabled_services, seed, seed.el_service_name, seed_node_el_clients[seed.el_service_name], node_modules)
     seed_node_configs = {}
     for n, seed in enumerate(seed_nodes):
-        seed_node_config = beacond.create_node_config(plan, seed, consensus_node_peering_info, seed.el_service_name, chain_id, chain_spec, genesis_deposits_root, genesis_deposit_count_hex, jwt_file, kzg_trusted_setup)
+        seed_node_config = beacond.create_node_config(plan, seed, consensus_node_peering_info, seed.el_service_name, chain_id, chain_spec, jwt_file, kzg_trusted_setup)
         seed_node_configs[seed.cl_service_name] = seed_node_config
     seed_nodes_clients = plan.add_services(
         configs = seed_node_configs,
@@ -132,7 +127,7 @@ def run(plan, network_configuration = {}, node_settings = {}, eth_json_rpc_endpo
 
     for n, full in enumerate(full_nodes):
         # 5b. Launch CL
-        full_node_config = beacond.create_node_config(plan, full, consensus_node_peering_info, full.el_service_name, chain_id, chain_spec, genesis_deposits_root, genesis_deposit_count_hex, jwt_file, kzg_trusted_setup)
+        full_node_config = beacond.create_node_config(plan, full, consensus_node_peering_info, full.el_service_name, chain_id, chain_spec, jwt_file, kzg_trusted_setup)
         full_node_configs[full.cl_service_name] = full_node_config
 
     if full_node_configs != {}:
@@ -162,7 +157,7 @@ def run(plan, network_configuration = {}, node_settings = {}, eth_json_rpc_endpo
 
     validator_node_configs = {}
     for n, validator in enumerate(validators):
-        validator_node_config = beacond.create_node_config(plan, validator, consensus_node_peering_info, validator.el_service_name, chain_id, chain_spec, genesis_deposits_root, genesis_deposit_count_hex, jwt_file, kzg_trusted_setup)
+        validator_node_config = beacond.create_node_config(plan, validator, consensus_node_peering_info, validator.el_service_name, chain_id, chain_spec, jwt_file, kzg_trusted_setup)
         validator_node_configs[validator.cl_service_name] = validator_node_config
 
     cl_clients = plan.add_services(