diff --git a/packages/contracts-bedrock/deploy-config/baklava.json b/packages/contracts-bedrock/deploy-config/baklava.json new file mode 100644 index 0000000000000..deb83e422fcc1 --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/baklava.json @@ -0,0 +1,76 @@ +{ + "l1StartingBlockTag": null, + "l1ChainID": 17000, + "l2ChainID": 62320, + "l2GenesisBlockGasLimit": "0x1c9c380", + "l2GenesisBlockBaseFeePerGas": "0x3b9aca00", + "l2OutputOracleSubmissionInterval": 600, + "l2OutputOracleStartingTimestamp": 1739987136, + "l2OutputOracleStartingBlockNumber": 28308600, + "l2OutputOracleProposer": "0x85c7AC265419359806B147Fba6Ea654229928333", + "l2OutputOracleChallenger": "0xDc94436A193a827786270dD4F6cD4b35c3f0C8f8", + "useFaultProofs": true, + "faultGameAbsolutePrestate": "0x0364010a7b2be12b8583c8bc2c610ef5b77bb52161cac1dd4f8cbe47edc05afd", + "faultGameMaxDepth": 73, + "faultGameClockExtension": 10800, + "faultGameMaxClockDuration": 302400, + "faultGameGenesisBlock": 42, + "faultGameGenesisOutputRoot": "0x2fafa02f4d94e20796afac0bae793bcc5c3cbb1244bc5a8c730153def18b0f3f", + "faultGameSplitDepth": 30, + "faultGameWithdrawalDelay": 604800, + "preimageOracleMinProposalSize": 126000, + "preimageOracleChallengePeriod": 86400, + "proofMaturityDelaySeconds": 604800, + "disputeGameFinalityDelaySeconds": 302400, + "respectedGameType": 1, + "requiredProtocolVersion": "0x0000000000000000000000000000000000000003000000010000000000000000", + "recommendedProtocolVersion": "0x0000000000000000000000000000000000000003000000010000000000000000", + "superchainConfigGuardian": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "l1BlockTime": 12, + "l2BlockTime": 1, + "finalizationPeriodSeconds": 12, + "maxSequencerDrift": 600, + "sequencerWindowSize": 7200, + "channelTimeout": 300, + "batchInboxAddress": "0xff00000000000000000000000000000000062320", + "systemConfigStartBlock": 0, + "p2pSequencerAddress": "0x3Cd8072cbC235246c684ab9BD76Bb6f3813Df2CD", + "batchSenderAddress": "0x242C6e6eA8e910A1835eFA4CaF8641769C27B595", + "proxyAdminOwner": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "finalSystemOwner": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "baseFeeVaultRecipient": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "baseFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "baseFeeVaultWithdrawalNetwork": 0, + "l1FeeVaultRecipient": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "l1FeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "l1FeeVaultWithdrawalNetwork": 0, + "sequencerFeeVaultRecipient": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "sequencerFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "sequencerFeeVaultWithdrawalNetwork": 0, + "eip1559Denominator": 400, + "eip1559Elasticity": 5, + "eip1559DenominatorCanyon": 400, + "eip1559BaseFeeFloor": 25000000000, + "gasPriceOracleBaseFeeScalar": 0, + "gasPriceOracleBlobBaseFeeScalar": 0, + "gasPriceOracleOverhead": 0, + "gasPriceOracleScalar": 0, + "enableGovernance": false, + "governanceTokenName": "Optimism", + "governanceTokenSymbol": "OP", + "governanceTokenOwner": "0x0000000000000000000000000000000000000000", + "fundDevAccounts": false, + "deployCeloContracts": false, + "useCustomGasToken": true, + "customGasTokenAddress": "0x0000000000000000000000000000000000000000", + "useAltDA": true, + "daCommitmentType": "GenericCommitment", + "daChallengeWindow": 1, + "daResolveWindow": 1, + "l2GenesisRegolithTimeOffset": "0x0", + "l2GenesisCanyonTimeOffset": "0x0", + "l2GenesisDeltaTimeOffset": "0x0", + "l2GenesisEcotoneTimeOffset": "0x0", + "l2GenesisFjordTimeOffset": "0x0", + "l2GenesisGraniteTimeOffset": "0x0" +} diff --git a/packages/contracts-bedrock/deploy-config/cue/baklava.cue b/packages/contracts-bedrock/deploy-config/cue/baklava.cue new file mode 100644 index 0000000000000..17534d626aac9 --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/cue/baklava.cue @@ -0,0 +1,47 @@ +package deployconfig + +network: test: baklava: #Common & { + _params: { + l1CeloSafeAddress: "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094" + feeRecipientAddress: l1CeloSafeAddress + sequencerWindowSizeHours: 24 + withdrawFeesOnL2: false + } + + l1StartingBlockTag: null + l1ChainID: 17000 + l2ChainID: 62320 + maxSequencerDrift: 10 * MinuteInSeconds + // this was used incorrectly, or at least it doesn't have + // any effect since we also activate the granite hardfork + // which has a hardcoded value of 50 + channelTimeout: 300 + + p2pSequencerAddress: "0x3Cd8072cbC235246c684ab9BD76Bb6f3813Df2CD" + batchInboxAddress: "0xff00000000000000000000000000000000062320" + batchSenderAddress: "0x242C6e6eA8e910A1835eFA4CaF8641769C27B595" + proxyAdminOwner: _params.l1CeloSafeAddress + superchainConfigGuardian: _params.l1CeloSafeAddress + + l2OutputOracleSubmissionInterval: 600 + l2OutputOracleStartingBlockNumber: 28308600 + l2OutputOracleStartingTimestamp: 1739987136 + l2OutputOracleProposer: "0x85c7AC265419359806B147Fba6Ea654229928333" + l2OutputOracleChallenger: "0xDc94436A193a827786270dD4F6cD4b35c3f0C8f8" + + finalizationPeriodSeconds: 12 + + l2GenesisBlockGasLimit: "0x1c9c380" + l2GenesisBlockBaseFeePerGas: "0x3b9aca00" + + useFaultProofs: true + faultGameAbsolutePrestate: "0x0364010a7b2be12b8583c8bc2c610ef5b77bb52161cac1dd4f8cbe47edc05afd" + faultGameGenesisOutputRoot: "0x2fafa02f4d94e20796afac0bae793bcc5c3cbb1244bc5a8c730153def18b0f3f" + + preimageOracleMinProposalSize: 126000 + preimageOracleChallengePeriod: 86400 + + faultGameGenesisBlock: 42 + + useAltDA: true +} diff --git a/packages/contracts-bedrock/deploy-config/cue/common.cue b/packages/contracts-bedrock/deploy-config/cue/common.cue new file mode 100644 index 0000000000000..ed623201bc3b5 --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/cue/common.cue @@ -0,0 +1,116 @@ +package deployconfig + +#Parameters: { + _params: { + l1CeloSafeAddress: #Address + feeRecipientAddress: #Address + sequencerWindowSizeHours: uint64 + withdrawFeesOnL2!: bool + isLocalDevnet!: bool + } + ... +} + +#Common: #DeployConfig & #Parameters & { + _params: { + // we set this to double the OP-suggested value (of 12h), + // because we had issues with EigenDA before and + // this was the only thing preventing a long reorg. + // Now we have the fallback mechanism, so this is not as + // relevant any longer. We still agreed that we want to be + // on the safe side here. + sequencerWindowSizeHours: uint64 | *24 + isLocalDevnet: bool | *false + withdrawFeesOnL2: bool | true + } + + deployCeloContracts: false + fundDevAccounts: false + if _params.isLocalDevnet == true { + deployCeloContracts: true + fundDevAccounts: true + } + + l2BlockTime: 1 + l1BlockTime: 12 + // has not effect anyway if not pre-Granite, + // but set it to a default of 50, which is the Granite hardcoded value + channelTimeout: uint64 | *50 + sequencerWindowSize: div((_params.sequencerWindowSizeHours * HourInSeconds), l1BlockTime) + systemConfigStartBlock: 0 + + finalSystemOwner: _params.l1CeloSafeAddress + + // superchain-related + requiredProtocolVersion: "0x0000000000000000000000000000000000000003000000010000000000000000" + recommendedProtocolVersion: "0x0000000000000000000000000000000000000003000000010000000000000000" + + // those values were chosen to match the gasprice parameters of ethereum, + // while taking into account our shorter blocktime + eip1559Denominator: 400 + eip1559Elasticity: 5 + eip1559DenominatorCanyon: eip1559Denominator + eip1559Denominator: 400 + eip1559Elasticity: 5 + eip1559BaseFeeFloor: 25 * gWei + + gasPriceOracleOverhead: 0 + gasPriceOracleScalar: 0 + gasPriceOracleBaseFeeScalar: 0 + gasPriceOracleBlobBaseFeeScalar: 0 + + l2GenesisFjordTimeOffset: #Hex64 | *"0x0" + l2GenesisRegolithTimeOffset: #Hex64 | *"0x0" + l2GenesisEcotoneTimeOffset: #Hex64 | *"0x0" + l2GenesisDeltaTimeOffset: #Hex64 | *"0x0" + l2GenesisCanyonTimeOffset: #Hex64 | *"0x0" + l2GenesisGraniteTimeOffset: #Hex64 | *"0x0" + + // those two will be deployed but don't receive funds + baseFeeVaultRecipient: _params.feeRecipientAddress + l1FeeVaultRecipient: _params.feeRecipientAddress + // for now this will be deployed and receive the tips + // in Celo but also fee-currency. + // The Celo is withdrawable to this address by everyone, + // the fee-currencies are owned by this address but the + // contract implementation is not compatible with ERC20 for now. + sequencerFeeVaultRecipient: _params.feeRecipientAddress + baseFeeVaultMinimumWithdrawalAmount: "0x8ac7230489e80000" // 10000000000000000000 + l1FeeVaultMinimumWithdrawalAmount: "0x8ac7230489e80000" // 10000000000000000000 + sequencerFeeVaultMinimumWithdrawalAmount: "0x8ac7230489e80000" // 10000000000000000000 + + if _params.withdrawFeesOnL2 == false { + sequencerFeeVaultWithdrawalNetwork: 0 + baseFeeVaultWithdrawalNetwork: 0 + l1FeeVaultWithdrawalNetwork: 0 + } + if _params.withdrawFeesOnL2 == true { + sequencerFeeVaultWithdrawalNetwork: 1 + baseFeeVaultWithdrawalNetwork: 1 + l1FeeVaultWithdrawalNetwork: 1 + } + + enableGovernance: false + governanceTokenOwner: ZeroAddress + + // AltDA + daCommitmentType: "GenericCommitment" + daChallengeWindow: 1 + daResolveWindow: 1 + + // FaultProofs + faultGameMaxDepth: uint64 | *73 + faultGameClockExtension: uint64 | *(3 * HourInSeconds) + faultGameSplitDepth: uint64 | *30 + // we are following op and base here + faultGameWithdrawalDelay: uint64 | *(7 * DayInSeconds) + + proofMaturityDelaySeconds: uint64 | *(7 * DayInSeconds) + disputeGameFinalityDelaySeconds: uint64 | *(div(7*DayInSeconds, 2)) + faultGameMaxClockDuration: uint64 | *(div(7*DayInSeconds, 2)) + // different than OP's "0" type + respectedGameType: 1 + + useCustomGasToken: true + customGasTokenAddress: ZeroAddress +} diff --git a/packages/contracts-bedrock/deploy-config/cue/mainnet.cue b/packages/contracts-bedrock/deploy-config/cue/mainnet.cue new file mode 100644 index 0000000000000..18d64e149aeb5 --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/cue/mainnet.cue @@ -0,0 +1,105 @@ +package deployconfig + +// this is the mainnet template for all values +// we know before any L1 deployment, privkey or safe generation +#MainnetTemplate: #Common & { + _params: sequencerWindowSizeHours: 24 + + // required for mainnet + proxyAdminOwnerIsMultisig!: bool + externalSuperchainConfig!: #Address + finalSystemOwner!: #Address + + if proxyAdminOwnerIsMultisig == true { + proxyAdminOwner: !=finalSystemOwner + } + + externalSuperchainConfig: "0x95703e0982140D16f8ebA6d158FccEde42f04a4C" + protocolVersionsProxy: "0x1b6dEB2197418075AB314ac4D52Ca1D104a8F663" + // set this to null, + // and also we don't need to overwrite this later anymore + // since we derive the starting-block based on the + // beacon-api deterministically now. + l1StartingBlockTag: null + l1ChainID: 1 + l2ChainID: 42220 + // this parameter is only relevant when l1 origin is + // less than l2 start time, just after migration. + // afterwards this is hardcoded to the value 2892. + maxSequencerDrift: 2892 + batchInboxAddress: "0xff00000000000000000000000000000000042220" + + l2GenesisBlockGasLimit: "0x1c9c380" // 30 000 000 + l2GenesisBlockBaseFeePerGas: "0x5d21dba00" // 25 000 000 000 + + // L2OO related, those values are used in + // the (later stage) initialization of the L2OO + finalizationPeriodSeconds: (7 * DayInSeconds) + l2OutputOracleSubmissionInterval: (30 * MinuteInSeconds) + + // this has to be overwritten later after l2 genesis, + // but before the fault-game initialization + faultGameGenesisBlock: uint64 | *31056500 + + preimageOracleMinProposalSize: uint64 | *126000 + preimageOracleChallengePeriod: uint64 | *(24 * HourInSeconds) + + useAltDA: true + useFaultProofs: true +} + +network: production: mainnet: #MainnetTemplate & { + _params: l1CeloSafeAddress: "0x4092A77bAF58fef0309452cEaCb09221e556E112" + // multisig on future l2, so we can't withdraw fees to L1: + _params: feeRecipientAddress: "0x7A1E98FC9a008107DbD1f430a05Ace8cf6f3FE19" + _params: withdrawFeesOnL2: true + + //has to be the aliased version of the finalSystemOwner! + proxyAdminOwnerIsMultisig: true + proxyAdminOwner: "0x51a3a77baf58fef0309452ceacb09221e556f223" + + p2pSequencerAddress: "0xA6F1c6c24De8b112dd3867dB907d187d490e6ddF" + batchSenderAddress: "0x0cd08c7f7a96aa9635f761b49216b9ea74c5ca60" + // those are important, since they are also used for the faultproofs + l2OutputOracleProposer: "0x1204884e697efd929729b9a717ea14496298a689" + l2OutputOracleChallenger: "0x6b145ebf66602ec524b196426b46631259689583" + superchainConfigGuardian: "0x6E226fa22e5F19363d231D3FA048aaBa73CC1f47" + + // When are we able to set the correct values? + faultGameGenesisOutputRoot: "0x3c736a83458982ae1f6b62284e9af2687333e17625c7147b9af4758fa84952e8" + faultGameAbsolutePrestate: "0x0364010a7b2be12b8583c8bc2c610ef5b77bb52161cac1dd4f8cbe47edc05afd" + faultGameGenesisBlock: 31056500 + l2OutputOracleStartingBlockNumber: 0 + l2OutputOracleStartingTimestamp: 0 +} + +network: dryrun: mainnet: #MainnetTemplate & { + // not a safe, but we can use the parameter with an EOA + _params: l1CeloSafeAddress: "0x3d98acBC85D3252DFfd6b500D94341F4774256F0" + _params: feeRecipientAddress: "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094" + _params: withdrawFeesOnL2: true + + // instead of the aliased address, use an EOA + proxyAdminOwner: "0x4ea9acbc85d3252dffd6b500d94341f477426801" + proxyAdminOwnerIsMultisig: true + + l2OutputOracleStartingBlockNumber: 30941000 + l2OutputOracleStartingTimestamp: 1742366039 + + p2pSequencerAddress: "0xc0fD4a912b7aC8D5a3ABDbef23c88c67Cfb528Cb" + batchSenderAddress: "0x4e8b8dd9611845f5fb80f43662dbeefbb47a75f6" + l2OutputOracleProposer: "0xc01061d4cc5b98965d2aa4b1dfcc1d77bb0d29f3" + l2OutputOracleChallenger: "0x9e21944b9dd761e7a89ecb17be005e955e750f2b" + superchainConfigGuardian: "0x1174B5f5Dd8fA3be9549b131E9810703D15f153d" + + faultGameGenesisBlock: 30941000 + disputeGameFinalityDelaySeconds: (1 * HourInSeconds) + faultGameWithdrawalDelay: (2 * disputeGameFinalityDelaySeconds) + proofMaturityDelaySeconds: (2 * disputeGameFinalityDelaySeconds) + faultGameClockExtension: (30 * MinuteInSeconds) + faultGameMaxClockDuration: disputeGameFinalityDelaySeconds + preimageOracleChallengePeriod: (10 * MinuteInSeconds) + + faultGameAbsolutePrestate: "0x0364010a7b2be12b8583c8bc2c610ef5b77bb52161cac1dd4f8cbe47edc05afd" + faultGameGenesisOutputRoot: "0x3c736a83458982ae1f6b62284e9af2687333e17625c7147b9af4758fa84952e8" +} diff --git a/packages/contracts-bedrock/deploy-config/cue/schema.cue b/packages/contracts-bedrock/deploy-config/cue/schema.cue new file mode 100644 index 0000000000000..26046f06b7088 --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/cue/schema.cue @@ -0,0 +1,363 @@ +package deployconfig + +// Type constraints +#Address: string & =~"^0x[a-fA-F0-9]{40}$" +#Hex64: string & =~"^0x[a-fA-F0-9]{64}$" +#Hex: string & =~"^0x[a-fA-F0-9]*$" +#CommitmentType: "GenericCommitment" | "KeccakCommitment" + +// Global vars +ZeroAddress: "0x0000000000000000000000000000000000000000" +MinuteInSeconds: 60 +HourInSeconds: 60 * MinuteInSeconds +DayInSeconds: 24 * HourInSeconds +gWei: 1000000000 + +#Superchain: { + // indicates the protocol version that + // nodes are required to adopt, to stay in sync with the network. + requiredProtocolVersion: #Hex + // indicates the protocol version that + // nodes are recommended to adopt, to stay in sync with the network. + recommendedProtocolVersion: #Hex + // GUARDIAN account in the SuperchainConfig. + // has the ability to pause withdrawals. + superchainConfigGuardian: #Address + + protocolVersionsProxy?: #Address + ... +} + +#Core: { + // anchors the L2 at an L1 block. + // The timestamp of the block referenced by l1StartingBlockTag is used + // in the L2 genesis block, rollup-config, and L1 output-oracle contract. + // The Output oracle deploy script may use it if the L2 starting timestamp is nil, assuming the L2 genesis is set up with this. + // The L2 genesis timestamp does not affect the initial L2 account state: + // the storage of the L1Block contract at genesis is zeroed, since the adoption of + // the L2-genesis allocs-generation through solidity script. + l1StartingBlockTag: #Hex64 | null + // chain ID of the L1 chain. + l1ChainID: uint64 + // chain ID of the L2 chain. + l2ChainID: uint64 & !=l1ChainID + // this is only used for a deploy-config sanity check and internally for generating + // some config parameters with CUE so that we can set them in a more human-readable form. + l1BlockTime: uint64 & >l2BlockTime + // number of seconds between each L2 block. + l2BlockTime: uint64 & >=1 + // number of seconds before an output is considered + // finalized. This impacts the amount of time that withdrawals take to finalize and is + // generally set to 1 week. + // This is only relevant for the OutputOracle 0 + // number of L1 blocks per sequencing window. + sequencerWindowSize: uint64 + // number of L1 blocks that a frame stays valid when included in L1. + // This is a pre-Granite parameter, for post-Granite, this + // is hardcoded to 50 l1 blocks! + channelTimeout: uint64 + // L1 account that batches are sent to. + batchInboxAddress: #Address + // block at which the op-node should start syncing + // from. It is an override to set this value on legacy networks where it is not set by + // default. It can be removed once all networks have this value set in their storage. + // This is only relevant for older proxies that get upgraded, if this is set to + // 0, the SystemConfig will set this to it's initialization block automatically. + // The value itself is then read from the op-node from the contract storage. + systemConfigStartBlock: uint64 + // address of the key the sequencer uses to sign blocks on the P2P layer + p2pSequencerAddress: #Address + // initial sequencer account that authorizes batches. + // transactions sent from this account to the batch inbox address are considered valid. + // this value is "initial" only since it will be set in the genesis blocks + // system-config. + batchSenderAddress: #Address + // owner of the ProxyAdmin predeploy on L2. + proxyAdminOwner: #Address + // owner of the system on L1. Any L1 contract that is ownable has + // this account set as its owner. + finalSystemOwner: #Address + + // the base-fee-vault related values are passed to the fee-vault contract. + // This contract is pre-deployed, but doesn't receive the fees in Cel2. + + // Recipient must not be the ZeroAddress as per the docs. + baseFeeVaultRecipient: #Address + // minimum withdrawal amount for the BaseFeeVault + baseFeeVaultMinimumWithdrawalAmount: #Hex + // withdrawal network for the BaseFeeVault + baseFeeVaultWithdrawalNetwork: uint64 + + // the l1-fee vault related values are passed to the fee-vault contract. + // This contract is pre-deployed, but doesn't receive the l1-fee in Cel2, because + // we set our l1-fee scalars to zero. + + // recipient of fees accumulated in the L1FeeVault. + // can be an account on L1 or L2, depending on the L1FeeVaultWithdrawalNetwork value + // Recipient must not be the ZeroAddress as per the docs. + l1FeeVaultRecipient: #Address + // minimum withdrawal amount for the L1FeeVault + l1FeeVaultMinimumWithdrawalAmount: #Hex + // withdrawal network for the L1FeeVault + l1FeeVaultWithdrawalNetwork: uint64 + + // the sequencer-fee-vault related values are passed to the fee-vault contract. + // This contract is pre-deployed, but it doesn't receive the fee-tip in Cel2. + // The value is set in the genesis block as well as in the payload-attributes + // as the Coinbase. + + // recipient of fees accumulated in the SequencerFeeVault. + // can be an account on L1 or L2, depending on the SequencerFeeVaultWithdrawalNetwork value + sequencerFeeVaultRecipient: #Address + // minimum withdrawal amount for the SequencerFeeVault + sequencerFeeVaultMinimumWithdrawalAmount: #Hex + // withdrawal network for the SequencerFeeVault + sequencerFeeVaultWithdrawalNetwork: uint64 + ... +} + +#EIP1559: { + // denominator of EIP1559 base fee market. + eip1559Denominator: uint64 & >0 + // elasticity of the EIP1559 fee market. + eip1559Elasticity: uint64 + // denominator of EIP1559 base fee market when Canyon is active. + eip1559DenominatorCanyon: uint64 & eip1559Denominator + // EIP1559BaseFeeFloor fixed floor for the EIP1559 base fee market. + eip1559BaseFeeFloor: uint64 + ... +} + +#Governance: { + // configures whether or not include governance token predeploy + enableGovernance: bool + // ERC20 symbol of the GovernanceToken + governanceTokenName: "Optimism" + // ERC20 name of the GovernanceToken + governanceTokenSymbol: "OP" + // owner of the GovernanceToken. + // Has the ability to mint and burn tokens. + governanceTokenOwner: #Address + ... +} + +#GasPriceOracle: { + // value of the base fee scalar used for fee calculations. + // part of the system-config, so this takes effect in the genesis + // block until it is overwritten by system events. + gasPriceOracleBaseFeeScalar: uint64 + // value of the blob base fee scalar used for fee calculations. + // part of the system-config, so this takes effect in the genesis + // block until it is overwritten by system events. + gasPriceOracleBlobBaseFeeScalar: uint64 + + // initial value of the gas overhead in the GasPriceOracle predeploy. + // deprecated: Since Ecotone, this field is superseded by gasPriceOracleBaseFeeScalar and GasPriceOracleBlobBaseFeeScalar. + // part of the system-config, so this takes effect in the genesis + // block until it is overwritten by system events. + gasPriceOracleOverhead?: uint64 + // initial value of the gas scalar in the GasPriceOracle predeploy. + // deprecated: Since Ecotone, this field is superseded by gasPriceOracleBaseFeeScalar and GasPriceOracleBlobBaseFeeScalar. + // part of the system-config, so this takes effect in the genesis + // block until it is overwritten by system events. + gasPriceOracleScalar?: uint64 + ... +} + +#Dev: { + // configures whether to fund the dev accounts. + // This should only be used during devnet deployments. + fundDevAccounts: bool + // deploys the celo contracts within the l2 genesis alloction. + // This should only be used during devnet deployments. + deployCeloContracts: bool + ... +} + +#Celo: { + // TODO: do we want to deploy with the script, + // or deploy in advance and configure the address + // + // flag to indicate that a custom gas token should be used + useCustomGasToken: bool + // address of the ERC20 token to be used to pay for gas on L2 + customGasTokenAddress: #Address + proxyAdminOwnerIsMultisig?: bool + externalSuperchainConfig?: #Address + ... +} + +#DataAvailability: { + // flag that indicates if the system is using op-alt-da + useAltDA: bool + // specifies the allowed commitment + daCommitmentType: #CommitmentType + // block interval during which the availability of a data commitment can be challenged. + daChallengeWindow: uint64 & >0 + // block interval during which a data availability challenge can be resolved. + daResolveWindow: uint64 & >0 + + // TODO: + // Javi: probably doesn't make sense to set this in permissioned fault proofs + + // percentage of the resolving cost to be refunded to the resolver + // such as 100 means 100% refund. + daResolverRefundPercentage?: uint8 & >=0 & <=100 + // required bond size to initiate a data availability challenge. + daBondSize?: uint64 + // represents the L1 address of the DataAvailabilityChallenge contract. + daChallengeProxy?: #Address + ... +} +#UpgradeSchedule: { + // number of seconds after genesis block that Regolith hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Regolith. + l2GenesisRegolithTimeOffset?: #Hex + // number of seconds after genesis block that Canyon hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Canyon. + l2GenesisCanyonTimeOffset?: #Hex + // number of seconds after genesis block that Delta hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Delta. + l2GenesisDeltaTimeOffset?: #Hex + // number of seconds after genesis block that Ecotone hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Ecotone. + l2GenesisEcotoneTimeOffset?: #Hex + // number of seconds after genesis block that Fjord hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Fjord. + l2GenesisFjordTimeOffset?: #Hex + // number of seconds after genesis block that Granite hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Granite. + l2GenesisGraniteTimeOffset?: #Hex + // number of seconds after genesis block that the Holocene hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Holocene. + l2GenesisHoloceneTimeOffset?: #Hex | *null + // number of seconds after genesis block that the Isthmus hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Isthmus. + l2GenesisIsthmusTimeOffset?: #Hex | *null + // number of seconds after genesis block that the Interop hard fork activates. + // Set it to 0 to activate at genesis. Nil to disable Interop. + l2GenesisInteropTimeOffset?: #Hex + // When Cancun activates. Relative to L1 genesis. + // NOTE: probably set accoring to mainnet value + l1CancunTimeOffset?: #Hex + // When Prague activates. Relative to L1 genesis. + // NOTE: probably set accoring to mainnet value + l1PragueTimeOffset?: #Hex + // is a flag that indicates if the system is using interop + useInterop?: bool + ... +} + +#L2GenesisBlock: { + // TODO: those values are currently all nulled or using a default, should we set any of those? + // L2GenesisBlockNonce hexutil.Uint64 `json:"l2GenesisBlockNonce"` + // L2GenesisBlockDifficulty *hexutil.Big `json:"l2GenesisBlockDifficulty"` + // L2GenesisBlockMixHash common.Hash `json:"l2GenesisBlockMixHash"` + // L2GenesisBlockNumber hexutil.Uint64 `json:"l2GenesisBlockNumber"` + // L2GenesisBlockGasUsed hexutil.Uint64 `json:"l2GenesisBlockGasUsed"` + // L2GenesisBlockParentHash common.Hash `json:"l2GenesisBlockParentHash"` + + // part of the system-config, so this takes effect in the genesis + // block until it is overwritten by system events. + l2GenesisBlockGasLimit: #Hex + // part of the system-config, so this takes effect in the genesis + // block until it is overwritten by system events. + l2GenesisBlockBaseFeePerGas: #Hex + ... +} + +#OutputOracle: { + // number of L2 blocks between outputs that are submitted + // to the L2OutputOracle contract located on L1. + l2OutputOracleSubmissionInterval: uint64 + // starting timestamp for the L2OutputOracle. + // MUST be the same as the timestamp of the L2OO start block. + // FIXME: this is somewhat problematic (at least for L2OO systems), + // since the computeL2Time takes that as a starting time for l2 block time calculations. + // However we previously set that based on the calculated Celo L1 migration block time, + // although this has to be the actual timestamp of the first L2 block + // specified in l2OutputOracleStartingBlockNumber + // /// @notice Returns the L2 timestamp corresponding to a given L2 block number. + // /// @param _l2BlockNumber The L2 block number of the target block. + // /// @return L2 timestamp of the given block. + // function computeL2Timestamp(uint256 _l2BlockNumber) public view returns (uint256) { + // return startingTimestamp + ((_l2BlockNumber - startingBlockNumber) * l2BlockTime); + // } + l2OutputOracleStartingTimestamp: uint64 + // starting block number for the L2OutputOracle. + // Must be greater than or equal to the first Bedrock block. + // The first L2 output will correspond to this value plus the submission interval. + l2OutputOracleStartingBlockNumber: uint64 + // address of the account that proposes L2 outputs. + l2OutputOracleProposer: #Address + // address of the account that challenges L2 outputs. + l2OutputOracleChallenger: #Address + ... +} + +#FaultProofs: { + // flag that indicates if the system is using fault + // proofs instead of the older output oracle mechanism. + useFaultProofs: bool + // absolute prestate of Cannon. This is computed + // by generating a proof from the 0th -> 1st instruction and grabbing the prestate from + // the output JSON. All honest challengers should agree on the setup state of the program. + faultGameAbsolutePrestate: #Hex64 + // maximum depth of the position tree within the fault dispute game. + // `2^{FaultGameMaxDepth}` is how many instructions the execution trace bisection game + // supports. Ideally, this should be conservatively set so that there is always enough + // room for a full Cannon trace. + faultGameMaxDepth: uint64 + // amount of time that the dispute game will set the potential grandchild claim's, + // clock to, if the remaining time is less than this value at the time of a claim's creation. + faultGameClockExtension: uint64 + // maximum amount of time that may accumulate on a team's chess clock before they + // may no longer respond. + faultGameMaxClockDuration: uint64 + // the block number for genesis. + faultGameGenesisBlock: uint64 + // output root for the genesis block. + faultGameGenesisOutputRoot: #Hex64 + // depth at which the fault dispute game splits from output roots to execution trace claims. + faultGameSplitDepth: uint64 + // number of seconds that users must wait before withdrawing ETH from a fault game. + faultGameWithdrawalDelay: uint64 + // minimum number of bytes that a large preimage oracle proposal can be. + preimageOracleMinProposalSize: uint64 + // number of seconds that challengers have to challenge a large preimage proposal. + preimageOracleChallengePeriod: uint64 + // number of seconds that a proof must be + // mature before it can be used to finalize a withdrawal. + proofMaturityDelaySeconds: uint64 + // is an additional number of seconds a + // dispute game must wait before it can be used to finalize a withdrawal. + disputeGameFinalityDelaySeconds: uint64 + // dispute game type that the OptimismPortal + // contract will respect for finalizing withdrawals. + respectedGameType: uint64 + ... +} + +#DeployConfig: #L2GenesisBlock & + #OutputOracle & + #FaultProofs & + #Superchain & + #Core & + #EIP1559 & + #GasPriceOracle & + #Governance & + #Dev & + #Celo & + #DataAvailability & + #UpgradeSchedule diff --git a/packages/contracts-bedrock/deploy-config/justfile b/packages/contracts-bedrock/deploy-config/justfile new file mode 100644 index 0000000000000..ec7b352b6011a --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/justfile @@ -0,0 +1,15 @@ + +format: + cue fmt ./cue + +export-mainnet: + cue export ./cue -e network.production.mainnet -f -o mainnet-celo.json + +export-dryrun: + cue export ./cue -e network.dryrun.mainnet -f -o mainnet-celo-dryrun.json + +export-baklava: + cue export ./cue -e network.test.baklava -f -o baklava.json + +export-all: export-mainnet export-baklava export-dryrun + diff --git a/packages/contracts-bedrock/deploy-config/mainnet-celo-dryrun.json b/packages/contracts-bedrock/deploy-config/mainnet-celo-dryrun.json new file mode 100644 index 0000000000000..ac77a06229eac --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/mainnet-celo-dryrun.json @@ -0,0 +1,79 @@ +{ + "l2GenesisBlockGasLimit": "0x1c9c380", + "l2GenesisBlockBaseFeePerGas": "0x5d21dba00", + "l2OutputOracleSubmissionInterval": 1800, + "l2OutputOracleStartingTimestamp": 1742366039, + "l2OutputOracleStartingBlockNumber": 30941000, + "l2OutputOracleProposer": "0xc01061d4cc5b98965d2aa4b1dfcc1d77bb0d29f3", + "l2OutputOracleChallenger": "0x9e21944b9dd761e7a89ecb17be005e955e750f2b", + "useFaultProofs": true, + "faultGameAbsolutePrestate": "0x0364010a7b2be12b8583c8bc2c610ef5b77bb52161cac1dd4f8cbe47edc05afd", + "faultGameMaxDepth": 73, + "faultGameClockExtension": 1800, + "faultGameMaxClockDuration": 3600, + "faultGameGenesisBlock": 30941000, + "faultGameGenesisOutputRoot": "0x3c736a83458982ae1f6b62284e9af2687333e17625c7147b9af4758fa84952e8", + "faultGameSplitDepth": 30, + "faultGameWithdrawalDelay": 7200, + "preimageOracleMinProposalSize": 126000, + "preimageOracleChallengePeriod": 600, + "proofMaturityDelaySeconds": 7200, + "disputeGameFinalityDelaySeconds": 3600, + "respectedGameType": 1, + "requiredProtocolVersion": "0x0000000000000000000000000000000000000003000000010000000000000000", + "recommendedProtocolVersion": "0x0000000000000000000000000000000000000003000000010000000000000000", + "superchainConfigGuardian": "0x1174B5f5Dd8fA3be9549b131E9810703D15f153d", + "protocolVersionsProxy": "0x1b6dEB2197418075AB314ac4D52Ca1D104a8F663", + "l1StartingBlockTag": null, + "l1ChainID": 1, + "l2ChainID": 42220, + "l1BlockTime": 12, + "l2BlockTime": 1, + "finalizationPeriodSeconds": 604800, + "maxSequencerDrift": 2892, + "sequencerWindowSize": 7200, + "channelTimeout": 50, + "batchInboxAddress": "0xff00000000000000000000000000000000042220", + "systemConfigStartBlock": 0, + "p2pSequencerAddress": "0xc0fD4a912b7aC8D5a3ABDbef23c88c67Cfb528Cb", + "batchSenderAddress": "0x4e8b8dd9611845f5fb80f43662dbeefbb47a75f6", + "proxyAdminOwner": "0x4ea9acbc85d3252dffd6b500d94341f477426801", + "finalSystemOwner": "0x3d98acBC85D3252DFfd6b500D94341F4774256F0", + "baseFeeVaultRecipient": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "baseFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "baseFeeVaultWithdrawalNetwork": 1, + "l1FeeVaultRecipient": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "l1FeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "l1FeeVaultWithdrawalNetwork": 1, + "sequencerFeeVaultRecipient": "0x22EaF69162ae49605441229EdbEF7D9FC5f4f094", + "sequencerFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "sequencerFeeVaultWithdrawalNetwork": 1, + "eip1559Denominator": 400, + "eip1559Elasticity": 5, + "eip1559DenominatorCanyon": 400, + "eip1559BaseFeeFloor": 25000000000, + "gasPriceOracleBaseFeeScalar": 0, + "gasPriceOracleBlobBaseFeeScalar": 0, + "gasPriceOracleOverhead": 0, + "gasPriceOracleScalar": 0, + "enableGovernance": false, + "governanceTokenName": "Optimism", + "governanceTokenSymbol": "OP", + "governanceTokenOwner": "0x0000000000000000000000000000000000000000", + "fundDevAccounts": false, + "deployCeloContracts": false, + "useCustomGasToken": true, + "customGasTokenAddress": "0x0000000000000000000000000000000000000000", + "proxyAdminOwnerIsMultisig": true, + "externalSuperchainConfig": "0x95703e0982140D16f8ebA6d158FccEde42f04a4C", + "useAltDA": true, + "daCommitmentType": "GenericCommitment", + "daChallengeWindow": 1, + "daResolveWindow": 1, + "l2GenesisRegolithTimeOffset": "0x0", + "l2GenesisCanyonTimeOffset": "0x0", + "l2GenesisDeltaTimeOffset": "0x0", + "l2GenesisEcotoneTimeOffset": "0x0", + "l2GenesisFjordTimeOffset": "0x0", + "l2GenesisGraniteTimeOffset": "0x0" +} diff --git a/packages/contracts-bedrock/deploy-config/mainnet-celo.json b/packages/contracts-bedrock/deploy-config/mainnet-celo.json new file mode 100644 index 0000000000000..996679981aea7 --- /dev/null +++ b/packages/contracts-bedrock/deploy-config/mainnet-celo.json @@ -0,0 +1,79 @@ +{ + "l2GenesisBlockGasLimit": "0x1c9c380", + "l2GenesisBlockBaseFeePerGas": "0x5d21dba00", + "l2OutputOracleSubmissionInterval": 1800, + "l2OutputOracleStartingTimestamp": 0, + "l2OutputOracleStartingBlockNumber": 0, + "l2OutputOracleProposer": "0x1204884e697efd929729b9a717ea14496298a689", + "l2OutputOracleChallenger": "0x6b145ebf66602ec524b196426b46631259689583", + "useFaultProofs": true, + "faultGameAbsolutePrestate": "0x0364010a7b2be12b8583c8bc2c610ef5b77bb52161cac1dd4f8cbe47edc05afd", + "faultGameMaxDepth": 73, + "faultGameClockExtension": 10800, + "faultGameMaxClockDuration": 302400, + "faultGameGenesisBlock": 31056500, + "faultGameGenesisOutputRoot": "0x3c736a83458982ae1f6b62284e9af2687333e17625c7147b9af4758fa84952e8", + "faultGameSplitDepth": 30, + "faultGameWithdrawalDelay": 604800, + "preimageOracleMinProposalSize": 126000, + "preimageOracleChallengePeriod": 86400, + "proofMaturityDelaySeconds": 604800, + "disputeGameFinalityDelaySeconds": 302400, + "respectedGameType": 1, + "requiredProtocolVersion": "0x0000000000000000000000000000000000000003000000010000000000000000", + "recommendedProtocolVersion": "0x0000000000000000000000000000000000000003000000010000000000000000", + "superchainConfigGuardian": "0x6E226fa22e5F19363d231D3FA048aaBa73CC1f47", + "protocolVersionsProxy": "0x1b6dEB2197418075AB314ac4D52Ca1D104a8F663", + "l1StartingBlockTag": null, + "l1ChainID": 1, + "l2ChainID": 42220, + "l1BlockTime": 12, + "l2BlockTime": 1, + "finalizationPeriodSeconds": 604800, + "maxSequencerDrift": 2892, + "sequencerWindowSize": 7200, + "channelTimeout": 50, + "batchInboxAddress": "0xff00000000000000000000000000000000042220", + "systemConfigStartBlock": 0, + "p2pSequencerAddress": "0xA6F1c6c24De8b112dd3867dB907d187d490e6ddF", + "batchSenderAddress": "0x0cd08c7f7a96aa9635f761b49216b9ea74c5ca60", + "proxyAdminOwner": "0x51a3a77baf58fef0309452ceacb09221e556f223", + "finalSystemOwner": "0x4092A77bAF58fef0309452cEaCb09221e556E112", + "baseFeeVaultRecipient": "0x7A1E98FC9a008107DbD1f430a05Ace8cf6f3FE19", + "baseFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "baseFeeVaultWithdrawalNetwork": 1, + "l1FeeVaultRecipient": "0x7A1E98FC9a008107DbD1f430a05Ace8cf6f3FE19", + "l1FeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "l1FeeVaultWithdrawalNetwork": 1, + "sequencerFeeVaultRecipient": "0x7A1E98FC9a008107DbD1f430a05Ace8cf6f3FE19", + "sequencerFeeVaultMinimumWithdrawalAmount": "0x8ac7230489e80000", + "sequencerFeeVaultWithdrawalNetwork": 1, + "eip1559Denominator": 400, + "eip1559Elasticity": 5, + "eip1559DenominatorCanyon": 400, + "eip1559BaseFeeFloor": 25000000000, + "gasPriceOracleBaseFeeScalar": 0, + "gasPriceOracleBlobBaseFeeScalar": 0, + "gasPriceOracleOverhead": 0, + "gasPriceOracleScalar": 0, + "enableGovernance": false, + "governanceTokenName": "Optimism", + "governanceTokenSymbol": "OP", + "governanceTokenOwner": "0x0000000000000000000000000000000000000000", + "fundDevAccounts": false, + "deployCeloContracts": false, + "useCustomGasToken": true, + "customGasTokenAddress": "0x0000000000000000000000000000000000000000", + "proxyAdminOwnerIsMultisig": true, + "externalSuperchainConfig": "0x95703e0982140D16f8ebA6d158FccEde42f04a4C", + "useAltDA": true, + "daCommitmentType": "GenericCommitment", + "daChallengeWindow": 1, + "daResolveWindow": 1, + "l2GenesisRegolithTimeOffset": "0x0", + "l2GenesisCanyonTimeOffset": "0x0", + "l2GenesisDeltaTimeOffset": "0x0", + "l2GenesisEcotoneTimeOffset": "0x0", + "l2GenesisFjordTimeOffset": "0x0", + "l2GenesisGraniteTimeOffset": "0x0" +}