config.ts 7.76 KB
Newer Older
1 2
/* External Imports */
import { Signer, ContractFactory, Contract } from 'ethers'
3
import { TransactionResponse } from '@ethersproject/abstract-provider'
4
import { Overrides } from '@ethersproject/contracts'
5 6 7 8 9 10 11 12 13 14 15 16

/* Internal Imports */
import { getContractFactory } from '../contract-defs'

export interface RollupDeployConfig {
  deploymentSigner: Signer
  ovmGasMeteringConfig: {
    minTransactionGasLimit: number
    maxTransactionGasLimit: number
    maxGasPerQueuePerEpoch: number
    secondsPerEpoch: number
  }
17 18
  ovmGlobalContext: {
    ovmCHAINID: number
19
    L2CrossDomainMessengerAddress: string
20
  }
21 22 23
  transactionChainConfig: {
    sequencer: string | Signer
    forceInclusionPeriodSeconds: number
24
    forceInclusionPeriodBlocks: number
25
  }
26 27 28 29
  stateChainConfig: {
    fraudProofWindowSeconds: number
    sequencerPublishWindowSeconds: number
  }
30 31 32
  l1CrossDomainMessengerConfig: {
    relayerAddress?: string | Signer
  }
33 34 35 36
  whitelistConfig: {
    owner: string | Signer
    allowArbitraryContractDeployment: boolean
  }
37
  addressManager?: string
38
  dependencies?: string[]
39 40
  deployOverrides: Overrides
  waitForReceipts: boolean
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
}

export interface ContractDeployParameters {
  factory: ContractFactory
  params?: any[]
  afterDeploy?: (contracts?: { [name: string]: Contract }) => Promise<void>
}

export interface ContractDeployConfig {
  [name: string]: ContractDeployParameters
}

