From cef8c83e3406b03d68bbc9a4bf561b2f635a52ab Mon Sep 17 00:00:00 2001 From: protolambda Date: Fri, 23 Aug 2024 13:33:17 -0600 Subject: [PATCH] op-chain-ops: prefund chain operator accounts --- op-chain-ops/genz/configs.go | 2 ++ op-chain-ops/genz/deploy.go | 12 ++++++++ op-chain-ops/genz/recipe.go | 59 ++++++++++++++++++++++++++++++++++-- 3 files changed, 71 insertions(+), 2 deletions(-) diff --git a/op-chain-ops/genz/configs.go b/op-chain-ops/genz/configs.go index db78837d5607f..30da2226d9f88 100644 --- a/op-chain-ops/genz/configs.go +++ b/op-chain-ops/genz/configs.go @@ -14,6 +14,7 @@ import ( type L1Config struct { ChainID *big.Int genesis.DevL1DeployConfig + Prefund map[common.Address]*big.Int } func (c *L1Config) Check(log log.Logger) error { @@ -50,6 +51,7 @@ type L2Config struct { Deployer common.Address // account used to deploy contracts to L2 genesis.L2InitializationConfig genesis.FaultProofDeployConfig + Prefund map[common.Address]*big.Int } func (c *L2Config) Check(log log.Logger) error { diff --git a/op-chain-ops/genz/deploy.go b/op-chain-ops/genz/deploy.go index 74a55284bf0d2..5d24253d01f6d 100644 --- a/op-chain-ops/genz/deploy.go +++ b/op-chain-ops/genz/deploy.go @@ -392,6 +392,12 @@ func completeL1(l1Host *script.Host, cfg *L1Config) (*L1Output, error) { return nil, fmt.Errorf("unexpected deployed account content by L1 genesis deployer: %w", err) } + for addr, amount := range cfg.Prefund { + acc := allocs.Accounts[addr] + acc.Balance = amount + allocs.Accounts[addr] = acc + } + l1Genesis.Alloc = allocs.Accounts // Insert an empty beaconchain deposit contract with valid empty-tree prestate. @@ -433,6 +439,12 @@ func completeL2(l2Host *script.Host, cfg *L2Config, l1Block *types.Block, deploy return nil, fmt.Errorf("unexpected deployed account content by L2 genesis deployer: %w", err) } + for addr, amount := range cfg.Prefund { + acc := allocs.Accounts[addr] + acc.Balance = amount + allocs.Accounts[addr] = acc + } + l2Genesis.Alloc = allocs.Accounts l2GenesisBlock := l2Genesis.ToBlock() diff --git a/op-chain-ops/genz/recipe.go b/op-chain-ops/genz/recipe.go index a8fc8914ccae9..e584ffb95237b 100644 --- a/op-chain-ops/genz/recipe.go +++ b/op-chain-ops/genz/recipe.go @@ -27,7 +27,18 @@ func (r *InteropDevRecipe) Build(addrs devkeys.Addresses) (*WorldConfig, error) L1GenesisBlockTimestamp: hexutil.Uint64(r.GenesisTimestamp), L1GenesisBlockGasLimit: 30_000_000, }, + Prefund: make(map[common.Address]*big.Int), } + + l1Users := devkeys.ChainUserKeys(l1Cfg.ChainID) + for i := uint64(0); i < 20; i++ { + userAddr, err := addrs.Address(l1Users(i)) + if err != nil { + return nil, fmt.Errorf("failed to get L1 user addr %d: %w", i, err) + } + l1Cfg.Prefund[userAddr] = Ether(10_000_000) + } + superchainOps := devkeys.SuperchainOperatorKeys(l1Cfg.ChainID) superchainDeployer, err := addrs.Address(superchainOps(devkeys.SuperchainDeployerKey)) @@ -46,6 +57,10 @@ func (r *InteropDevRecipe) Build(addrs devkeys.Addresses) (*WorldConfig, error) if err != nil { return nil, err } + l1Cfg.Prefund[superchainDeployer] = Ether(10_000_000) + l1Cfg.Prefund[finalSystemOwner] = Ether(10_000_000) + l1Cfg.Prefund[superchainProxyAdmin] = Ether(10_000_000) + l1Cfg.Prefund[superchainConfigGuardian] = Ether(10_000_000) superchainCfg := &SuperchainConfig{ FinalSystemOwner: finalSystemOwner, ProxyAdminOwner: superchainProxyAdmin, @@ -66,11 +81,37 @@ func (r *InteropDevRecipe) Build(addrs devkeys.Addresses) (*WorldConfig, error) if err != nil { return nil, fmt.Errorf("failed to generate L2 config for chain %d: %w", l2ChainID, err) } + if err := prefundL2Accounts(l1Cfg, l2Cfg, addrs); err != nil { + return nil, fmt.Errorf("failed to prefund addresses on L1 for L2 chain %d: %w", l2ChainID, err) + } world.L2s[fmt.Sprintf("%d", l2ChainID)] = l2Cfg } return world, nil } +func prefundL2Accounts(l1Cfg *L1Config, l2Cfg *L2Config, addrs devkeys.Addresses) error { + l1Cfg.Prefund[l2Cfg.BatchSenderAddress] = Ether(10_000_000) + l1Cfg.Prefund[l2Cfg.Deployer] = Ether(10_000_000) + l1Cfg.Prefund[l2Cfg.FinalSystemOwner] = Ether(10_000_000) + proposer, err := addrs.Address(devkeys.ChainOperatorKey{ + ChainID: new(big.Int).SetUint64(l2Cfg.L2ChainID), + Role: devkeys.ProposerRole, + }) + if err != nil { + return err + } + l1Cfg.Prefund[proposer] = Ether(10_000_000) + challenger, err := addrs.Address(devkeys.ChainOperatorKey{ + ChainID: new(big.Int).SetUint64(l2Cfg.L2ChainID), + Role: devkeys.ChallengerRole, + }) + if err != nil { + return err + } + l1Cfg.Prefund[challenger] = Ether(10_000_000) + return nil +} + func InteropL2DevConfig(l1ChainID, l2ChainID uint64, addrs devkeys.Addresses) (*L2Config, error) { // Padded chain ID, hex encoded, prefixed with 0xff like inboxes, then 0x02 to signify devnet. batchInboxAddress := common.HexToAddress(fmt.Sprintf("0xff02%016x", l2ChainID)) @@ -109,7 +150,7 @@ func InteropL2DevConfig(l1ChainID, l2ChainID uint64, addrs devkeys.Addresses) (* return nil, err } - return &L2Config{ + l2Cfg := &L2Config{ Deployer: deployer, L2InitializationConfig: genesis.L2InitializationConfig{ DevDeployConfig: genesis.DevDeployConfig{ @@ -195,7 +236,21 @@ func InteropL2DevConfig(l1ChainID, l2ChainID uint64, addrs devkeys.Addresses) (* DisputeGameFinalityDelaySeconds: 6, RespectedGameType: 254, // "fast" game type }, - }, nil + Prefund: make(map[common.Address]*big.Int), + } + + l2Users := devkeys.ChainUserKeys(new(big.Int).SetUint64(l2ChainID)) + for i := uint64(0); i < 20; i++ { + userAddr, err := addrs.Address(l2Users(i)) + if err != nil { + return nil, fmt.Errorf("failed to get L2 user addr %d: %w", i, err) + } + l2Cfg.Prefund[userAddr] = Ether(10_000_000) + } + + l2Cfg.Prefund[l2ProxyAdminOwner] = Ether(10_000_000) + + return l2Cfg, nil } var etherScalar = new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)