diff --git a/deployment/ccip/changeset/cs_prerequisites.go b/deployment/ccip/changeset/cs_prerequisites.go index 84c2b118ddc..3b52fa09cd5 100644 --- a/deployment/ccip/changeset/cs_prerequisites.go +++ b/deployment/ccip/changeset/cs_prerequisites.go @@ -5,6 +5,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" "github.com/pkg/errors" "golang.org/x/sync/errgroup" @@ -28,6 +29,7 @@ import ( "github.com/smartcontractkit/chainlink-evm/gethwrappers/shared/generated/burn_mint_erc677" "github.com/smartcontractkit/chainlink-evm/gethwrappers/shared/generated/multicall3" "github.com/smartcontractkit/chainlink-evm/gethwrappers/shared/generated/weth9" + "github.com/smartcontractkit/chainlink-evm/gethwrappers/shared/generated/weth9_zksync" cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment" @@ -185,11 +187,28 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state case deployOpts.LegacyDeploymentCfg != nil && deployOpts.LegacyDeploymentCfg.RMNConfig != nil: rmn, err := cldf.DeployContract(lggr, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*rmn_contract.RMNContract] { - rmnAddress, tx2, rmnC, err2 := rmn_contract.DeployRMNContract( - chain.DeployerKey, - chain.Client, - *deployOpts.LegacyDeploymentCfg.RMNConfig, + var ( + rmnAddress common.Address + tx2 *types.Transaction + rmnC *rmn_contract.RMNContract + err2 error ) + + if chain.IsZkSyncVM { + rmnAddress, _, rmnC, err2 = rmn_contract.DeployRMNContractZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + *deployOpts.LegacyDeploymentCfg.RMNConfig, + ) + } else { + rmnAddress, tx2, rmnC, err2 = rmn_contract.DeployRMNContract( + chain.DeployerKey, + chain.Client, + *deployOpts.LegacyDeploymentCfg.RMNConfig, + ) + } return cldf.ContractDeploy[*rmn_contract.RMNContract]{ Address: rmnAddress, Contract: rmnC, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.RMN, deployment.Version1_5_0), Err: err2, } @@ -204,10 +223,25 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if chainState.MockRMN == nil { rmn, err := cldf.DeployContract(lggr, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*mock_rmn_contract.MockRMNContract] { - rmnAddress, tx2, rmnC, err2 := mock_rmn_contract.DeployMockRMNContract( - chain.DeployerKey, - chain.Client, + var ( + rmnAddress common.Address + tx2 *types.Transaction + rmnC *mock_rmn_contract.MockRMNContract + err2 error ) + if chain.IsZkSyncVM { + rmnAddress, _, rmnC, err2 = mock_rmn_contract.DeployMockRMNContractZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + ) + } else { + rmnAddress, tx2, rmnC, err2 = mock_rmn_contract.DeployMockRMNContract( + chain.DeployerKey, + chain.Client, + ) + } return cldf.ContractDeploy[*mock_rmn_contract.MockRMNContract]{ Address: rmnAddress, Contract: rmnC, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.MockRMN, deployment.Version1_0_0), Err: err2, } @@ -225,11 +259,27 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if rmnProxy == nil { RMNProxy, err := cldf.DeployContract(lggr, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*rmn_proxy_contract.RMNProxy] { - rmnProxyAddr, tx2, rmnProxy2, err2 := rmn_proxy_contract.DeployRMNProxy( - chain.DeployerKey, - chain.Client, - rmnAddr, + var ( + rmnProxyAddr common.Address + tx2 *types.Transaction + rmnProxy2 *rmn_proxy_contract.RMNProxy + err2 error ) + if chain.IsZkSyncVM { + rmnProxyAddr, _, rmnProxy2, err2 = rmn_proxy_contract.DeployRMNProxyZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + rmnAddr, + ) + } else { + rmnProxyAddr, tx2, rmnProxy2, err2 = rmn_proxy_contract.DeployRMNProxy( + chain.DeployerKey, + chain.Client, + rmnAddr, + ) + } return cldf.ContractDeploy[*rmn_proxy_contract.RMNProxy]{ Address: rmnProxyAddr, Contract: rmnProxy2, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.ARMProxy, deployment.Version1_0_0), Err: err2, } @@ -276,9 +326,24 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if tokenAdminReg == nil { tokenAdminRegistry, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*token_admin_registry.TokenAdminRegistry] { - tokenAdminRegistryAddr, tx2, tokenAdminRegistry, err2 := token_admin_registry.DeployTokenAdminRegistry( - chain.DeployerKey, - chain.Client) + var ( + tokenAdminRegistryAddr common.Address + tx2 *types.Transaction + tokenAdminRegistry *token_admin_registry.TokenAdminRegistry + err2 error + ) + if chain.IsZkSyncVM { + tokenAdminRegistryAddr, _, tokenAdminRegistry, err2 = token_admin_registry.DeployTokenAdminRegistryZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + ) + } else { + tokenAdminRegistryAddr, tx2, tokenAdminRegistry, err2 = token_admin_registry.DeployTokenAdminRegistry( + chain.DeployerKey, + chain.Client) + } return cldf.ContractDeploy[*token_admin_registry.TokenAdminRegistry]{ Address: tokenAdminRegistryAddr, Contract: tokenAdminRegistry, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.TokenAdminRegistry, deployment.Version1_5_0), Err: err2, } @@ -302,10 +367,26 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if len(regAddresses) == 0 { customRegistryModule, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*registry_module_owner_custom.RegistryModuleOwnerCustom] { - regModAddr, tx2, regMod, err2 := registry_module_owner_custom.DeployRegistryModuleOwnerCustom( - chain.DeployerKey, - chain.Client, - tokenAdminReg.Address()) + var ( + regModAddr common.Address + tx2 *types.Transaction + regMod *registry_module_owner_custom.RegistryModuleOwnerCustom + err2 error + ) + if chain.IsZkSyncVM { + regModAddr, _, regMod, err2 = registry_module_owner_custom.DeployRegistryModuleOwnerCustomZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + tokenAdminReg.Address(), + ) + } else { + regModAddr, tx2, regMod, err2 = registry_module_owner_custom.DeployRegistryModuleOwnerCustom( + chain.DeployerKey, + chain.Client, + tokenAdminReg.Address()) + } return cldf.ContractDeploy[*registry_module_owner_custom.RegistryModuleOwnerCustom]{ Address: regModAddr, Contract: regMod, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.RegistryModule, deployment.Version1_6_0), Err: err2, } @@ -342,12 +423,40 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state } if weth9Contract == nil { + deployWeth9ZkAndPort := func(chain cldf.Chain) (*weth9.WETH9, common.Address, error) { + weth9AddrZk, _, weth9zk, err := weth9_zksync.DeployWETH9ZKSyncZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + ) + if err != nil { + return nil, common.Address{}, err + } + weth9ZkPorted, err := weth9.NewWETH9(weth9zk.Address(), chain.Client) + if err != nil { + return nil, common.Address{}, err + } + + return weth9ZkPorted, weth9AddrZk, nil + } + weth, err := cldf.DeployContract(lggr, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*weth9.WETH9] { - weth9Addr, tx2, weth9c, err2 := weth9.DeployWETH9( - chain.DeployerKey, - chain.Client, + var ( + weth9Addr common.Address + tx2 *types.Transaction + weth9c *weth9.WETH9 + err2 error ) + if chain.IsZkSyncVM { + weth9c, weth9Addr, err2 = deployWeth9ZkAndPort(chain) + } else { + weth9Addr, tx2, weth9c, err2 = weth9.DeployWETH9( + chain.DeployerKey, + chain.Client, + ) + } return cldf.ContractDeploy[*weth9.WETH9]{ Address: weth9Addr, Contract: weth9c, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.WETH9, deployment.Version1_0_0), Err: err2, } @@ -366,12 +475,29 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if r == nil { routerContract, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*router.Router] { - routerAddr, tx2, routerC, err2 := router.DeployRouter( - chain.DeployerKey, - chain.Client, - weth9Contract.Address(), - rmnProxy.Address(), + var ( + routerAddr common.Address + tx2 *types.Transaction + routerC *router.Router + err2 error ) + if chain.IsZkSyncVM { + routerAddr, _, routerC, err2 = router.DeployRouterZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + weth9Contract.Address(), + rmnProxy.Address(), + ) + } else { + routerAddr, tx2, routerC, err2 = router.DeployRouter( + chain.DeployerKey, + chain.Client, + weth9Contract.Address(), + rmnProxy.Address(), + ) + } return cldf.ContractDeploy[*router.Router]{ Address: routerAddr, Contract: routerC, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.Router, deployment.Version1_2_0), Err: err2, } @@ -389,17 +515,36 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if tokenPoolFactory == nil { _, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*token_pool_factory.TokenPoolFactory] { - tpfAddr, tx2, contract, err2 := token_pool_factory.DeployTokenPoolFactory( - chain.DeployerKey, - chain.Client, - tokenAdminReg.Address(), - // There will always be at least one registry module deployed at this point. - // We just use the first one here. If a different RegistryModule is desired, - // users can run DeployTokenPoolFactoryChangeset with the desired address. - regAddresses[0], - rmnProxy.Address(), - r.Address(), + var ( + tpfAddr common.Address + tx2 *types.Transaction + contract *token_pool_factory.TokenPoolFactory + err2 error ) + if chain.IsZkSyncVM { + tpfAddr, _, contract, err2 = token_pool_factory.DeployTokenPoolFactoryZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + tokenAdminReg.Address(), + regAddresses[0], + rmnProxy.Address(), + r.Address(), + ) + } else { + tpfAddr, tx2, contract, err2 = token_pool_factory.DeployTokenPoolFactory( + chain.DeployerKey, + chain.Client, + tokenAdminReg.Address(), + // There will always be at least one registry module deployed at this point. + // We just use the first one here. If a different RegistryModule is desired, + // users can run DeployTokenPoolFactoryChangeset with the desired address. + regAddresses[0], + rmnProxy.Address(), + r.Address(), + ) + } return cldf.ContractDeploy[*token_pool_factory.TokenPoolFactory]{ Address: tpfAddr, Contract: contract, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.TokenPoolFactory, deployment.Version1_5_1), Err: err2, } @@ -417,16 +562,37 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if factoryBurnMintERC20 == nil { _, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*factory_burn_mint_erc20.FactoryBurnMintERC20] { - factoryBurnMintERC20Addr, tx2, contract, err2 := factory_burn_mint_erc20.DeployFactoryBurnMintERC20( - chain.DeployerKey, - chain.Client, - string(shared.FactoryBurnMintERC20Symbol), - string(shared.FactoryBurnMintERC20Symbol), - 18, - big.NewInt(0), - big.NewInt(0), - chain.DeployerKey.From, + var ( + factoryBurnMintERC20Addr common.Address + tx2 *types.Transaction + contract *factory_burn_mint_erc20.FactoryBurnMintERC20 + err2 error ) + if chain.IsZkSyncVM { + factoryBurnMintERC20Addr, _, contract, err2 = factory_burn_mint_erc20.DeployFactoryBurnMintERC20Zk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + string(shared.FactoryBurnMintERC20Symbol), + string(shared.FactoryBurnMintERC20Symbol), + uint8(18), + big.NewInt(0), + big.NewInt(0), + chain.DeployerKey.From, + ) + } else { + factoryBurnMintERC20Addr, tx2, contract, err2 = factory_burn_mint_erc20.DeployFactoryBurnMintERC20( + chain.DeployerKey, + chain.Client, + string(shared.FactoryBurnMintERC20Symbol), + string(shared.FactoryBurnMintERC20Symbol), + 18, + big.NewInt(0), + big.NewInt(0), + chain.DeployerKey.From, + ) + } return cldf.ContractDeploy[*factory_burn_mint_erc20.FactoryBurnMintERC20]{ Address: factoryBurnMintERC20Addr, Contract: contract, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.FactoryBurnMintERC20Token, deployment.Version1_0_0), Err: err2, } @@ -443,10 +609,25 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if deployOpts.Multicall3Enabled && mc3 == nil { _, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*multicall3.Multicall3] { - multicall3Addr, tx2, multicall3Wrapper, err2 := multicall3.DeployMulticall3( - chain.DeployerKey, - chain.Client, + var ( + multicall3Addr common.Address + tx2 *types.Transaction + multicall3Wrapper *multicall3.Multicall3 + err2 error ) + if chain.IsZkSyncVM { + multicall3Addr, _, multicall3Wrapper, err2 = multicall3.DeployMulticall3Zk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + ) + } else { + multicall3Addr, tx2, multicall3Wrapper, err2 = multicall3.DeployMulticall3( + chain.DeployerKey, + chain.Client, + ) + } return cldf.ContractDeploy[*multicall3.Multicall3]{ Address: multicall3Addr, Contract: multicall3Wrapper, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.Multicall3, deployment.Version1_0_0), Err: err2, } @@ -475,11 +656,27 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state if chainState.Receiver == nil { _, err := cldf.DeployContract(e.Logger, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*maybe_revert_message_receiver.MaybeRevertMessageReceiver] { - receiverAddr, tx, receiver, err2 := maybe_revert_message_receiver.DeployMaybeRevertMessageReceiver( - chain.DeployerKey, - chain.Client, - false, + var ( + receiverAddr common.Address + tx *types.Transaction + receiver *maybe_revert_message_receiver.MaybeRevertMessageReceiver + err2 error ) + if chain.IsZkSyncVM { + receiverAddr, _, receiver, err2 = maybe_revert_message_receiver.DeployMaybeRevertMessageReceiverZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + false, + ) + } else { + receiverAddr, tx, receiver, err2 = maybe_revert_message_receiver.DeployMaybeRevertMessageReceiver( + chain.DeployerKey, + chain.Client, + false, + ) + } return cldf.ContractDeploy[*maybe_revert_message_receiver.MaybeRevertMessageReceiver]{ Address: receiverAddr, Contract: receiver, Tx: tx, Tv: cldf.NewTypeAndVersion(shared.CCIPReceiver, deployment.Version1_0_0), Err: err2, } @@ -500,13 +697,31 @@ func deployPrerequisiteContracts(e cldf.Environment, ab cldf.AddressBook, state } _, err := cldf.DeployContract(lggr, chain, ab, func(chain cldf.Chain) cldf.ContractDeploy[*price_registry_1_2_0.PriceRegistry] { - priceRegAddr, tx2, priceRegAddrC, err2 := price_registry_1_2_0.DeployPriceRegistry( - chain.DeployerKey, - chain.Client, - nil, - []common.Address{weth9Contract.Address(), linkAddr}, - deployOpts.LegacyDeploymentCfg.PriceRegStalenessThreshold, + var ( + priceRegAddr common.Address + tx2 *types.Transaction + priceRegAddrC *price_registry_1_2_0.PriceRegistry + err2 error ) + if chain.IsZkSyncVM { + priceRegAddr, _, priceRegAddrC, err2 = price_registry_1_2_0.DeployPriceRegistryZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + nil, + []common.Address{weth9Contract.Address(), linkAddr}, + deployOpts.LegacyDeploymentCfg.PriceRegStalenessThreshold, + ) + } else { + priceRegAddr, tx2, priceRegAddrC, err2 = price_registry_1_2_0.DeployPriceRegistry( + chain.DeployerKey, + chain.Client, + nil, + []common.Address{weth9Contract.Address(), linkAddr}, + deployOpts.LegacyDeploymentCfg.PriceRegStalenessThreshold, + ) + } return cldf.ContractDeploy[*price_registry_1_2_0.PriceRegistry]{ Address: priceRegAddr, Contract: priceRegAddrC, Tx: tx2, Tv: cldf.NewTypeAndVersion(shared.PriceRegistry, deployment.Version1_2_0), Err: err2, @@ -538,14 +753,33 @@ func deployUSDC( ) { token, err := cldf.DeployContract(lggr, chain, addresses, func(chain cldf.Chain) cldf.ContractDeploy[*burn_mint_erc677.BurnMintERC677] { - tokenAddress, tx, tokenContract, err2 := burn_mint_erc677.DeployBurnMintERC677( - chain.DeployerKey, - chain.Client, - shared.USDCName, - string(shared.USDCSymbol), - shared.UsdcDecimals, - big.NewInt(0), + var ( + tokenAddress common.Address + tx *types.Transaction + tokenContract *burn_mint_erc677.BurnMintERC677 + err2 error ) + if chain.IsZkSyncVM { + tokenAddress, _, tokenContract, err2 = burn_mint_erc677.DeployBurnMintERC677Zk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + shared.USDCName, + string(shared.USDCSymbol), + shared.UsdcDecimals, + big.NewInt(0), + ) + } else { + tokenAddress, tx, tokenContract, err2 = burn_mint_erc677.DeployBurnMintERC677( + chain.DeployerKey, + chain.Client, + shared.USDCName, + string(shared.USDCSymbol), + shared.UsdcDecimals, + big.NewInt(0), + ) + } return cldf.ContractDeploy[*burn_mint_erc677.BurnMintERC677]{ Address: tokenAddress, Contract: tokenContract, @@ -571,13 +805,31 @@ func deployUSDC( transmitter, err := cldf.DeployContract(lggr, chain, addresses, func(chain cldf.Chain) cldf.ContractDeploy[*mock_usdc_token_transmitter.MockE2EUSDCTransmitter] { - transmitterAddress, tx, transmitterContract, err2 := mock_usdc_token_transmitter.DeployMockE2EUSDCTransmitter( - chain.DeployerKey, - chain.Client, - 0, - reader.AllAvailableDomains()[chain.Selector], - token.Address, + var ( + transmitterAddress common.Address + tx *types.Transaction + transmitterContract *mock_usdc_token_transmitter.MockE2EUSDCTransmitter + err2 error ) + if chain.IsZkSyncVM { + transmitterAddress, _, transmitterContract, err2 = mock_usdc_token_transmitter.DeployMockE2EUSDCTransmitterZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + 0, + reader.AllAvailableDomains()[chain.Selector], + token.Address, + ) + } else { + transmitterAddress, tx, transmitterContract, err2 = mock_usdc_token_transmitter.DeployMockE2EUSDCTransmitter( + chain.DeployerKey, + chain.Client, + 0, + reader.AllAvailableDomains()[chain.Selector], + token.Address, + ) + } return cldf.ContractDeploy[*mock_usdc_token_transmitter.MockE2EUSDCTransmitter]{ Address: transmitterAddress, Contract: transmitterContract, @@ -593,12 +845,29 @@ func deployUSDC( messenger, err := cldf.DeployContract(lggr, chain, addresses, func(chain cldf.Chain) cldf.ContractDeploy[*mock_usdc_token_messenger.MockE2EUSDCTokenMessenger] { - messengerAddress, tx, messengerContract, err2 := mock_usdc_token_messenger.DeployMockE2EUSDCTokenMessenger( - chain.DeployerKey, - chain.Client, - 0, - transmitter.Address, + var ( + messengerAddress common.Address + tx *types.Transaction + messengerContract *mock_usdc_token_messenger.MockE2EUSDCTokenMessenger + err2 error ) + if chain.IsZkSyncVM { + messengerAddress, _, messengerContract, err2 = mock_usdc_token_messenger.DeployMockE2EUSDCTokenMessengerZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + 0, + transmitter.Address, + ) + } else { + messengerAddress, tx, messengerContract, err2 = mock_usdc_token_messenger.DeployMockE2EUSDCTokenMessenger( + chain.DeployerKey, + chain.Client, + 0, + transmitter.Address, + ) + } return cldf.ContractDeploy[*mock_usdc_token_messenger.MockE2EUSDCTokenMessenger]{ Address: messengerAddress, Contract: messengerContract, @@ -614,15 +883,35 @@ func deployUSDC( tokenPool, err := cldf.DeployContract(lggr, chain, addresses, func(chain cldf.Chain) cldf.ContractDeploy[*usdc_token_pool.USDCTokenPool] { - tokenPoolAddress, tx, tokenPoolContract, err2 := usdc_token_pool.DeployUSDCTokenPool( - chain.DeployerKey, - chain.Client, - messenger.Address, - token.Address, - []common.Address{}, - rmnProxy, - router, + var ( + tokenPoolAddress common.Address + tx *types.Transaction + tokenPoolContract *usdc_token_pool.USDCTokenPool + err2 error ) + if chain.IsZkSyncVM { + tokenPoolAddress, _, tokenPoolContract, err2 = usdc_token_pool.DeployUSDCTokenPoolZk( + nil, + chain.ClientZkSyncVM, + chain.DeployerKeyZkSyncVM, + chain.Client, + messenger.Address, + token.Address, + []common.Address{}, + rmnProxy, + router, + ) + } else { + tokenPoolAddress, tx, tokenPoolContract, err2 = usdc_token_pool.DeployUSDCTokenPool( + chain.DeployerKey, + chain.Client, + messenger.Address, + token.Address, + []common.Address{}, + rmnProxy, + router, + ) + } return cldf.ContractDeploy[*usdc_token_pool.USDCTokenPool]{ Address: tokenPoolAddress, Contract: tokenPoolContract, diff --git a/deployment/ccip/changeset/cs_prerequisites_test.go b/deployment/ccip/changeset/cs_prerequisites_test.go index 4a1c264be9e..e2cd33c679c 100644 --- a/deployment/ccip/changeset/cs_prerequisites_test.go +++ b/deployment/ccip/changeset/cs_prerequisites_test.go @@ -6,6 +6,7 @@ import ( "github.com/stretchr/testify/require" "go.uber.org/zap/zapcore" + cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/deployment/ccip/shared/stateview" "github.com/smartcontractkit/chainlink/deployment/environment/memory" @@ -15,11 +16,29 @@ import ( func TestDeployPrerequisites(t *testing.T) { t.Parallel() lggr := logger.TestLogger(t) + e := memory.NewMemoryEnvironment(t, lggr, zapcore.InfoLevel, memory.MemoryEnvironmentConfig{ Bootstraps: 1, Chains: 2, Nodes: 4, }) + + testDeployPrerequisitesWithEnv(t, e) +} + +func TestDeployPrerequisitesZk(t *testing.T) { + t.Parallel() + lggr := logger.TestLogger(t) + e := memory.NewMemoryEnvironment(t, lggr, zapcore.InfoLevel, memory.MemoryEnvironmentConfig{ + Bootstraps: 1, + ZkChains: 2, + Nodes: 4, + }) + + testDeployPrerequisitesWithEnv(t, e) +} + +func testDeployPrerequisitesWithEnv(t *testing.T, e cldf.Environment) { newChain := e.AllChainSelectors()[0] cfg := changeset.DeployPrerequisiteConfig{ Configs: []changeset.DeployPrerequisiteConfigPerChain{