export const makeContractDeployConfig = async (
  config: RollupDeployConfig,
  AddressManager: Contract
): Promise<ContractDeployConfig> => {
57 58 59 60 61 62 63 64 65 66
  const _sendTx = async (
    txPromise: Promise<TransactionResponse>
  ): Promise<TransactionResponse> => {
    const res = await txPromise
    if (config.waitForReceipts) {
      await res.wait()
    }
    return res
  }

67
  return {
68 69 70 71
    OVM_L2CrossDomainMessenger: {
      factory: getContractFactory('OVM_L2CrossDomainMessenger'),
      params: [AddressManager.address],
    },
72 73
    OVM_L1CrossDomainMessenger: {
      factory: getContractFactory('OVM_L1CrossDomainMessenger'),
74
      params: [],
75 76 77 78 79
      afterDeploy: async (contracts): Promise<void> => {
        if (config.l1CrossDomainMessengerConfig.relayerAddress) {
          const relayer = config.l1CrossDomainMessengerConfig.relayerAddress
          const address =
            typeof relayer === 'string' ? relayer : await relayer.getAddress()
80 81 82
          await _sendTx(
            AddressManager.setAddress('OVM_L2MessageRelayer', address)
          )
83 84
        }
      },
85 86 87 88 89 90 91
    },
    Proxy__OVM_L1CrossDomainMessenger: {
      factory: getContractFactory('Lib_ResolvedDelegateProxy'),
      params: [AddressManager.address, 'OVM_L1CrossDomainMessenger'],
      afterDeploy: async (contracts): Promise<void> => {
        const xDomainMessenger = getContractFactory(
          'OVM_L1CrossDomainMessenger'
92 93 94
        )
          .connect(config.deploymentSigner)
          .attach(contracts.Proxy__OVM_L1CrossDomainMessenger.address)
95 96 97 98 99 100 101 102 103 104 105 106
        await _sendTx(
          xDomainMessenger.initialize(
            AddressManager.address,
            config.deployOverrides
          )
        )
        await _sendTx(
          AddressManager.setAddress(
            'OVM_L2CrossDomainMessenger',
            config.ovmGlobalContext.L2CrossDomainMessengerAddress,
            config.deployOverrides
          )
107
        )
108
      },
109
    },
110 111 112 113 114 115 116
    OVM_L1ETHGateway: {
      factory: getContractFactory('OVM_L1ETHGateway'),
      params: [
        AddressManager.address,
        '0x4200000000000000000000000000000000000006',
      ],
    },
117 118 119 120
    OVM_L1MultiMessageRelayer: {
      factory: getContractFactory('OVM_L1MultiMessageRelayer'),
      params: [AddressManager.address],
    },
121 122 123 124 125
    OVM_CanonicalTransactionChain: {
      factory: getContractFactory('OVM_CanonicalTransactionChain'),
      params: [
        AddressManager.address,
        config.transactionChainConfig.forceInclusionPeriodSeconds,
126 127
        config.transactionChainConfig.forceInclusionPeriodBlocks,
        config.ovmGasMeteringConfig.maxTransactionGasLimit,
128
      ],
129
      afterDeploy: async (): Promise<void> => {
130 131 132 133 134
        const sequencer = config.transactionChainConfig.sequencer
        const sequencerAddress =
          typeof sequencer === 'string'
            ? sequencer
            : await sequencer.getAddress()
135 136 137 138 139 140 141 142
        await _sendTx(
          AddressManager.setAddress(
            'OVM_DecompressionPrecompileAddress',
            '0x4200000000000000000000000000000000000005'
          )
        )
        await _sendTx(
          AddressManager.setAddress('OVM_Sequencer', sequencerAddress)
143
        )
144
        await _sendTx(AddressManager.setAddress('Sequencer', sequencerAddress))
145 146 147 148
      },
    },
    OVM_StateCommitmentChain: {
      factory: getContractFactory('OVM_StateCommitmentChain'),
149 150 151 152 153
      params: [
        AddressManager.address,
        config.stateChainConfig.fraudProofWindowSeconds,
        config.stateChainConfig.sequencerPublishWindowSeconds,
      ],
154
    },
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
    OVM_DeployerWhitelist: {
      factory: getContractFactory('OVM_DeployerWhitelist'),
      params: [],
    },
    OVM_L1MessageSender: {
      factory: getContractFactory('OVM_L1MessageSender'),
      params: [],
    },
    OVM_L2ToL1MessagePasser: {
      factory: getContractFactory('OVM_L2ToL1MessagePasser'),
      params: [],
    },
    OVM_SafetyChecker: {
      factory: getContractFactory('OVM_SafetyChecker'),
      params: [],
    },
171 172
    OVM_ExecutionManager: {
      factory: getContractFactory('OVM_ExecutionManager'),
173 174 175
      params: [
        AddressManager.address,
        config.ovmGasMeteringConfig,
176
        config.ovmGlobalContext,
177
      ],
178 179 180 181 182
    },
    OVM_StateManager: {
      factory: getContractFactory('OVM_StateManager'),
      params: [await config.deploymentSigner.getAddress()],
      afterDeploy: async (contracts): Promise<void> => {
183 184 185 186 187
        await _sendTx(
          contracts.OVM_StateManager.setExecutionManager(
            contracts.OVM_ExecutionManager.address,
            config.deployOverrides
          )
188 189 190 191 192
        )
      },
    },
    OVM_StateManagerFactory: {
      factory: getContractFactory('OVM_StateManagerFactory'),
193
      params: [],
194 195 196 197 198 199 200
    },
    OVM_FraudVerifier: {
      factory: getContractFactory('OVM_FraudVerifier'),
      params: [AddressManager.address],
    },
    OVM_StateTransitionerFactory: {
      factory: getContractFactory('OVM_StateTransitionerFactory'),
201
      params: [AddressManager.address],
202
    },
203
    OVM_ECDSAContractAccount: {
204
      factory: getContractFactory('OVM_ECDSAContractAccount'),
205
    },
Kevin Ho's avatar
Kevin Ho committed
206 207 208 209 210 211
    OVM_SequencerEntrypoint: {
      factory: getContractFactory('OVM_SequencerEntrypoint'),
    },
    OVM_ProxySequencerEntrypoint: {
      factory: getContractFactory('OVM_ProxySequencerEntrypoint'),
    },
212
    mockOVM_ECDSAContractAccount: {
213 214
      factory: getContractFactory('mockOVM_ECDSAContractAccount'),
    },
215 216
    OVM_BondManager: {
      factory: getContractFactory('mockOVM_BondManager'),
217
      params: [AddressManager.address],
218
    },
Kevin Ho's avatar
Kevin Ho committed
219 220
    OVM_ETH: {
      factory: getContractFactory('OVM_ETH'),
221
      params: [
222 223
        '0x4200000000000000000000000000000000000007',
        '0x0000000000000000000000000000000000000000', // will be overridden by geth when state dump is ingested.  Storage key: 0x0000000000000000000000000000000000000000000000000000000000000008
224
      ],
Kevin Ho's avatar
Kevin Ho committed
225
    },
226 227 228 229 230 231 232 233 234 235 236 237
    'OVM_ChainStorageContainer:CTC:batches': {
      factory: getContractFactory('OVM_ChainStorageContainer'),
      params: [AddressManager.address, 'OVM_CanonicalTransactionChain'],
    },
    'OVM_ChainStorageContainer:CTC:queue': {
      factory: getContractFactory('OVM_ChainStorageContainer'),
      params: [AddressManager.address, 'OVM_CanonicalTransactionChain'],
    },
    'OVM_ChainStorageContainer:SCC:batches': {
      factory: getContractFactory('OVM_ChainStorageContainer'),
      params: [AddressManager.address, 'OVM_StateCommitmentChain'],
    },
238 239 240
    ERC1820Registry: {
      factory: getContractFactory('ERC1820Registry'),
    },
241 242
  }
}