diff --git a/.github/integration-in-memory-tests.yml b/.github/integration-in-memory-tests.yml index ef0bf95c596..01bb90044f4 100644 --- a/.github/integration-in-memory-tests.yml +++ b/.github/integration-in-memory-tests.yml @@ -55,13 +55,13 @@ runner-test-matrix: - PR Integration CCIP Tests test_cmd: cd integration-tests/smoke/ccip && go test ccip_batching_test.go -timeout 12m -test.parallel=2 -count=1 -json - - id: contracts/ccipreader_test.go:* - path: integration-tests/contracts/ccipreader_test.go + - id: smoke/ccip/ccip_reader_test.go:* + path: integration-tests/smoke/ccip/ccip_reader_test.go test_env_type: in-memory runs_on: ubuntu-latest triggers: - PR Integration CCIP Tests - test_cmd: cd integration-tests/contracts && go test ccipreader_test.go -timeout 5m -test.parallel=1 -count=1 -json + test_cmd: cd integration-tests/smoke/ccip && go test ccip_reader_test.go -timeout 5m -test.parallel=1 -count=1 -json - id: smoke/ccip/ccip_usdc_test.go:* path: integration-tests/smoke/ccip/ccip_usdc_test.go diff --git a/deployment/ccip/changeset/accept_ownership_test.go b/deployment/ccip/changeset/accept_ownership_test.go index dc3b0ba33b3..264be42cce1 100644 --- a/deployment/ccip/changeset/accept_ownership_test.go +++ b/deployment/ccip/changeset/accept_ownership_test.go @@ -1,21 +1,21 @@ -package changeset +package changeset_test import ( "testing" - "github.com/ethereum/go-ethereum/common" - "github.com/stretchr/testify/require" "golang.org/x/exp/maps" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" ) func Test_NewAcceptOwnershipChangeset(t *testing.T) { t.Parallel() - e, _ := NewMemoryEnvironment(t) - state, err := LoadOnchainState(e.Env) + e, _ := testhelpers.NewMemoryEnvironment(t) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) allChains := maps.Keys(e.Env.Chains) @@ -35,7 +35,7 @@ func Test_NewAcceptOwnershipChangeset(t *testing.T) { // at this point we have the initial deploys done, now we need to transfer ownership // to the timelock contract - state, err = LoadOnchainState(e.Env) + state, err = changeset.LoadOnchainState(e.Env) require.NoError(t, err) // compose the transfer ownership and accept ownership changesets @@ -43,84 +43,10 @@ func Test_NewAcceptOwnershipChangeset(t *testing.T) { // note this doesn't have proposals. { Changeset: commonchangeset.WrapChangeSet(commonchangeset.TransferToMCMSWithTimelock), - Config: genTestTransferOwnershipConfig(e, allChains, state), + Config: testhelpers.GenTestTransferOwnershipConfig(e, allChains, state), }, }) require.NoError(t, err) - assertTimelockOwnership(t, e, allChains, state) -} - -func genTestTransferOwnershipConfig( - e DeployedEnv, - chains []uint64, - state CCIPOnChainState, -) commonchangeset.TransferToMCMSWithTimelockConfig { - var ( - timelocksPerChain = make(map[uint64]common.Address) - contracts = make(map[uint64][]common.Address) - ) - - // chain contracts - for _, chain := range chains { - timelocksPerChain[chain] = state.Chains[chain].Timelock.Address() - contracts[chain] = []common.Address{ - state.Chains[chain].OnRamp.Address(), - state.Chains[chain].OffRamp.Address(), - state.Chains[chain].FeeQuoter.Address(), - state.Chains[chain].NonceManager.Address(), - state.Chains[chain].RMNRemote.Address(), - state.Chains[chain].TestRouter.Address(), - state.Chains[chain].Router.Address(), - } - } - - // home chain - homeChainTimelockAddress := state.Chains[e.HomeChainSel].Timelock.Address() - timelocksPerChain[e.HomeChainSel] = homeChainTimelockAddress - contracts[e.HomeChainSel] = append(contracts[e.HomeChainSel], - state.Chains[e.HomeChainSel].CapabilityRegistry.Address(), - state.Chains[e.HomeChainSel].CCIPHome.Address(), - state.Chains[e.HomeChainSel].RMNHome.Address(), - ) - - return commonchangeset.TransferToMCMSWithTimelockConfig{ - ContractsByChain: contracts, - } -} - -// assertTimelockOwnership asserts that the ownership of the contracts has been transferred -// to the appropriate timelock contract on each chain. -func assertTimelockOwnership( - t *testing.T, - e DeployedEnv, - chains []uint64, - state CCIPOnChainState, -) { - // check that the ownership has been transferred correctly - for _, chain := range chains { - for _, contract := range []common.Address{ - state.Chains[chain].OnRamp.Address(), - state.Chains[chain].OffRamp.Address(), - state.Chains[chain].FeeQuoter.Address(), - state.Chains[chain].NonceManager.Address(), - state.Chains[chain].RMNRemote.Address(), - } { - owner, _, err := commonchangeset.LoadOwnableContract(contract, e.Env.Chains[chain].Client) - require.NoError(t, err) - require.Equal(t, state.Chains[chain].Timelock.Address(), owner) - } - } - - // check home chain contracts ownership - homeChainTimelockAddress := state.Chains[e.HomeChainSel].Timelock.Address() - for _, contract := range []common.Address{ - state.Chains[e.HomeChainSel].CapabilityRegistry.Address(), - state.Chains[e.HomeChainSel].CCIPHome.Address(), - state.Chains[e.HomeChainSel].RMNHome.Address(), - } { - owner, _, err := commonchangeset.LoadOwnableContract(contract, e.Env.Chains[e.HomeChainSel].Client) - require.NoError(t, err) - require.Equal(t, homeChainTimelockAddress, owner) - } + testhelpers.AssertTimelockOwnership(t, e, allChains, state) } diff --git a/deployment/ccip/changeset/cs_active_candidate_test.go b/deployment/ccip/changeset/cs_active_candidate_test.go index 7c50fbc77d0..a3a0505b950 100644 --- a/deployment/ccip/changeset/cs_active_candidate_test.go +++ b/deployment/ccip/changeset/cs_active_candidate_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "math/big" @@ -10,7 +10,9 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/internal" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/stretchr/testify/require" @@ -26,10 +28,10 @@ func Test_ActiveCandidate(t *testing.T) { // We want to have the active instance execute a few messages // and then setup a candidate instance. The candidate instance // should not be able to transmit anything until we make it active. - tenv, _ := NewMemoryEnvironment(t, - WithChains(2), - WithNodes(4)) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, + testhelpers.WithNumOfChains(2), + testhelpers.WithNumOfNodes(4)) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) // Deploy to all chains. @@ -41,9 +43,9 @@ func Test_ActiveCandidate(t *testing.T) { sourceState := state.Chains[source] tenv.Env, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateOnRampsDests), - Config: UpdateOnRampDestsConfig{ - UpdatesByChain: map[uint64]map[uint64]OnRampDestinationUpdate{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOnRampsDestsChangeset), + Config: changeset.UpdateOnRampDestsConfig{ + UpdatesByChain: map[uint64]map[uint64]changeset.OnRampDestinationUpdate{ source: { dest: { IsEnabled: true, @@ -54,35 +56,35 @@ func Test_ActiveCandidate(t *testing.T) { }, }, { - Changeset: commonchangeset.WrapChangeSet(UpdateFeeQuoterPricesCS), - Config: UpdateFeeQuoterPricesConfig{ - PricesByChain: map[uint64]FeeQuoterPriceUpdatePerSource{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterPricesChangeset), + Config: changeset.UpdateFeeQuoterPricesConfig{ + PricesByChain: map[uint64]changeset.FeeQuoterPriceUpdatePerSource{ source: { TokenPrices: map[common.Address]*big.Int{ - sourceState.LinkToken.Address(): DefaultLinkPrice, - sourceState.Weth9.Address(): DefaultWethPrice, + sourceState.LinkToken.Address(): testhelpers.DefaultLinkPrice, + sourceState.Weth9.Address(): testhelpers.DefaultWethPrice, }, GasPrices: map[uint64]*big.Int{ - dest: DefaultGasPrice, + dest: testhelpers.DefaultGasPrice, }, }, }, }, }, { - Changeset: commonchangeset.WrapChangeSet(UpdateFeeQuoterDests), - Config: UpdateFeeQuoterDestsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterDestsChangeset), + Config: changeset.UpdateFeeQuoterDestsConfig{ UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{ source: { - dest: DefaultFeeQuoterDestChainConfig(), + dest: changeset.DefaultFeeQuoterDestChainConfig(), }, }, }, }, { - Changeset: commonchangeset.WrapChangeSet(UpdateOffRampSources), - Config: UpdateOffRampSourcesConfig{ - UpdatesByChain: map[uint64]map[uint64]OffRampSourceUpdate{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOffRampSourcesChangeset), + Config: changeset.UpdateOffRampSourcesConfig{ + UpdatesByChain: map[uint64]map[uint64]changeset.OffRampSourceUpdate{ dest: { source: { IsEnabled: true, @@ -92,9 +94,9 @@ func Test_ActiveCandidate(t *testing.T) { }, }, { - Changeset: commonchangeset.WrapChangeSet(UpdateRouterRamps), - Config: UpdateRouterRampsConfig{ - UpdatesByChain: map[uint64]RouterUpdates{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateRouterRampsChangeset), + Config: changeset.UpdateRouterRampsConfig{ + UpdatesByChain: map[uint64]changeset.RouterUpdates{ // onRamp update on source chain source: { OnRampUpdates: map[uint64]bool{ @@ -125,17 +127,17 @@ func Test_ActiveCandidate(t *testing.T) { _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { Changeset: commonchangeset.WrapChangeSet(commonchangeset.TransferToMCMSWithTimelock), - Config: genTestTransferOwnershipConfig(tenv, allChains, state), + Config: testhelpers.GenTestTransferOwnershipConfig(tenv, allChains, state), }, }) require.NoError(t, err) - assertTimelockOwnership(t, tenv, allChains, state) + testhelpers.AssertTimelockOwnership(t, tenv, allChains, state) sendMsg := func() { latesthdr, err := tenv.Env.Chains[dest].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) block := latesthdr.Number.Uint64() - msgSentEvent := TestSendRequest(t, tenv.Env, state, source, dest, false, router.ClientEVM2AnyMessage{ + msgSentEvent := testhelpers.TestSendRequest(t, tenv.Env, state, source, dest, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, @@ -147,13 +149,13 @@ func Test_ActiveCandidate(t *testing.T) { startBlocks = map[uint64]*uint64{ dest: &block, } - expectedSeqNum = map[SourceDestPair]uint64{ + expectedSeqNum = map[testhelpers.SourceDestPair]uint64{ { SourceChainSelector: source, DestChainSelector: dest, }: msgSentEvent.SequenceNumber, } - expectedSeqNumExec = map[SourceDestPair][]uint64{ + expectedSeqNumExec = map[testhelpers.SourceDestPair][]uint64{ { SourceChainSelector: source, DestChainSelector: dest, @@ -162,8 +164,8 @@ func Test_ActiveCandidate(t *testing.T) { ) // Confirm execution of the message - ConfirmCommitForAllWithExpectedSeqNums(t, tenv.Env, state, expectedSeqNum, startBlocks) - ConfirmExecWithSeqNrsForAll(t, tenv.Env, state, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(t, tenv.Env, state, expectedSeqNum, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, tenv.Env, state, expectedSeqNumExec, startBlocks) } // send a message from source to dest and ensure that it gets executed @@ -188,30 +190,34 @@ func Test_ActiveCandidate(t *testing.T) { // Now we can add a candidate config, send another request, and observe behavior. // The candidate config should not be able to execute messages. - tokenConfig := NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) + tokenConfig := changeset.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(SetCandidateChangeset), - Config: SetCandidateChangesetConfig{ - SetCandidateConfigBase: SetCandidateConfigBase{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetCandidateChangeset), + Config: changeset.SetCandidateChangesetConfig{ + SetCandidateConfigBase: changeset.SetCandidateConfigBase{ HomeChainSelector: tenv.HomeChainSel, FeedChainSelector: tenv.FeedChainSel, - MCMS: &MCMSConfig{ + MCMS: &changeset.MCMSConfig{ MinDelay: 0, }, }, - PluginInfo: []SetCandidatePluginInfo{ + PluginInfo: []changeset.SetCandidatePluginInfo{ { // NOTE: this is technically not a new chain, but needed for validation. - OCRConfigPerRemoteChainSelector: map[uint64]CCIPOCRParams{ - dest: DefaultOCRParams(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9), nil, true, false), + OCRConfigPerRemoteChainSelector: map[uint64]changeset.CCIPOCRParams{ + dest: changeset.DeriveCCIPOCRParams( + changeset.WithDefaultCommitOffChainConfig(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9)), + ), }, PluginType: types.PluginTypeCCIPCommit, }, { // NOTE: this is technically not a new chain, but needed for validation. - OCRConfigPerRemoteChainSelector: map[uint64]CCIPOCRParams{ - dest: DefaultOCRParams(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9), nil, false, true), + OCRConfigPerRemoteChainSelector: map[uint64]changeset.CCIPOCRParams{ + dest: changeset.DeriveCCIPOCRParams( + changeset.WithDefaultExecuteOffChainConfig(nil), + ), }, PluginType: types.PluginTypeCCIPExec, }, diff --git a/deployment/ccip/changeset/cs_add_lane_test.go b/deployment/ccip/changeset/cs_add_lane_test.go index 4b9f1f8641f..18f86d98a68 100644 --- a/deployment/ccip/changeset/cs_add_lane_test.go +++ b/deployment/ccip/changeset/cs_add_lane_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -8,37 +8,39 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" ) func TestAddLanesWithTestRouter(t *testing.T) { t.Parallel() - e, _ := NewMemoryEnvironment(t) + e, _ := testhelpers.NewMemoryEnvironment(t) // Here we have CR + nodes set up, but no CCIP contracts deployed. - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) selectors := e.Env.AllChainSelectors() chain1, chain2 := selectors[0], selectors[1] - AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, chain1, chain2, true) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, chain1, chain2, true) // Need to keep track of the block number for each chain so that event subscription can be done from that block. startBlocks := make(map[uint64]*uint64) // Send a message from each chain to every other chain. - expectedSeqNumExec := make(map[SourceDestPair][]uint64) + expectedSeqNumExec := make(map[testhelpers.SourceDestPair][]uint64) latesthdr, err := e.Env.Chains[chain2].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) block := latesthdr.Number.Uint64() startBlocks[chain2] = &block - msgSentEvent := TestSendRequest(t, e.Env, state, chain1, chain2, true, router.ClientEVM2AnyMessage{ + msgSentEvent := testhelpers.TestSendRequest(t, e.Env, state, chain1, chain2, true, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[chain2].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - expectedSeqNumExec[SourceDestPair{ + expectedSeqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: chain1, DestChainSelector: chain2, }] = []uint64{msgSentEvent.SequenceNumber} - ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) } diff --git a/deployment/ccip/changeset/cs_ccip_home.go b/deployment/ccip/changeset/cs_ccip_home.go index 12f488d1cfd..ef173e5ed07 100644 --- a/deployment/ccip/changeset/cs_ccip_home.go +++ b/deployment/ccip/changeset/cs_ccip_home.go @@ -39,7 +39,7 @@ var ( _ deployment.ChangeSet[PromoteCandidateChangesetConfig] = PromoteCandidateChangeset _ deployment.ChangeSet[SetCandidateChangesetConfig] = SetCandidateChangeset _ deployment.ChangeSet[RevokeCandidateChangesetConfig] = RevokeCandidateChangeset - _ deployment.ChangeSet[UpdateChainConfigConfig] = UpdateChainConfig + _ deployment.ChangeSet[UpdateChainConfigConfig] = UpdateChainConfigChangeset ) type tokenInfo interface { @@ -171,14 +171,66 @@ func (c CCIPOCRParams) Validate(selector uint64, feedChainSel uint64, state CCIP return nil } -// DefaultOCRParams returns the default OCR parameters for a chain, -// except for a few values which must be parameterized (passed as arguments). -func DefaultOCRParams( - feedChainSel uint64, - tokenInfo map[ccipocr3.UnknownEncodedAddress]pluginconfig.TokenInfo, - tokenDataObservers []pluginconfig.TokenDataObserverConfig, - commit bool, - exec bool, +type CCIPOCROpts func(params *CCIPOCRParams) + +// WithOCRParamOverride can be used if you want to override the default OCR parameters with your custom function. +func WithOCRParamOverride(override func(params *CCIPOCRParams)) CCIPOCROpts { + return func(params *CCIPOCRParams) { + if override != nil { + override(params) + } + } +} + +// WithDefaultCommitOffChainConfig can be used to add token info to the existing commit off-chain config. If no commit off-chain config is set, it will be created with default values. +func WithDefaultCommitOffChainConfig(feedChainSel uint64, tokenInfo map[ccipocr3.UnknownEncodedAddress]pluginconfig.TokenInfo) CCIPOCROpts { + return func(params *CCIPOCRParams) { + if params.CommitOffChainConfig == nil { + params.CommitOffChainConfig = &pluginconfig.CommitOffchainConfig{ + RemoteGasPriceBatchWriteFrequency: *config.MustNewDuration(internal.RemoteGasPriceBatchWriteFrequency), + TokenPriceBatchWriteFrequency: *config.MustNewDuration(internal.TokenPriceBatchWriteFrequency), + TokenInfo: tokenInfo, + PriceFeedChainSelector: ccipocr3.ChainSelector(feedChainSel), + NewMsgScanBatchSize: merklemulti.MaxNumberTreeLeaves, + MaxReportTransmissionCheckAttempts: 5, + RMNEnabled: os.Getenv("ENABLE_RMN") == "true", // only enabled in manual test + RMNSignaturesTimeout: 30 * time.Minute, + MaxMerkleTreeSize: merklemulti.MaxNumberTreeLeaves, + SignObservationPrefix: "chainlink ccip 1.6 rmn observation", + } + } else { + if params.CommitOffChainConfig.TokenInfo == nil { + params.CommitOffChainConfig.TokenInfo = make(map[ccipocr3.UnknownEncodedAddress]pluginconfig.TokenInfo) + } + for k, v := range tokenInfo { + params.CommitOffChainConfig.TokenInfo[k] = v + } + } + } +} + +// WithDefaultExecuteOffChainConfig can be used to add token data observers to the execute off-chain config. If no execute off-chain config is set, it will be created with default values. +func WithDefaultExecuteOffChainConfig(tokenDataObservers []pluginconfig.TokenDataObserverConfig) CCIPOCROpts { + return func(params *CCIPOCRParams) { + if params.ExecuteOffChainConfig == nil { + params.ExecuteOffChainConfig = &pluginconfig.ExecuteOffchainConfig{ + BatchGasLimit: internal.BatchGasLimit, + RelativeBoostPerWaitHour: internal.RelativeBoostPerWaitHour, + InflightCacheExpiry: *config.MustNewDuration(internal.InflightCacheExpiry), + RootSnoozeTime: *config.MustNewDuration(internal.RootSnoozeTime), + MessageVisibilityInterval: *config.MustNewDuration(internal.FirstBlockAge), + BatchingStrategyID: internal.BatchingStrategyID, + TokenDataObservers: tokenDataObservers, + } + } else if tokenDataObservers != nil { + params.ExecuteOffChainConfig.TokenDataObservers = append(params.ExecuteOffChainConfig.TokenDataObservers, tokenDataObservers...) + } + } +} + +// DeriveCCIPOCRParams derives the default OCR parameters for a chain, with the option to override them. +func DeriveCCIPOCRParams( + opts ...CCIPOCROpts, ) CCIPOCRParams { params := CCIPOCRParams{ OCRParameters: commontypes.OCRParameters{ @@ -196,30 +248,8 @@ func DefaultOCRParams( MaxDurationShouldTransmitAcceptedReport: internal.MaxDurationShouldTransmitAcceptedReport, }, } - if exec { - params.ExecuteOffChainConfig = &pluginconfig.ExecuteOffchainConfig{ - BatchGasLimit: internal.BatchGasLimit, - RelativeBoostPerWaitHour: internal.RelativeBoostPerWaitHour, - InflightCacheExpiry: *config.MustNewDuration(internal.InflightCacheExpiry), - RootSnoozeTime: *config.MustNewDuration(internal.RootSnoozeTime), - MessageVisibilityInterval: *config.MustNewDuration(internal.FirstBlockAge), - BatchingStrategyID: internal.BatchingStrategyID, - TokenDataObservers: tokenDataObservers, - } - } - if commit { - params.CommitOffChainConfig = &pluginconfig.CommitOffchainConfig{ - RemoteGasPriceBatchWriteFrequency: *config.MustNewDuration(internal.RemoteGasPriceBatchWriteFrequency), - TokenPriceBatchWriteFrequency: *config.MustNewDuration(internal.TokenPriceBatchWriteFrequency), - TokenInfo: tokenInfo, - PriceFeedChainSelector: ccipocr3.ChainSelector(feedChainSel), - NewMsgScanBatchSize: merklemulti.MaxNumberTreeLeaves, - MaxReportTransmissionCheckAttempts: 5, - RMNEnabled: os.Getenv("ENABLE_RMN") == "true", // only enabled in manual test - RMNSignaturesTimeout: 30 * time.Minute, - MaxMerkleTreeSize: merklemulti.MaxNumberTreeLeaves, - SignObservationPrefix: "chainlink ccip 1.6 rmn observation", - } + for _, opt := range opts { + opt(¶ms) } return params } @@ -1217,7 +1247,7 @@ func (c UpdateChainConfigConfig) Validate(e deployment.Environment) error { return nil } -func UpdateChainConfig(e deployment.Environment, cfg UpdateChainConfigConfig) (deployment.ChangesetOutput, error) { +func UpdateChainConfigChangeset(e deployment.Environment, cfg UpdateChainConfigConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("%w: %w", deployment.ErrInvalidConfig, err) } diff --git a/deployment/ccip/changeset/cs_ccip_home_test.go b/deployment/ccip/changeset/cs_ccip_home_test.go index 96220477384..73fd921d503 100644 --- a/deployment/ccip/changeset/cs_ccip_home_test.go +++ b/deployment/ccip/changeset/cs_ccip_home_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "math/big" @@ -15,7 +15,9 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/internal" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types" "github.com/smartcontractkit/chainlink/v2/core/logger" @@ -26,8 +28,8 @@ import ( ) func TestInvalidOCR3Params(t *testing.T) { - e, _ := NewMemoryEnvironment(t, - WithPrerequisiteDeployment(nil)) + e, _ := testhelpers.NewMemoryEnvironment(t, + testhelpers.WithPrerequisiteDeploymentOnly(nil)) chain1 := e.Env.AllChainSelectors()[0] envNodes, err := deployment.NodeInfo(e.Env.NodeIDs, e.Env.Offchain) require.NoError(t, err) @@ -35,20 +37,20 @@ func TestInvalidOCR3Params(t *testing.T) { // no proposals to be made, timelock can be passed as nil here e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(DeployHomeChain), - Config: DeployHomeChainConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployHomeChainChangeset), + Config: changeset.DeployHomeChainConfig{ HomeChainSel: e.HomeChainSel, - RMNDynamicConfig: NewTestRMNDynamicConfig(), - RMNStaticConfig: NewTestRMNStaticConfig(), - NodeOperators: NewTestNodeOperator(e.Env.Chains[e.HomeChainSel].DeployerKey.From), + RMNDynamicConfig: testhelpers.NewTestRMNDynamicConfig(), + RMNStaticConfig: testhelpers.NewTestRMNStaticConfig(), + NodeOperators: testhelpers.NewTestNodeOperator(e.Env.Chains[e.HomeChainSel].DeployerKey.From), NodeP2PIDsPerNodeOpAdmin: map[string][][32]byte{ - TestNodeOperator: envNodes.NonBootstraps().PeerIDs(), + testhelpers.TestNodeOperator: envNodes.NonBootstraps().PeerIDs(), }, }, }, { - Changeset: commonchangeset.WrapChangeSet(DeployChainContracts), - Config: DeployChainContractsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployChainContractsChangeset), + Config: changeset.DeployChainContractsConfig{ ChainSelectors: []uint64{chain1}, HomeChainSelector: e.HomeChainSel, }, @@ -56,11 +58,14 @@ func TestInvalidOCR3Params(t *testing.T) { }) require.NoError(t, err) - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) nodes, err := deployment.NodeInfo(e.Env.NodeIDs, e.Env.Offchain) require.NoError(t, err) - params := DefaultOCRParams(e.FeedChainSel, nil, nil, true, true) + params := changeset.DeriveCCIPOCRParams( + changeset.WithDefaultCommitOffChainConfig(e.FeedChainSel, nil), + changeset.WithDefaultExecuteOffChainConfig(nil), + ) // tweak params to have invalid config // make DeltaRound greater than DeltaProgress params.OCRParameters.DeltaRound = params.OCRParameters.DeltaProgress + time.Duration(1) @@ -97,10 +102,10 @@ func Test_PromoteCandidate(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { ctx := testcontext.Get(t) - tenv, _ := NewMemoryEnvironment(t, - WithChains(2), - WithNodes(4)) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, + testhelpers.WithNumOfChains(2), + testhelpers.WithNumOfNodes(4)) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) // Deploy to all chains. @@ -132,9 +137,9 @@ func Test_PromoteCandidate(t *testing.T) { require.NoError(t, err) require.NotEqual(t, [32]byte{}, ActiveDigestExecBefore) - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } @@ -146,10 +151,10 @@ func Test_PromoteCandidate(t *testing.T) { }, }, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(PromoteCandidateChangeset), - Config: PromoteCandidateChangesetConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.PromoteCandidateChangeset), + Config: changeset.PromoteCandidateChangesetConfig{ HomeChainSelector: tenv.HomeChainSel, - PluginInfo: []PromoteCandidatePluginInfo{ + PluginInfo: []changeset.PromoteCandidatePluginInfo{ { RemoteChainSelectors: []uint64{dest}, PluginType: types.PluginTypeCCIPCommit, @@ -193,10 +198,10 @@ func Test_SetCandidate(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { ctx := testcontext.Get(t) - tenv, _ := NewMemoryEnvironment(t, - WithChains(2), - WithNodes(4)) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, + testhelpers.WithNumOfChains(2), + testhelpers.WithNumOfNodes(4)) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) // Deploy to all chains. @@ -227,13 +232,13 @@ func Test_SetCandidate(t *testing.T) { require.NoError(t, err) require.Equal(t, [32]byte{}, candidateDigestExecBefore) - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } - tokenConfig := NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) + tokenConfig := changeset.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) _, err = commonchangeset.ApplyChangesets(t, tenv.Env, map[uint64]*proposalutils.TimelockExecutionContracts{ tenv.HomeChainSel: { Timelock: state.Chains[tenv.HomeChainSel].Timelock, @@ -241,23 +246,27 @@ func Test_SetCandidate(t *testing.T) { }, }, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(SetCandidateChangeset), - Config: SetCandidateChangesetConfig{ - SetCandidateConfigBase: SetCandidateConfigBase{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetCandidateChangeset), + Config: changeset.SetCandidateChangesetConfig{ + SetCandidateConfigBase: changeset.SetCandidateConfigBase{ HomeChainSelector: tenv.HomeChainSel, FeedChainSelector: tenv.FeedChainSel, MCMS: mcmsConfig, }, - PluginInfo: []SetCandidatePluginInfo{ + PluginInfo: []changeset.SetCandidatePluginInfo{ { - OCRConfigPerRemoteChainSelector: map[uint64]CCIPOCRParams{ - dest: DefaultOCRParams(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9), nil, true, false), + OCRConfigPerRemoteChainSelector: map[uint64]changeset.CCIPOCRParams{ + dest: changeset.DeriveCCIPOCRParams( + changeset.WithDefaultCommitOffChainConfig(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9)), + ), }, PluginType: types.PluginTypeCCIPCommit, }, { - OCRConfigPerRemoteChainSelector: map[uint64]CCIPOCRParams{ - dest: DefaultOCRParams(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9), nil, false, true), + OCRConfigPerRemoteChainSelector: map[uint64]changeset.CCIPOCRParams{ + dest: changeset.DeriveCCIPOCRParams( + changeset.WithDefaultExecuteOffChainConfig(nil), + ), }, PluginType: types.PluginTypeCCIPExec, }, @@ -302,10 +311,10 @@ func Test_RevokeCandidate(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { ctx := testcontext.Get(t) - tenv, _ := NewMemoryEnvironment(t, - WithChains(2), - WithNodes(4)) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, + testhelpers.WithNumOfChains(2), + testhelpers.WithNumOfNodes(4)) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) // Deploy to all chains. @@ -336,13 +345,13 @@ func Test_RevokeCandidate(t *testing.T) { require.NoError(t, err) require.Equal(t, [32]byte{}, candidateDigestExecBefore) - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } - tokenConfig := NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) + tokenConfig := changeset.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) _, err = commonchangeset.ApplyChangesets(t, tenv.Env, map[uint64]*proposalutils.TimelockExecutionContracts{ tenv.HomeChainSel: { Timelock: state.Chains[tenv.HomeChainSel].Timelock, @@ -350,23 +359,27 @@ func Test_RevokeCandidate(t *testing.T) { }, }, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(SetCandidateChangeset), - Config: SetCandidateChangesetConfig{ - SetCandidateConfigBase: SetCandidateConfigBase{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetCandidateChangeset), + Config: changeset.SetCandidateChangesetConfig{ + SetCandidateConfigBase: changeset.SetCandidateConfigBase{ HomeChainSelector: tenv.HomeChainSel, FeedChainSelector: tenv.FeedChainSel, MCMS: mcmsConfig, }, - PluginInfo: []SetCandidatePluginInfo{ + PluginInfo: []changeset.SetCandidatePluginInfo{ { - OCRConfigPerRemoteChainSelector: map[uint64]CCIPOCRParams{ - dest: DefaultOCRParams(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9), nil, true, true), + OCRConfigPerRemoteChainSelector: map[uint64]changeset.CCIPOCRParams{ + dest: changeset.DeriveCCIPOCRParams( + changeset.WithDefaultCommitOffChainConfig(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9)), + ), }, PluginType: types.PluginTypeCCIPCommit, }, { - OCRConfigPerRemoteChainSelector: map[uint64]CCIPOCRParams{ - dest: DefaultOCRParams(tenv.FeedChainSel, tokenConfig.GetTokenInfo(logger.TestLogger(t), state.Chains[dest].LinkToken, state.Chains[dest].Weth9), nil, true, true), + OCRConfigPerRemoteChainSelector: map[uint64]changeset.CCIPOCRParams{ + dest: changeset.DeriveCCIPOCRParams( + changeset.WithDefaultExecuteOffChainConfig(nil), + ), }, PluginType: types.PluginTypeCCIPExec, }, @@ -400,8 +413,8 @@ func Test_RevokeCandidate(t *testing.T) { }, }, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(RevokeCandidateChangeset), - Config: RevokeCandidateChangesetConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.RevokeCandidateChangeset), + Config: changeset.RevokeCandidateChangesetConfig{ HomeChainSelector: tenv.HomeChainSel, RemoteChainSelector: dest, PluginType: types.PluginTypeCCIPCommit, @@ -409,8 +422,8 @@ func Test_RevokeCandidate(t *testing.T) { }, }, { - Changeset: commonchangeset.WrapChangeSet(RevokeCandidateChangeset), - Config: RevokeCandidateChangesetConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.RevokeCandidateChangeset), + Config: changeset.RevokeCandidateChangesetConfig{ HomeChainSelector: tenv.HomeChainSel, RemoteChainSelector: dest, PluginType: types.PluginTypeCCIPExec, @@ -438,8 +451,8 @@ func Test_RevokeCandidate(t *testing.T) { func transferToTimelock( t *testing.T, - tenv DeployedEnv, - state CCIPOnChainState, + tenv testhelpers.DeployedEnv, + state changeset.CCIPOnChainState, source, dest uint64) { // Transfer ownership to timelock so that we can promote the zero digest later down the line. @@ -459,11 +472,11 @@ func transferToTimelock( }, []commonchangeset.ChangesetApplication{ { Changeset: commonchangeset.WrapChangeSet(commonchangeset.TransferToMCMSWithTimelock), - Config: genTestTransferOwnershipConfig(tenv, []uint64{source, dest}, state), + Config: testhelpers.GenTestTransferOwnershipConfig(tenv, []uint64{source, dest}, state), }, }) require.NoError(t, err) - assertTimelockOwnership(t, tenv, []uint64{source, dest}, state) + testhelpers.AssertTimelockOwnership(t, tenv, []uint64{source, dest}, state) } func Test_UpdateChainConfigs(t *testing.T) { @@ -481,8 +494,8 @@ func Test_UpdateChainConfigs(t *testing.T) { }, } { t.Run(tc.name, func(t *testing.T) { - tenv, _ := NewMemoryEnvironment(t, WithChains(3)) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) allChains := maps.Keys(tenv.Env.Chains) @@ -500,9 +513,9 @@ func Test_UpdateChainConfigs(t *testing.T) { require.NoError(t, err) assert.NotZero(t, otherChainConfig.FChain) - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } @@ -513,11 +526,11 @@ func Test_UpdateChainConfigs(t *testing.T) { }, }, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateChainConfig), - Config: UpdateChainConfigConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateChainConfigChangeset), + Config: changeset.UpdateChainConfigConfig{ HomeChainSelector: tenv.HomeChainSel, RemoteChainRemoves: []uint64{otherChain}, - RemoteChainAdds: make(map[uint64]ChainConfig), + RemoteChainAdds: make(map[uint64]changeset.ChainConfig), MCMS: mcmsConfig, }, }, @@ -537,11 +550,11 @@ func Test_UpdateChainConfigs(t *testing.T) { }, }, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateChainConfig), - Config: UpdateChainConfigConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateChainConfigChangeset), + Config: changeset.UpdateChainConfigConfig{ HomeChainSelector: tenv.HomeChainSel, RemoteChainRemoves: []uint64{}, - RemoteChainAdds: map[uint64]ChainConfig{ + RemoteChainAdds: map[uint64]changeset.ChainConfig{ otherChain: { EncodableChainConfig: chainconfig.ChainConfig{ GasPriceDeviationPPB: cciptypes.BigInt{Int: big.NewInt(internal.GasPriceDeviationPPB)}, diff --git a/deployment/ccip/changeset/cs_chain_contracts.go b/deployment/ccip/changeset/cs_chain_contracts.go index 8b50aa2fd3c..64e7ca295d7 100644 --- a/deployment/ccip/changeset/cs_chain_contracts.go +++ b/deployment/ccip/changeset/cs_chain_contracts.go @@ -31,13 +31,13 @@ import ( ) var ( - _ deployment.ChangeSet[UpdateOnRampDestsConfig] = UpdateOnRampsDests - _ deployment.ChangeSet[UpdateOffRampSourcesConfig] = UpdateOffRampSources - _ deployment.ChangeSet[UpdateRouterRampsConfig] = UpdateRouterRamps - _ deployment.ChangeSet[UpdateFeeQuoterDestsConfig] = UpdateFeeQuoterDests - _ deployment.ChangeSet[SetOCR3OffRampConfig] = SetOCR3OffRamp - _ deployment.ChangeSet[UpdateFeeQuoterPricesConfig] = UpdateFeeQuoterPricesCS - _ deployment.ChangeSet[UpdateNonceManagerConfig] = UpdateNonceManagersCS + _ deployment.ChangeSet[UpdateOnRampDestsConfig] = UpdateOnRampsDestsChangeset + _ deployment.ChangeSet[UpdateOffRampSourcesConfig] = UpdateOffRampSourcesChangeset + _ deployment.ChangeSet[UpdateRouterRampsConfig] = UpdateRouterRampsChangeset + _ deployment.ChangeSet[UpdateFeeQuoterDestsConfig] = UpdateFeeQuoterDestsChangeset + _ deployment.ChangeSet[SetOCR3OffRampConfig] = SetOCR3OffRampChangeset + _ deployment.ChangeSet[UpdateFeeQuoterPricesConfig] = UpdateFeeQuoterPricesChangeset + _ deployment.ChangeSet[UpdateNonceManagerConfig] = UpdateNonceManagersChangeset ) type UpdateNonceManagerConfig struct { @@ -107,7 +107,7 @@ func (cfg UpdateNonceManagerConfig) Validate(e deployment.Environment) error { return nil } -func UpdateNonceManagersCS(e deployment.Environment, cfg UpdateNonceManagerConfig) (deployment.ChangesetOutput, error) { +func UpdateNonceManagersChangeset(e deployment.Environment, cfg UpdateNonceManagerConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } @@ -272,10 +272,10 @@ func (cfg UpdateOnRampDestsConfig) Validate(e deployment.Environment) error { return nil } -// UpdateOnRampsDests updates the onramp destinations for each onramp +// UpdateOnRampsDestsChangeset updates the onramp destinations for each onramp // in the chains specified. Multichain support is important - consider when we add a new chain // and need to update the onramp destinations for all chains to support the new chain. -func UpdateOnRampsDests(e deployment.Environment, cfg UpdateOnRampDestsConfig) (deployment.ChangesetOutput, error) { +func UpdateOnRampsDestsChangeset(e deployment.Environment, cfg UpdateOnRampDestsConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } @@ -437,7 +437,7 @@ func (cfg UpdateFeeQuoterPricesConfig) Validate(e deployment.Environment) error return nil } -func UpdateFeeQuoterPricesCS(e deployment.Environment, cfg UpdateFeeQuoterPricesConfig) (deployment.ChangesetOutput, error) { +func UpdateFeeQuoterPricesChangeset(e deployment.Environment, cfg UpdateFeeQuoterPricesConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } @@ -559,7 +559,7 @@ func (cfg UpdateFeeQuoterDestsConfig) Validate(e deployment.Environment) error { return nil } -func UpdateFeeQuoterDests(e deployment.Environment, cfg UpdateFeeQuoterDestsConfig) (deployment.ChangesetOutput, error) { +func UpdateFeeQuoterDestsChangeset(e deployment.Environment, cfg UpdateFeeQuoterDestsConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } @@ -680,8 +680,8 @@ func (cfg UpdateOffRampSourcesConfig) Validate(e deployment.Environment) error { return nil } -// UpdateOffRampSources updates the offramp sources for each offramp. -func UpdateOffRampSources(e deployment.Environment, cfg UpdateOffRampSourcesConfig) (deployment.ChangesetOutput, error) { +// UpdateOffRampSourcesChangeset updates the offramp sources for each offramp. +func UpdateOffRampSourcesChangeset(e deployment.Environment, cfg UpdateOffRampSourcesConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } @@ -834,14 +834,14 @@ func (cfg UpdateRouterRampsConfig) Validate(e deployment.Environment) error { return nil } -// UpdateRouterRamps updates the on/offramps +// UpdateRouterRampsChangeset updates the on/offramps // in either the router or test router for a series of chains. Use cases include: // - Ramp upgrade. After deploying new ramps you can enable them on the test router and // ensure it works e2e. Then enable the ramps on the real router. // - New chain support. When adding a new chain, you can enable the new destination // on all chains to support the new chain through the test router first. Once tested, // Enable the new destination on the real router. -func UpdateRouterRamps(e deployment.Environment, cfg UpdateRouterRampsConfig) (deployment.ChangesetOutput, error) { +func UpdateRouterRampsChangeset(e deployment.Environment, cfg UpdateRouterRampsConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } @@ -964,13 +964,13 @@ func (c SetOCR3OffRampConfig) Validate(e deployment.Environment) error { return nil } -// SetOCR3OffRamp will set the OCR3 offramp for the given chain. +// SetOCR3OffRampChangeset will set the OCR3 offramp for the given chain. // to the active configuration on CCIPHome. This // is used to complete the candidate->active promotion cycle, it's // run after the candidate is confirmed to be working correctly. // Multichain is especially helpful for NOP rotations where we have // to touch all the chain to change signers. -func SetOCR3OffRamp(e deployment.Environment, cfg SetOCR3OffRampConfig) (deployment.ChangesetOutput, error) { +func SetOCR3OffRampChangeset(e deployment.Environment, cfg SetOCR3OffRampConfig) (deployment.ChangesetOutput, error) { if err := cfg.Validate(e); err != nil { return deployment.ChangesetOutput{}, err } diff --git a/deployment/ccip/changeset/cs_chain_contracts_test.go b/deployment/ccip/changeset/cs_chain_contracts_test.go index 544362a1b1e..7b7f420e531 100644 --- a/deployment/ccip/changeset/cs_chain_contracts_test.go +++ b/deployment/ccip/changeset/cs_chain_contracts_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -10,6 +10,8 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" ) @@ -32,8 +34,8 @@ func TestUpdateOnRampsDests(t *testing.T) { ctx := testcontext.Get(t) // Default env just has 2 chains with all contracts // deployed but no lanes. - tenv, _ := NewMemoryEnvironment(t) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) allChains := maps.Keys(tenv.Env.Chains) @@ -45,17 +47,17 @@ func TestUpdateOnRampsDests(t *testing.T) { transferToTimelock(t, tenv, state, source, dest) } - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateOnRampsDests), - Config: UpdateOnRampDestsConfig{ - UpdatesByChain: map[uint64]map[uint64]OnRampDestinationUpdate{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOnRampsDestsChangeset), + Config: changeset.UpdateOnRampDestsConfig{ + UpdatesByChain: map[uint64]map[uint64]changeset.OnRampDestinationUpdate{ source: { dest: { IsEnabled: true, @@ -106,8 +108,8 @@ func TestUpdateOffRampsSources(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { ctx := testcontext.Get(t) - tenv, _ := NewMemoryEnvironment(t) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) allChains := maps.Keys(tenv.Env.Chains) @@ -119,17 +121,17 @@ func TestUpdateOffRampsSources(t *testing.T) { transferToTimelock(t, tenv, state, source, dest) } - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateOffRampSources), - Config: UpdateOffRampSourcesConfig{ - UpdatesByChain: map[uint64]map[uint64]OffRampSourceUpdate{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOffRampSourcesChangeset), + Config: changeset.UpdateOffRampSourcesConfig{ + UpdatesByChain: map[uint64]map[uint64]changeset.OffRampSourceUpdate{ source: { dest: { IsEnabled: true, @@ -176,8 +178,8 @@ func TestUpdateFQDests(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { ctx := testcontext.Get(t) - tenv, _ := NewMemoryEnvironment(t) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) allChains := maps.Keys(tenv.Env.Chains) @@ -189,20 +191,20 @@ func TestUpdateFQDests(t *testing.T) { transferToTimelock(t, tenv, state, source, dest) } - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } - fqCfg1 := DefaultFeeQuoterDestChainConfig() - fqCfg2 := DefaultFeeQuoterDestChainConfig() + fqCfg1 := changeset.DefaultFeeQuoterDestChainConfig() + fqCfg2 := changeset.DefaultFeeQuoterDestChainConfig() fqCfg2.DestGasOverhead = 1000 _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateFeeQuoterDests), - Config: UpdateFeeQuoterDestsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterDestsChangeset), + Config: changeset.UpdateFeeQuoterDestsConfig{ UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{ source: { dest: fqCfg1, @@ -220,10 +222,10 @@ func TestUpdateFQDests(t *testing.T) { // Assert the fq configuration is as we expect. source2destCfg, err := state.Chains[source].FeeQuoter.GetDestChainConfig(&bind.CallOpts{Context: ctx}, dest) require.NoError(t, err) - AssertEqualFeeConfig(t, fqCfg1, source2destCfg) + testhelpers.AssertEqualFeeConfig(t, fqCfg1, source2destCfg) dest2sourceCfg, err := state.Chains[dest].FeeQuoter.GetDestChainConfig(&bind.CallOpts{Context: ctx}, source) require.NoError(t, err) - AssertEqualFeeConfig(t, fqCfg2, dest2sourceCfg) + testhelpers.AssertEqualFeeConfig(t, fqCfg2, dest2sourceCfg) }) } } @@ -244,8 +246,8 @@ func TestUpdateRouterRamps(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { ctx := testcontext.Get(t) - tenv, _ := NewMemoryEnvironment(t) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) allChains := maps.Keys(tenv.Env.Chains) @@ -257,9 +259,9 @@ func TestUpdateRouterRamps(t *testing.T) { transferToTimelock(t, tenv, state, source, dest) } - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } @@ -267,10 +269,10 @@ func TestUpdateRouterRamps(t *testing.T) { // Updates test router. _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateRouterRamps), - Config: UpdateRouterRampsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateRouterRampsChangeset), + Config: changeset.UpdateRouterRampsConfig{ TestRouter: true, - UpdatesByChain: map[uint64]RouterUpdates{ + UpdatesByChain: map[uint64]changeset.RouterUpdates{ source: { OffRampUpdates: map[uint64]bool{ dest: true, @@ -320,8 +322,8 @@ func TestUpdateNonceManagersCS(t *testing.T) { }, } { t.Run(tc.name, func(t *testing.T) { - tenv, _ := NewMemoryEnvironment(t) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) allChains := maps.Keys(tenv.Env.Chains) @@ -333,18 +335,18 @@ func TestUpdateNonceManagersCS(t *testing.T) { transferToTimelock(t, tenv, state, source, dest) } - var mcmsConfig *MCMSConfig + var mcmsConfig *changeset.MCMSConfig if tc.mcmsEnabled { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } _, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(UpdateNonceManagersCS), - Config: UpdateNonceManagerConfig{ - UpdatesByChain: map[uint64]NonceManagerUpdate{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateNonceManagersChangeset), + Config: changeset.UpdateNonceManagerConfig{ + UpdatesByChain: map[uint64]changeset.NonceManagerUpdate{ source: { RemovedAuthCallers: []common.Address{state.Chains[source].OnRamp.Address()}, }, diff --git a/deployment/ccip/changeset/cs_deploy_chain.go b/deployment/ccip/changeset/cs_deploy_chain.go index 175498ba2cf..0cdc2327ca3 100644 --- a/deployment/ccip/changeset/cs_deploy_chain.go +++ b/deployment/ccip/changeset/cs_deploy_chain.go @@ -23,18 +23,18 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" ) -var _ deployment.ChangeSet[DeployChainContractsConfig] = DeployChainContracts +var _ deployment.ChangeSet[DeployChainContractsConfig] = DeployChainContractsChangeset -// DeployChainContracts deploys all new CCIP v1.6 or later contracts for the given chains. +// DeployChainContractsChangeset deploys all new CCIP v1.6 or later contracts for the given chains. // It returns the new addresses for the contracts. -// DeployChainContracts is idempotent. If there is an error, it will return the successfully deployed addresses and the error so that the caller can call the +// DeployChainContractsChangeset is idempotent. If there is an error, it will return the successfully deployed addresses and the error so that the caller can call the // changeset again with the same input to retry the failed deployment. // Caller should update the environment's address book with the returned addresses. // Points to note : // In case of migrating from legacy ccip to 1.6, the previous RMN address should be set while deploying RMNRemote. // if there is no existing RMN address found, RMNRemote will be deployed with 0x0 address for previous RMN address // which will set RMN to 0x0 address immutably in RMNRemote. -func DeployChainContracts(env deployment.Environment, c DeployChainContractsConfig) (deployment.ChangesetOutput, error) { +func DeployChainContractsChangeset(env deployment.Environment, c DeployChainContractsConfig) (deployment.ChangesetOutput, error) { if err := c.Validate(); err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("invalid DeployChainContractsConfig: %w", err) } diff --git a/deployment/ccip/changeset/cs_deploy_chain_test.go b/deployment/ccip/changeset/cs_deploy_chain_test.go index 1f77be3ca5a..c579b075b70 100644 --- a/deployment/ccip/changeset/cs_deploy_chain_test.go +++ b/deployment/ccip/changeset/cs_deploy_chain_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "encoding/json" @@ -9,6 +9,8 @@ import ( "go.uber.org/zap/zapcore" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" @@ -33,20 +35,20 @@ func TestDeployChainContractsChangeset(t *testing.T) { for _, chain := range e.AllChainSelectors() { cfg[chain] = proposalutils.SingleGroupTimelockConfig(t) } - var prereqCfg []DeployPrerequisiteConfigPerChain + prereqCfg := make([]changeset.DeployPrerequisiteConfigPerChain, 0) for _, chain := range e.AllChainSelectors() { - prereqCfg = append(prereqCfg, DeployPrerequisiteConfigPerChain{ + prereqCfg = append(prereqCfg, changeset.DeployPrerequisiteConfigPerChain{ ChainSelector: chain, }) } e, err = commonchangeset.ApplyChangesets(t, e, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(DeployHomeChain), - Config: DeployHomeChainConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployHomeChainChangeset), + Config: changeset.DeployHomeChainConfig{ HomeChainSel: homeChainSel, - RMNStaticConfig: NewTestRMNStaticConfig(), - RMNDynamicConfig: NewTestRMNDynamicConfig(), - NodeOperators: NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), + RMNStaticConfig: testhelpers.NewTestRMNStaticConfig(), + RMNDynamicConfig: testhelpers.NewTestRMNDynamicConfig(), + NodeOperators: testhelpers.NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), NodeP2PIDsPerNodeOpAdmin: map[string][][32]byte{ "NodeOperator": p2pIds, }, @@ -61,14 +63,14 @@ func TestDeployChainContractsChangeset(t *testing.T) { Config: cfg, }, { - Changeset: commonchangeset.WrapChangeSet(DeployPrerequisites), - Config: DeployPrerequisiteConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployPrerequisitesChangeset), + Config: changeset.DeployPrerequisiteConfig{ Configs: prereqCfg, }, }, { - Changeset: commonchangeset.WrapChangeSet(DeployChainContracts), - Config: DeployChainContractsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployChainContractsChangeset), + Config: changeset.DeployChainContractsConfig{ ChainSelectors: selectors, HomeChainSelector: homeChainSel, }, @@ -77,7 +79,7 @@ func TestDeployChainContractsChangeset(t *testing.T) { require.NoError(t, err) // load onchain state - state, err := LoadOnchainState(e) + state, err := changeset.LoadOnchainState(e) require.NoError(t, err) // verify all contracts populated @@ -101,9 +103,9 @@ func TestDeployChainContractsChangeset(t *testing.T) { func TestDeployCCIPContracts(t *testing.T) { t.Parallel() - e, _ := NewMemoryEnvironment(t) + e, _ := testhelpers.NewMemoryEnvironment(t) // Deploy all the CCIP contracts. - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) snap, err := state.View(e.Env.AllChainSelectors()) require.NoError(t, err) diff --git a/deployment/ccip/changeset/cs_home_chain.go b/deployment/ccip/changeset/cs_home_chain.go index 3b985f5c526..cc234a45e49 100644 --- a/deployment/ccip/changeset/cs_home_chain.go +++ b/deployment/ccip/changeset/cs_home_chain.go @@ -16,6 +16,7 @@ import ( "golang.org/x/exp/maps" "github.com/smartcontractkit/chainlink-common/pkg/logger" + "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" "github.com/smartcontractkit/chainlink/deployment" @@ -26,10 +27,10 @@ import ( p2ptypes "github.com/smartcontractkit/chainlink/v2/core/services/p2p/types" ) -var _ deployment.ChangeSet[DeployHomeChainConfig] = DeployHomeChain +var _ deployment.ChangeSet[DeployHomeChainConfig] = DeployHomeChainChangeset -// DeployHomeChain is a separate changeset because it is a standalone deployment performed once in home chain for the entire CCIP deployment. -func DeployHomeChain(env deployment.Environment, cfg DeployHomeChainConfig) (deployment.ChangesetOutput, error) { +// DeployHomeChainChangeset is a separate changeset because it is a standalone deployment performed once in home chain for the entire CCIP deployment. +func DeployHomeChainChangeset(env deployment.Environment, cfg DeployHomeChainConfig) (deployment.ChangesetOutput, error) { err := cfg.Validate() if err != nil { return deployment.ChangesetOutput{}, errors.Wrapf(deployment.ErrInvalidConfig, "%v", err) diff --git a/deployment/ccip/changeset/cs_home_chain_test.go b/deployment/ccip/changeset/cs_home_chain_test.go index 135e60f4eb1..0dbdb866d9b 100644 --- a/deployment/ccip/changeset/cs_home_chain_test.go +++ b/deployment/ccip/changeset/cs_home_chain_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -8,6 +8,8 @@ import ( "go.uber.org/zap/zapcore" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commoncs "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" "github.com/smartcontractkit/chainlink/deployment/common/view/v1_0" @@ -27,19 +29,19 @@ func TestDeployHomeChain(t *testing.T) { nodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) require.NoError(t, err) p2pIds := nodes.NonBootstraps().PeerIDs() - homeChainCfg := DeployHomeChainConfig{ + homeChainCfg := changeset.DeployHomeChainConfig{ HomeChainSel: homeChainSel, - RMNStaticConfig: NewTestRMNStaticConfig(), - RMNDynamicConfig: NewTestRMNDynamicConfig(), - NodeOperators: NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), + RMNStaticConfig: testhelpers.NewTestRMNStaticConfig(), + RMNDynamicConfig: testhelpers.NewTestRMNDynamicConfig(), + NodeOperators: testhelpers.NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), NodeP2PIDsPerNodeOpAdmin: map[string][][32]byte{ "NodeOperator": p2pIds, }, } - output, err := DeployHomeChain(e, homeChainCfg) + output, err := changeset.DeployHomeChainChangeset(e, homeChainCfg) require.NoError(t, err) require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) - state, err := LoadOnchainState(e) + state, err := changeset.LoadOnchainState(e) require.NoError(t, err) require.NotNil(t, state.Chains[homeChainSel].CapabilityRegistry) require.NotNil(t, state.Chains[homeChainSel].CCIPHome) @@ -62,18 +64,18 @@ func TestDeployHomeChain(t *testing.T) { } func TestRemoveDonsValidate(t *testing.T) { - e, _ := NewMemoryEnvironment(t) - s, err := LoadOnchainState(e.Env) + e, _ := testhelpers.NewMemoryEnvironment(t) + s, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) homeChain := s.Chains[e.HomeChainSel] var tt = []struct { name string - config RemoveDONsConfig + config changeset.RemoveDONsConfig expectErr bool }{ { name: "invalid home", - config: RemoveDONsConfig{ + config: changeset.RemoveDONsConfig{ HomeChainSel: 0, DonIDs: []uint32{1}, }, @@ -81,7 +83,7 @@ func TestRemoveDonsValidate(t *testing.T) { }, { name: "invalid dons", - config: RemoveDONsConfig{ + config: changeset.RemoveDONsConfig{ HomeChainSel: e.HomeChainSel, DonIDs: []uint32{1377}, }, @@ -89,7 +91,7 @@ func TestRemoveDonsValidate(t *testing.T) { }, { name: "no dons", - config: RemoveDONsConfig{ + config: changeset.RemoveDONsConfig{ HomeChainSel: e.HomeChainSel, DonIDs: []uint32{}, }, @@ -97,7 +99,7 @@ func TestRemoveDonsValidate(t *testing.T) { }, { name: "success", - config: RemoveDONsConfig{ + config: changeset.RemoveDONsConfig{ HomeChainSel: e.HomeChainSel, DonIDs: []uint32{1}, }, @@ -117,8 +119,8 @@ func TestRemoveDonsValidate(t *testing.T) { } func TestRemoveDons(t *testing.T) { - e, _ := NewMemoryEnvironment(t) - s, err := LoadOnchainState(e.Env) + e, _ := testhelpers.NewMemoryEnvironment(t) + s, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) homeChain := s.Chains[e.HomeChainSel] @@ -127,8 +129,8 @@ func TestRemoveDons(t *testing.T) { require.NoError(t, err) e.Env, err = commoncs.ApplyChangesets(t, e.Env, nil, []commoncs.ChangesetApplication{ { - Changeset: commoncs.WrapChangeSet(RemoveDONs), - Config: RemoveDONsConfig{ + Changeset: commoncs.WrapChangeSet(changeset.RemoveDONs), + Config: changeset.RemoveDONsConfig{ HomeChainSel: e.HomeChainSel, DonIDs: []uint32{donsBefore[0].Id}, }, @@ -158,11 +160,11 @@ func TestRemoveDons(t *testing.T) { }, }, { - Changeset: commoncs.WrapChangeSet(RemoveDONs), - Config: RemoveDONsConfig{ + Changeset: commoncs.WrapChangeSet(changeset.RemoveDONs), + Config: changeset.RemoveDONsConfig{ HomeChainSel: e.HomeChainSel, DonIDs: []uint32{donsBefore[0].Id}, - MCMS: &MCMSConfig{MinDelay: 0}, + MCMS: &changeset.MCMSConfig{MinDelay: 0}, }, }, }) diff --git a/deployment/ccip/changeset/cs_jobspec.go b/deployment/ccip/changeset/cs_jobspec.go index 2551f193f47..e29578a516a 100644 --- a/deployment/ccip/changeset/cs_jobspec.go +++ b/deployment/ccip/changeset/cs_jobspec.go @@ -9,11 +9,11 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/services/relay" ) -var _ deployment.ChangeSet[any] = CCIPCapabilityJobspec +var _ deployment.ChangeSet[any] = CCIPCapabilityJobspecChangeset -// CCIPCapabilityJobspec returns the job specs for the CCIP capability. +// CCIPCapabilityJobspecChangeset returns the job specs for the CCIP capability. // The caller needs to propose these job specs to the offchain system. -func CCIPCapabilityJobspec(env deployment.Environment, _ any) (deployment.ChangesetOutput, error) { +func CCIPCapabilityJobspecChangeset(env deployment.Environment, _ any) (deployment.ChangesetOutput, error) { nodes, err := deployment.NodeInfo(env.NodeIDs, env.Offchain) if err != nil { return deployment.ChangesetOutput{}, err diff --git a/deployment/ccip/changeset/cs_jobspec_test.go b/deployment/ccip/changeset/cs_jobspec_test.go index a0445b0d5ee..b79dfc47387 100644 --- a/deployment/ccip/changeset/cs_jobspec_test.go +++ b/deployment/ccip/changeset/cs_jobspec_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -7,6 +7,7 @@ import ( "go.uber.org/zap/zapcore" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/deployment/environment/memory" ccip "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/validate" "github.com/smartcontractkit/chainlink/v2/core/logger" @@ -19,7 +20,7 @@ func TestJobSpecChangeset(t *testing.T) { Chains: 1, Nodes: 4, }) - output, err := CCIPCapabilityJobspec(e, nil) + output, err := changeset.CCIPCapabilityJobspecChangeset(e, nil) require.NoError(t, err) require.NotNil(t, output.JobSpecs) nodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) diff --git a/deployment/ccip/changeset/cs_prerequisites.go b/deployment/ccip/changeset/cs_prerequisites.go index 33db57cdc91..da4f59c3eb6 100644 --- a/deployment/ccip/changeset/cs_prerequisites.go +++ b/deployment/ccip/changeset/cs_prerequisites.go @@ -2,34 +2,41 @@ package changeset import ( "fmt" + "math/big" "github.com/ethereum/go-ethereum/common" "github.com/pkg/errors" "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/timelock" + "github.com/smartcontractkit/chainlink-ccip/pkg/reader" + "github.com/smartcontractkit/chainlink-common/pkg/logger" "golang.org/x/sync/errgroup" "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/maybe_revert_message_receiver" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_rmn_contract" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_usdc_token_messenger" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_usdc_token_transmitter" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/price_registry_1_2_0" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/registry_module_owner_custom" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_contract" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_proxy_contract" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/token_admin_registry" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/usdc_token_pool" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/weth9" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/burn_mint_erc677" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/multicall3" ) var ( - _ deployment.ChangeSet[DeployPrerequisiteConfig] = DeployPrerequisites + _ deployment.ChangeSet[DeployPrerequisiteConfig] = DeployPrerequisitesChangeset ) -// DeployPrerequisites deploys the pre-requisite contracts for CCIP +// DeployPrerequisitesChangeset deploys the pre-requisite contracts for CCIP // pre-requisite contracts are the contracts which can be reused from previous versions of CCIP // Or the contracts which are already deployed on the chain ( for example, tokens, feeds, etc) // Caller should update the environment's address book with the returned addresses. -func DeployPrerequisites(env deployment.Environment, cfg DeployPrerequisiteConfig) (deployment.ChangesetOutput, error) { +func DeployPrerequisitesChangeset(env deployment.Environment, cfg DeployPrerequisiteConfig) (deployment.ChangesetOutput, error) { err := cfg.Validate() if err != nil { return deployment.ChangesetOutput{}, errors.Wrapf(deployment.ErrInvalidConfig, "%v", err) @@ -236,7 +243,7 @@ func deployPrerequisiteContracts(e deployment.Environment, ab deployment.Address if rmnOwner != chain.DeployerKey.From { lggr.Warnw( "RMNProxy is not owned by the deployer and RMNProxy is not pointing to the correct RMN contract, "+ - "run SetRMNRemoteOnRMNProxy to update RMN with a proposal", + "run SetRMNRemoteOnRMNProxyChangeset to update RMN with a proposal", "chain", chain.String(), "owner", rmnOwner, "currentRMN", currentRMNAddr, "expectedRMN", rmnAddr) } else { tx, err := rmnProxy.SetARM(chain.DeployerKey, rmnAddr) @@ -373,7 +380,7 @@ func deployPrerequisiteContracts(e deployment.Environment, ab deployment.Address } } if deployOpts.USDCEnabled { - token, pool, messenger, transmitter, err1 := DeployUSDC(e.Logger, chain, ab, rmnProxy.Address(), r.Address()) + token, pool, messenger, transmitter, err1 := deployUSDC(e.Logger, chain, ab, rmnProxy.Address(), r.Address()) if err1 != nil { return err1 } @@ -435,3 +442,119 @@ func deployPrerequisiteContracts(e deployment.Environment, ab deployment.Address } return nil } + +func deployUSDC( + lggr logger.Logger, + chain deployment.Chain, + addresses deployment.AddressBook, + rmnProxy common.Address, + router common.Address, +) ( + *burn_mint_erc677.BurnMintERC677, + *usdc_token_pool.USDCTokenPool, + *mock_usdc_token_messenger.MockE2EUSDCTokenMessenger, + *mock_usdc_token_transmitter.MockE2EUSDCTransmitter, + error, +) { + token, err := deployment.DeployContract(lggr, chain, addresses, + func(chain deployment.Chain) deployment.ContractDeploy[*burn_mint_erc677.BurnMintERC677] { + tokenAddress, tx, tokenContract, err2 := burn_mint_erc677.DeployBurnMintERC677( + chain.DeployerKey, + chain.Client, + USDCName, + string(USDCSymbol), + UsdcDecimals, + big.NewInt(0), + ) + return deployment.ContractDeploy[*burn_mint_erc677.BurnMintERC677]{ + Address: tokenAddress, + Contract: tokenContract, + Tx: tx, + Tv: deployment.NewTypeAndVersion(USDCToken, deployment.Version1_0_0), + Err: err2, + } + }) + if err != nil { + lggr.Errorw("Failed to deploy USDC token", "chain", chain.String(), "err", err) + return nil, nil, nil, nil, err + } + + tx, err := token.Contract.GrantMintRole(chain.DeployerKey, chain.DeployerKey.From) + if err != nil { + lggr.Errorw("Failed to grant mint role", "chain", chain.String(), "token", token.Contract.Address(), "err", err) + return nil, nil, nil, nil, err + } + _, err = chain.Confirm(tx) + if err != nil { + return nil, nil, nil, nil, err + } + + transmitter, err := deployment.DeployContract(lggr, chain, addresses, + func(chain deployment.Chain) deployment.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, + ) + return deployment.ContractDeploy[*mock_usdc_token_transmitter.MockE2EUSDCTransmitter]{ + Address: transmitterAddress, + Contract: transmitterContract, + Tx: tx, + Tv: deployment.NewTypeAndVersion(USDCMockTransmitter, deployment.Version1_0_0), + Err: err2, + } + }) + if err != nil { + lggr.Errorw("Failed to deploy mock USDC transmitter", "chain", chain.String(), "err", err) + return nil, nil, nil, nil, err + } + + messenger, err := deployment.DeployContract(lggr, chain, addresses, + func(chain deployment.Chain) deployment.ContractDeploy[*mock_usdc_token_messenger.MockE2EUSDCTokenMessenger] { + messengerAddress, tx, messengerContract, err2 := mock_usdc_token_messenger.DeployMockE2EUSDCTokenMessenger( + chain.DeployerKey, + chain.Client, + 0, + transmitter.Address, + ) + return deployment.ContractDeploy[*mock_usdc_token_messenger.MockE2EUSDCTokenMessenger]{ + Address: messengerAddress, + Contract: messengerContract, + Tx: tx, + Tv: deployment.NewTypeAndVersion(USDCTokenMessenger, deployment.Version1_0_0), + Err: err2, + } + }) + if err != nil { + lggr.Errorw("Failed to deploy USDC token messenger", "chain", chain.String(), "err", err) + return nil, nil, nil, nil, err + } + + tokenPool, err := deployment.DeployContract(lggr, chain, addresses, + func(chain deployment.Chain) deployment.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, + ) + return deployment.ContractDeploy[*usdc_token_pool.USDCTokenPool]{ + Address: tokenPoolAddress, + Contract: tokenPoolContract, + Tx: tx, + Tv: deployment.NewTypeAndVersion(USDCTokenPool, deployment.Version1_0_0), + Err: err2, + } + }) + if err != nil { + lggr.Errorw("Failed to deploy USDC token pool", "chain", chain.String(), "err", err) + return nil, nil, nil, nil, err + } + + return token.Contract, tokenPool.Contract, messenger.Contract, transmitter.Contract, nil +} diff --git a/deployment/ccip/changeset/cs_prerequisites_test.go b/deployment/ccip/changeset/cs_prerequisites_test.go index 5835bd41aa3..c9c20757e92 100644 --- a/deployment/ccip/changeset/cs_prerequisites_test.go +++ b/deployment/ccip/changeset/cs_prerequisites_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -6,6 +6,7 @@ import ( "github.com/stretchr/testify/require" "go.uber.org/zap/zapcore" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/deployment/environment/memory" "github.com/smartcontractkit/chainlink/v2/core/logger" ) @@ -19,18 +20,18 @@ func TestDeployPrerequisites(t *testing.T) { Nodes: 4, }) newChain := e.AllChainSelectors()[0] - cfg := DeployPrerequisiteConfig{ - Configs: []DeployPrerequisiteConfigPerChain{ + cfg := changeset.DeployPrerequisiteConfig{ + Configs: []changeset.DeployPrerequisiteConfigPerChain{ { ChainSelector: newChain, }, }, } - output, err := DeployPrerequisites(e, cfg) + output, err := changeset.DeployPrerequisitesChangeset(e, cfg) require.NoError(t, err) err = e.ExistingAddresses.Merge(output.AddressBook) require.NoError(t, err) - state, err := LoadOnchainState(e) + state, err := changeset.LoadOnchainState(e) require.NoError(t, err) require.NotNil(t, state.Chains[newChain].Weth9) require.NotNil(t, state.Chains[newChain].TokenAdminRegistry) diff --git a/deployment/ccip/changeset/cs_rmn_curse_uncurse.go b/deployment/ccip/changeset/cs_rmn_curse_uncurse.go index 1f3222014e3..b6125638143 100644 --- a/deployment/ccip/changeset/cs_rmn_curse_uncurse.go +++ b/deployment/ccip/changeset/cs_rmn_curse_uncurse.go @@ -9,6 +9,11 @@ import ( commoncs "github.com/smartcontractkit/chainlink/deployment/common/changeset" ) +var ( + _ deployment.ChangeSet[RMNCurseConfig] = RMNCurseChangeset + _ deployment.ChangeSet[RMNCurseConfig] = RMNUncurseChangeset +) + // GlobalCurseSubject as defined here: https://github.com/smartcontractkit/chainlink/blob/new-rmn-curse-changeset/contracts/src/v0.8/ccip/rmn/RMNRemote.sol#L15 func GlobalCurseSubject() Subject { return Subject{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01} @@ -225,7 +230,7 @@ func RMNCurseChangeset(e deployment.Environment, cfg RMNCurseConfig) (deployment grouped := groupRMNSubjectBySelector(curseActions, true, true) // For each chain in the environment get the RMNRemote contract and call curse for selector, chain := range state.Chains { - deployer, err := deployerGroup.getDeployer(selector) + deployer, err := deployerGroup.GetDeployer(selector) if err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("failed to get deployer for chain %d: %w", selector, err) } @@ -258,7 +263,7 @@ func RMNCurseChangeset(e deployment.Environment, cfg RMNCurseConfig) (deployment } } - return deployerGroup.enact("proposal to curse RMNs: " + cfg.Reason) + return deployerGroup.Enact("proposal to curse RMNs: " + cfg.Reason) } // RMNUncurseChangeset creates a new changeset for uncursing chains or lanes on RMNRemote contracts. @@ -296,7 +301,7 @@ func RMNUncurseChangeset(e deployment.Environment, cfg RMNCurseConfig) (deployme // For each chain in the environement get the RMNRemote contract and call uncurse for selector, chain := range state.Chains { - deployer, err := deployerGroup.getDeployer(selector) + deployer, err := deployerGroup.GetDeployer(selector) if err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("failed to get deployer for chain %d: %w", selector, err) } @@ -330,5 +335,5 @@ func RMNUncurseChangeset(e deployment.Environment, cfg RMNCurseConfig) (deployme } } - return deployerGroup.enact("proposal to uncurse RMNs: %s" + cfg.Reason) + return deployerGroup.Enact("proposal to uncurse RMNs: %s" + cfg.Reason) } diff --git a/deployment/ccip/changeset/cs_rmn_curse_uncurse_test.go b/deployment/ccip/changeset/cs_rmn_curse_uncurse_test.go index 2b0a6c07a59..7a043b36645 100644 --- a/deployment/ccip/changeset/cs_rmn_curse_uncurse_test.go +++ b/deployment/ccip/changeset/cs_rmn_curse_uncurse_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -6,6 +6,8 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/stretchr/testify/require" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" ) @@ -19,7 +21,7 @@ type curseAssertion struct { type CurseTestCase struct { name string - curseActionsBuilder func(mapIDToSelectorFunc) []CurseAction + curseActionsBuilder func(mapIDToSelectorFunc) []changeset.CurseAction curseAssertions []curseAssertion } @@ -28,8 +30,8 @@ type mapIDToSelectorFunc func(uint64) uint64 var testCases = []CurseTestCase{ { name: "lane", - curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []CurseAction { - return []CurseAction{CurseLaneBidirectionally(mapIDToSelector(0), mapIDToSelector(1))} + curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []changeset.CurseAction { + return []changeset.CurseAction{changeset.CurseLaneBidirectionally(mapIDToSelector(0), mapIDToSelector(1))} }, curseAssertions: []curseAssertion{ {chainID: 0, subject: 1, cursed: true}, @@ -42,8 +44,10 @@ var testCases = []CurseTestCase{ }, { name: "lane duplicate", - curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []CurseAction { - return []CurseAction{CurseLaneBidirectionally(mapIDToSelector(0), mapIDToSelector(1)), CurseLaneBidirectionally(mapIDToSelector(0), mapIDToSelector(1))} + curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []changeset.CurseAction { + return []changeset.CurseAction{ + changeset.CurseLaneBidirectionally(mapIDToSelector(0), mapIDToSelector(1)), + changeset.CurseLaneBidirectionally(mapIDToSelector(0), mapIDToSelector(1))} }, curseAssertions: []curseAssertion{ {chainID: 0, subject: 1, cursed: true}, @@ -56,8 +60,8 @@ var testCases = []CurseTestCase{ }, { name: "chain", - curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []CurseAction { - return []CurseAction{CurseChain(mapIDToSelector(0))} + curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []changeset.CurseAction { + return []changeset.CurseAction{changeset.CurseChain(mapIDToSelector(0))} }, curseAssertions: []curseAssertion{ {chainID: 0, globalCurse: true, cursed: true}, @@ -69,8 +73,8 @@ var testCases = []CurseTestCase{ }, { name: "chain duplicate", - curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []CurseAction { - return []CurseAction{CurseChain(mapIDToSelector(0)), CurseChain(mapIDToSelector(0))} + curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []changeset.CurseAction { + return []changeset.CurseAction{changeset.CurseChain(mapIDToSelector(0)), changeset.CurseChain(mapIDToSelector(0))} }, curseAssertions: []curseAssertion{ {chainID: 0, globalCurse: true, cursed: true}, @@ -82,8 +86,8 @@ var testCases = []CurseTestCase{ }, { name: "chain and lanes", - curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []CurseAction { - return []CurseAction{CurseChain(mapIDToSelector(0)), CurseLaneBidirectionally(mapIDToSelector(1), mapIDToSelector(2))} + curseActionsBuilder: func(mapIDToSelector mapIDToSelectorFunc) []changeset.CurseAction { + return []changeset.CurseAction{changeset.CurseChain(mapIDToSelector(0)), changeset.CurseLaneBidirectionally(mapIDToSelector(1), mapIDToSelector(2))} }, curseAssertions: []curseAssertion{ {chainID: 0, globalCurse: true, cursed: true}, @@ -142,7 +146,7 @@ func TestRMNCurseConfigValidate(t *testing.T) { } func runRmnUncurseTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] @@ -150,23 +154,23 @@ func runRmnUncurseTest(t *testing.T, tc CurseTestCase) { verifyNoActiveCurseOnAllChains(t, &e) - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", } - _, err := RMNCurseChangeset(e.Env, config) + _, err := changeset.RMNCurseChangeset(e.Env, config) require.NoError(t, err) verifyTestCaseAssertions(t, &e, tc, mapIDToSelector) - _, err = RMNUncurseChangeset(e.Env, config) + _, err = changeset.RMNUncurseChangeset(e.Env, config) require.NoError(t, err) verifyNoActiveCurseOnAllChains(t, &e) } -func transferRMNContractToMCMS(t *testing.T, e *DeployedEnv, state CCIPOnChainState, timelocksPerChain map[uint64]*proposalutils.TimelockExecutionContracts) { +func transferRMNContractToMCMS(t *testing.T, e *testhelpers.DeployedEnv, state changeset.CCIPOnChainState, timelocksPerChain map[uint64]*proposalutils.TimelockExecutionContracts) { contractsByChain := make(map[uint64][]common.Address) rmnRemoteAddressesByChain := buildRMNRemoteAddressPerChain(e.Env, state) for chainSelector, rmnRemoteAddress := range rmnRemoteAddressesByChain { @@ -189,30 +193,30 @@ func transferRMNContractToMCMS(t *testing.T, e *DeployedEnv, state CCIPOnChainSt } func runRmnUncurseMCMSTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] } - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", - MCMS: &MCMSConfig{MinDelay: 0}, + MCMS: &changeset.MCMSConfig{MinDelay: 0}, } - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) verifyNoActiveCurseOnAllChains(t, &e) - timelocksPerChain := buildTimelockPerChain(e.Env, state) + timelocksPerChain := changeset.BuildTimelockPerChain(e.Env, state) transferRMNContractToMCMS(t, &e, state, timelocksPerChain) _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(RMNCurseChangeset), + Changeset: commonchangeset.WrapChangeSet(changeset.RMNCurseChangeset), Config: config, }, }) @@ -222,7 +226,7 @@ func runRmnUncurseMCMSTest(t *testing.T, tc CurseTestCase) { _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(RMNUncurseChangeset), + Changeset: commonchangeset.WrapChangeSet(changeset.RMNUncurseChangeset), Config: config, }, }) @@ -232,13 +236,13 @@ func runRmnUncurseMCMSTest(t *testing.T, tc CurseTestCase) { } func runRmnCurseConfigValidateTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] } - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", } @@ -248,7 +252,7 @@ func runRmnCurseConfigValidateTest(t *testing.T, tc CurseTestCase) { } func runRmnCurseTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] @@ -256,19 +260,19 @@ func runRmnCurseTest(t *testing.T, tc CurseTestCase) { verifyNoActiveCurseOnAllChains(t, &e) - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", } - _, err := RMNCurseChangeset(e.Env, config) + _, err := changeset.RMNCurseChangeset(e.Env, config) require.NoError(t, err) verifyTestCaseAssertions(t, &e, tc, mapIDToSelector) } func runRmnCurseIdempotentTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] @@ -276,22 +280,22 @@ func runRmnCurseIdempotentTest(t *testing.T, tc CurseTestCase) { verifyNoActiveCurseOnAllChains(t, &e) - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", } - _, err := RMNCurseChangeset(e.Env, config) + _, err := changeset.RMNCurseChangeset(e.Env, config) require.NoError(t, err) - _, err = RMNCurseChangeset(e.Env, config) + _, err = changeset.RMNCurseChangeset(e.Env, config) require.NoError(t, err) verifyTestCaseAssertions(t, &e, tc, mapIDToSelector) } func runRmnUncurseIdempotentTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] @@ -299,50 +303,50 @@ func runRmnUncurseIdempotentTest(t *testing.T, tc CurseTestCase) { verifyNoActiveCurseOnAllChains(t, &e) - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", } - _, err := RMNCurseChangeset(e.Env, config) + _, err := changeset.RMNCurseChangeset(e.Env, config) require.NoError(t, err) verifyTestCaseAssertions(t, &e, tc, mapIDToSelector) - _, err = RMNUncurseChangeset(e.Env, config) + _, err = changeset.RMNUncurseChangeset(e.Env, config) require.NoError(t, err) - _, err = RMNUncurseChangeset(e.Env, config) + _, err = changeset.RMNUncurseChangeset(e.Env, config) require.NoError(t, err) verifyNoActiveCurseOnAllChains(t, &e) } func runRmnCurseMCMSTest(t *testing.T, tc CurseTestCase) { - e, _ := NewMemoryEnvironment(t, WithChains(3)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) mapIDToSelector := func(id uint64) uint64 { return e.Env.AllChainSelectors()[id] } - config := RMNCurseConfig{ + config := changeset.RMNCurseConfig{ CurseActions: tc.curseActionsBuilder(mapIDToSelector), Reason: "test curse", - MCMS: &MCMSConfig{MinDelay: 0}, + MCMS: &changeset.MCMSConfig{MinDelay: 0}, } - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) verifyNoActiveCurseOnAllChains(t, &e) - timelocksPerChain := buildTimelockPerChain(e.Env, state) + timelocksPerChain := changeset.BuildTimelockPerChain(e.Env, state) transferRMNContractToMCMS(t, &e, state, timelocksPerChain) _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(RMNCurseChangeset), + Changeset: commonchangeset.WrapChangeSet(changeset.RMNCurseChangeset), Config: config, }, }) @@ -351,14 +355,14 @@ func runRmnCurseMCMSTest(t *testing.T, tc CurseTestCase) { verifyTestCaseAssertions(t, &e, tc, mapIDToSelector) } -func verifyTestCaseAssertions(t *testing.T, e *DeployedEnv, tc CurseTestCase, mapIDToSelector mapIDToSelectorFunc) { - state, err := LoadOnchainState(e.Env) +func verifyTestCaseAssertions(t *testing.T, e *testhelpers.DeployedEnv, tc CurseTestCase, mapIDToSelector mapIDToSelectorFunc) { + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) for _, assertion := range tc.curseAssertions { - cursedSubject := SelectorToSubject(mapIDToSelector(assertion.subject)) + cursedSubject := changeset.SelectorToSubject(mapIDToSelector(assertion.subject)) if assertion.globalCurse { - cursedSubject = GlobalCurseSubject() + cursedSubject = changeset.GlobalCurseSubject() } isCursed, err := state.Chains[mapIDToSelector(assertion.chainID)].RMNRemote.IsCursed(nil, cursedSubject) @@ -367,8 +371,8 @@ func verifyTestCaseAssertions(t *testing.T, e *DeployedEnv, tc CurseTestCase, ma } } -func verifyNoActiveCurseOnAllChains(t *testing.T, e *DeployedEnv) { - state, err := LoadOnchainState(e.Env) +func verifyNoActiveCurseOnAllChains(t *testing.T, e *testhelpers.DeployedEnv) { + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) for _, chain := range e.Env.Chains { diff --git a/deployment/ccip/changeset/cs_update_rmn_config.go b/deployment/ccip/changeset/cs_update_rmn_config.go index 1797d588fca..e220ca50998 100644 --- a/deployment/ccip/changeset/cs_update_rmn_config.go +++ b/deployment/ccip/changeset/cs_update_rmn_config.go @@ -20,9 +20,9 @@ import ( ) var ( - _ deployment.ChangeSet[SetRMNRemoteOnRMNProxyConfig] = SetRMNRemoteOnRMNProxy + _ deployment.ChangeSet[SetRMNRemoteOnRMNProxyConfig] = SetRMNRemoteOnRMNProxyChangeset _ deployment.ChangeSet[SetRMNHomeCandidateConfig] = SetRMNHomeCandidateConfigChangeset - _ deployment.ChangeSet[PromoteRMNHomeCandidateConfig] = PromoteCandidateConfigChangeset + _ deployment.ChangeSet[PromoteRMNHomeCandidateConfig] = PromoteRMNHomeCandidateConfigChangeset _ deployment.ChangeSet[SetRMNRemoteConfig] = SetRMNRemoteConfigChangeset ) @@ -51,7 +51,7 @@ func (c SetRMNRemoteOnRMNProxyConfig) Validate(state CCIPOnChainState) error { return nil } -func SetRMNRemoteOnRMNProxy(e deployment.Environment, cfg SetRMNRemoteOnRMNProxyConfig) (deployment.ChangesetOutput, error) { +func SetRMNRemoteOnRMNProxyChangeset(e deployment.Environment, cfg SetRMNRemoteOnRMNProxyConfig) (deployment.ChangesetOutput, error) { state, err := LoadOnchainState(e) if err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("failed to load onchain state: %w", err) @@ -314,9 +314,9 @@ func SetRMNHomeCandidateConfigChangeset(e deployment.Environment, config SetRMNH }, } - timelocksPerChain := buildTimelockAddressPerChain(e, state) + timelocksPerChain := BuildTimelockAddressPerChain(e, state) - proposerMCMSes := buildProposerPerChain(e, state) + proposerMCMSes := BuildProposerPerChain(e, state) prop, err := proposalutils.BuildProposalFromBatches( timelocksPerChain, @@ -331,7 +331,7 @@ func SetRMNHomeCandidateConfigChangeset(e deployment.Environment, config SetRMNH }, nil } -func PromoteCandidateConfigChangeset(e deployment.Environment, config PromoteRMNHomeCandidateConfig) (deployment.ChangesetOutput, error) { +func PromoteRMNHomeCandidateConfigChangeset(e deployment.Environment, config PromoteRMNHomeCandidateConfig) (deployment.ChangesetOutput, error) { state, err := LoadOnchainState(e) if err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("failed to load onchain state: %w", err) @@ -393,9 +393,9 @@ func PromoteCandidateConfigChangeset(e deployment.Environment, config PromoteRMN }, } - timelocksPerChain := buildTimelockAddressPerChain(e, state) + timelocksPerChain := BuildTimelockAddressPerChain(e, state) - proposerMCMSes := buildProposerPerChain(e, state) + proposerMCMSes := BuildProposerPerChain(e, state) prop, err := proposalutils.BuildProposalFromBatches( timelocksPerChain, @@ -414,7 +414,7 @@ func PromoteCandidateConfigChangeset(e deployment.Environment, config PromoteRMN }, nil } -func buildRMNRemotePerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]*rmn_remote.RMNRemote { +func BuildRMNRemotePerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]*rmn_remote.RMNRemote { timelocksPerChain := make(map[uint64]*rmn_remote.RMNRemote) for _, chain := range e.Chains { timelocksPerChain[chain.Selector] = state.Chains[chain.Selector].RMNRemote @@ -488,7 +488,7 @@ func SetRMNRemoteConfigChangeset(e deployment.Environment, config SetRMNRemoteCo return deployment.ChangesetOutput{}, fmt.Errorf("failed to get RMNHome active digest for chain %s: %w", homeChain.String(), err) } - rmnRemotePerChain := buildRMNRemotePerChain(e, state) + rmnRemotePerChain := BuildRMNRemotePerChain(e, state) batches := make([]timelock.BatchChainOperation, 0) for chain, remoteConfig := range config.RMNRemoteConfigs { remote, ok := rmnRemotePerChain[chain] @@ -545,9 +545,9 @@ func SetRMNRemoteConfigChangeset(e deployment.Environment, config SetRMNRemoteCo return deployment.ChangesetOutput{}, nil } - timelocksPerChain := buildTimelockAddressPerChain(e, state) + timelocksPerChain := BuildTimelockAddressPerChain(e, state) - proposerMCMSes := buildProposerPerChain(e, state) + proposerMCMSes := BuildProposerPerChain(e, state) prop, err := proposalutils.BuildProposalFromBatches( timelocksPerChain, diff --git a/deployment/ccip/changeset/cs_update_rmn_config_test.go b/deployment/ccip/changeset/cs_update_rmn_config_test.go index fdccf36af07..1db80197b15 100644 --- a/deployment/ccip/changeset/cs_update_rmn_config_test.go +++ b/deployment/ccip/changeset/cs_update_rmn_config_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "testing" @@ -7,6 +7,8 @@ import ( "github.com/stretchr/testify/require" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" @@ -15,19 +17,19 @@ import ( ) var ( - rmn_staging_1 = RMNNopConfig{ + rmnStaging1 = changeset.RMNNopConfig{ NodeIndex: 0, PeerId: deployment.MustPeerIDFromString("p2p_12D3KooWRXxZq3pd4a3ZGkKj7Nt1SQQrnB8CuvbPnnV9KVeMeWqg"), OffchainPublicKey: [32]byte(common.FromHex("0xb34944857a42444d1b285d7940d6e06682309e0781e43a69676ee9f85c73c2d1")), EVMOnChainPublicKey: common.HexToAddress("0x5af8ee32316a6427f169a45fdc1b3a91a85ac459e3c1cb91c69e1c51f0c1fc21"), } - rmn_staging_2 = RMNNopConfig{ + rmnStaging2 = changeset.RMNNopConfig{ NodeIndex: 1, PeerId: deployment.MustPeerIDFromString("p2p_12D3KooWEmdxYQFsRbD9aFczF32zA3CcUwuSiWCk2CrmACo4v9RL"), OffchainPublicKey: [32]byte(common.FromHex("0x68d9f3f274e3985528a923a9bace3d39c55dd778b187b4120b384cc48c892859")), EVMOnChainPublicKey: common.HexToAddress("0x858589216956f482a0f68b282a7050af4cd48ed2"), } - rmn_staging_3 = RMNNopConfig{ + rmnStaging3 = changeset.RMNNopConfig{ NodeIndex: 2, PeerId: deployment.MustPeerIDFromString("p2p_12D3KooWJS42cNXKJvj6DeZnxEX7aGxhEuap6uNFrz554AbUDw6Q"), OffchainPublicKey: [32]byte(common.FromHex("0x5af8ee32316a6427f169a45fdc1b3a91a85ac459e3c1cb91c69e1c51f0c1fc21")), @@ -38,7 +40,7 @@ var ( type updateRMNConfigTestCase struct { useMCMS bool name string - nops []RMNNopConfig + nops []changeset.RMNNopConfig } func TestUpdateRMNConfig(t *testing.T) { @@ -47,12 +49,12 @@ func TestUpdateRMNConfig(t *testing.T) { { useMCMS: true, name: "with MCMS", - nops: []RMNNopConfig{rmn_staging_1, rmn_staging_2, rmn_staging_3}, + nops: []changeset.RMNNopConfig{rmnStaging1, rmnStaging2, rmnStaging3}, }, { useMCMS: false, name: "without MCMS", - nops: []RMNNopConfig{rmn_staging_1, rmn_staging_2, rmn_staging_3}, + nops: []changeset.RMNNopConfig{rmnStaging1, rmnStaging2, rmnStaging3}, }, } @@ -65,9 +67,9 @@ func TestUpdateRMNConfig(t *testing.T) { } func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { - e, _ := NewMemoryEnvironment(t) + e, _ := testhelpers.NewMemoryEnvironment(t) - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) contractsByChain := make(map[uint64][]common.Address) @@ -78,7 +80,7 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { contractsByChain[e.HomeChainSel] = append(contractsByChain[e.HomeChainSel], state.Chains[e.HomeChainSel].RMNHome.Address()) - timelocksPerChain := buildTimelockPerChain(e.Env, state) + timelocksPerChain := changeset.BuildTimelockPerChain(e.Env, state) if tc.useMCMS { // This is required because RMNHome is initially owned by the deployer _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ @@ -99,10 +101,10 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { previousActiveDigest, err := rmnHome.GetActiveDigest(nil) require.NoError(t, err) - var mcmsConfig *MCMSConfig = nil + var mcmsConfig *changeset.MCMSConfig if tc.useMCMS { - mcmsConfig = &MCMSConfig{ + mcmsConfig = &changeset.MCMSConfig{ MinDelay: 0, } } @@ -112,7 +114,7 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { nodes = append(nodes, nop.ToRMNHomeNode()) } - setRMNHomeCandidateConfig := SetRMNHomeCandidateConfig{ + setRMNHomeCandidateConfig := changeset.SetRMNHomeCandidateConfig{ HomeChainSelector: e.HomeChainSel, RMNStaticConfig: rmn_home.RMNHomeStaticConfig{ Nodes: nodes, @@ -127,14 +129,14 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(SetRMNHomeCandidateConfigChangeset), + Changeset: commonchangeset.WrapChangeSet(changeset.SetRMNHomeCandidateConfigChangeset), Config: setRMNHomeCandidateConfig, }, }) require.NoError(t, err) - state, err = LoadOnchainState(e.Env) + state, err = changeset.LoadOnchainState(e.Env) require.NoError(t, err) currentCandidateDigest, err := rmnHome.GetCandidateDigest(nil) @@ -145,7 +147,7 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { require.NotEqual(t, previousCandidateDigest, currentCandidateDigest) require.Equal(t, previousActiveDigest, currentActiveDigest) - promoteConfig := PromoteRMNHomeCandidateConfig{ + promoteConfig := changeset.PromoteRMNHomeCandidateConfig{ HomeChainSelector: e.HomeChainSel, DigestToPromote: currentCandidateDigest, MCMSConfig: mcmsConfig, @@ -153,7 +155,7 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(PromoteCandidateConfigChangeset), + Changeset: commonchangeset.WrapChangeSet(changeset.PromoteRMNHomeCandidateConfigChangeset), Config: promoteConfig, }, }) @@ -169,9 +171,9 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { signers = append(signers, nop.ToRMNRemoteSigner()) } - remoteConfigs := make(map[uint64]RMNRemoteConfig, len(e.Env.Chains)) + remoteConfigs := make(map[uint64]changeset.RMNRemoteConfig, len(e.Env.Chains)) for _, chain := range e.Env.Chains { - remoteConfig := RMNRemoteConfig{ + remoteConfig := changeset.RMNRemoteConfig{ Signers: signers, F: 0, } @@ -179,7 +181,7 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { remoteConfigs[chain.Selector] = remoteConfig } - setRemoteConfig := SetRMNRemoteConfig{ + setRemoteConfig := changeset.SetRMNRemoteConfig{ HomeChainSelector: e.HomeChainSel, RMNRemoteConfigs: remoteConfigs, MCMSConfig: mcmsConfig, @@ -187,13 +189,13 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { _, err = commonchangeset.ApplyChangesets(t, e.Env, timelocksPerChain, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(SetRMNRemoteConfigChangeset), + Changeset: commonchangeset.WrapChangeSet(changeset.SetRMNRemoteConfigChangeset), Config: setRemoteConfig, }, }) require.NoError(t, err) - rmnRemotePerChain := buildRMNRemotePerChain(e.Env, state) + rmnRemotePerChain := changeset.BuildRMNRemotePerChain(e.Env, state) for _, rmnRemote := range rmnRemotePerChain { remoteConfigSetEvents, err := rmnRemote.FilterConfigSet(nil, nil) require.NoError(t, err) @@ -206,8 +208,8 @@ func updateRMNConfig(t *testing.T, tc updateRMNConfigTestCase) { } } -func buildRMNRemoteAddressPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]common.Address { - rmnRemotePerChain := buildRMNRemotePerChain(e, state) +func buildRMNRemoteAddressPerChain(e deployment.Environment, state changeset.CCIPOnChainState) map[uint64]common.Address { + rmnRemotePerChain := changeset.BuildRMNRemotePerChain(e, state) rmnRemoteAddressPerChain := make(map[uint64]common.Address) for chain, remote := range rmnRemotePerChain { if remote == nil { @@ -220,14 +222,14 @@ func buildRMNRemoteAddressPerChain(e deployment.Environment, state CCIPOnChainSt func TestSetRMNRemoteOnRMNProxy(t *testing.T) { t.Parallel() - e, _ := NewMemoryEnvironment(t, WithNoJobsAndContracts()) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNoJobsAndContracts()) allChains := e.Env.AllChainSelectors() mcmsCfg := make(map[uint64]commontypes.MCMSWithTimelockConfig) var err error - var prereqCfgs []DeployPrerequisiteConfigPerChain + prereqCfgs := make([]changeset.DeployPrerequisiteConfigPerChain, 0) for _, c := range e.Env.AllChainSelectors() { mcmsCfg[c] = proposalutils.SingleGroupTimelockConfig(t) - prereqCfgs = append(prereqCfgs, DeployPrerequisiteConfigPerChain{ + prereqCfgs = append(prereqCfgs, changeset.DeployPrerequisiteConfigPerChain{ ChainSelector: c, }) } @@ -239,8 +241,8 @@ func TestSetRMNRemoteOnRMNProxy(t *testing.T) { Config: allChains, }, { - Changeset: commonchangeset.WrapChangeSet(DeployPrerequisites), - Config: DeployPrerequisiteConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployPrerequisitesChangeset), + Config: changeset.DeployPrerequisiteConfig{ Configs: prereqCfgs, }, }, @@ -251,7 +253,7 @@ func TestSetRMNRemoteOnRMNProxy(t *testing.T) { }) require.NoError(t, err) contractsByChain := make(map[uint64][]common.Address) - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) for _, chain := range allChains { rmnProxy := state.Chains[chain].RMNProxy @@ -278,36 +280,36 @@ func TestSetRMNRemoteOnRMNProxy(t *testing.T) { }, { - Changeset: commonchangeset.WrapChangeSet(DeployHomeChain), - Config: DeployHomeChainConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployHomeChainChangeset), + Config: changeset.DeployHomeChainConfig{ HomeChainSel: e.HomeChainSel, - RMNDynamicConfig: NewTestRMNDynamicConfig(), - RMNStaticConfig: NewTestRMNStaticConfig(), - NodeOperators: NewTestNodeOperator(e.Env.Chains[e.HomeChainSel].DeployerKey.From), + RMNDynamicConfig: testhelpers.NewTestRMNDynamicConfig(), + RMNStaticConfig: testhelpers.NewTestRMNStaticConfig(), + NodeOperators: testhelpers.NewTestNodeOperator(e.Env.Chains[e.HomeChainSel].DeployerKey.From), NodeP2PIDsPerNodeOpAdmin: map[string][][32]byte{ "NodeOperator": envNodes.NonBootstraps().PeerIDs(), }, }, }, { - Changeset: commonchangeset.WrapChangeSet(DeployChainContracts), - Config: DeployChainContractsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployChainContractsChangeset), + Config: changeset.DeployChainContractsConfig{ ChainSelectors: allChains, HomeChainSelector: e.HomeChainSel, }, }, { - Changeset: commonchangeset.WrapChangeSet(SetRMNRemoteOnRMNProxy), - Config: SetRMNRemoteOnRMNProxyConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetRMNRemoteOnRMNProxyChangeset), + Config: changeset.SetRMNRemoteOnRMNProxyConfig{ ChainSelectors: allChains, - MCMSConfig: &MCMSConfig{ + MCMSConfig: &changeset.MCMSConfig{ MinDelay: 0, }, }, }, }) require.NoError(t, err) - state, err = LoadOnchainState(e.Env) + state, err = changeset.LoadOnchainState(e.Env) require.NoError(t, err) for _, chain := range allChains { rmnProxy := state.Chains[chain].RMNProxy diff --git a/deployment/ccip/changeset/deployer_group.go b/deployment/ccip/changeset/deployer_group.go index 0c0ff1e5c8e..5f7c7e52da2 100644 --- a/deployment/ccip/changeset/deployer_group.go +++ b/deployment/ccip/changeset/deployer_group.go @@ -31,10 +31,10 @@ type DeployerGroup struct { // deployerGroup := NewDeployerGroup(e, state, mcmConfig) // selector := 0 // # Get the right deployer key for the chain -// deployer := deployerGroup.getDeployer(selector) +// deployer := deployerGroup.GetDeployer(selector) // state.Chains[selector].RMNRemote.Curse() // # Execute the transaction or create the proposal -// deployerGroup.enact("Curse RMNRemote") +// deployerGroup.Enact("Curse RMNRemote") func NewDeployerGroup(e deployment.Environment, state CCIPOnChainState, mcmConfig *MCMSConfig) *DeployerGroup { return &DeployerGroup{ e: e, @@ -44,7 +44,7 @@ func NewDeployerGroup(e deployment.Environment, state CCIPOnChainState, mcmConfi } } -func (d *DeployerGroup) getDeployer(chain uint64) (*bind.TransactOpts, error) { +func (d *DeployerGroup) GetDeployer(chain uint64) (*bind.TransactOpts, error) { txOpts := d.e.Chains[chain].DeployerKey if d.mcmConfig != nil { txOpts = deployment.SimTransactOpts() @@ -102,7 +102,7 @@ func (d *DeployerGroup) getDeployer(chain uint64) (*bind.TransactOpts, error) { return sim, nil } -func (d *DeployerGroup) enact(deploymentDescription string) (deployment.ChangesetOutput, error) { +func (d *DeployerGroup) Enact(deploymentDescription string) (deployment.ChangesetOutput, error) { if d.mcmConfig != nil { return d.enactMcms(deploymentDescription) } @@ -127,9 +127,9 @@ func (d *DeployerGroup) enactMcms(deploymentDescription string) (deployment.Chan }) } - timelocksPerChain := buildTimelockAddressPerChain(d.e, d.state) + timelocksPerChain := BuildTimelockAddressPerChain(d.e, d.state) - proposerMCMSes := buildProposerPerChain(d.e, d.state) + proposerMCMSes := BuildProposerPerChain(d.e, d.state) prop, err := proposalutils.BuildProposalFromBatches( timelocksPerChain, @@ -165,7 +165,7 @@ func (d *DeployerGroup) enactDeployer() (deployment.ChangesetOutput, error) { return deployment.ChangesetOutput{}, nil } -func buildTimelockPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]*proposalutils.TimelockExecutionContracts { +func BuildTimelockPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]*proposalutils.TimelockExecutionContracts { timelocksPerChain := make(map[uint64]*proposalutils.TimelockExecutionContracts) for _, chain := range e.Chains { timelocksPerChain[chain.Selector] = &proposalutils.TimelockExecutionContracts{ @@ -176,8 +176,8 @@ func buildTimelockPerChain(e deployment.Environment, state CCIPOnChainState) map return timelocksPerChain } -func buildTimelockAddressPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]common.Address { - timelocksPerChain := buildTimelockPerChain(e, state) +func BuildTimelockAddressPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]common.Address { + timelocksPerChain := BuildTimelockPerChain(e, state) timelockAddressPerChain := make(map[uint64]common.Address) for chain, timelock := range timelocksPerChain { timelockAddressPerChain[chain] = timelock.Timelock.Address() @@ -185,7 +185,7 @@ func buildTimelockAddressPerChain(e deployment.Environment, state CCIPOnChainSta return timelockAddressPerChain } -func buildProposerPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]*gethwrappers.ManyChainMultiSig { +func BuildProposerPerChain(e deployment.Environment, state CCIPOnChainState) map[uint64]*gethwrappers.ManyChainMultiSig { proposerPerChain := make(map[uint64]*gethwrappers.ManyChainMultiSig) for _, chain := range e.Chains { proposerPerChain[chain.Selector] = state.Chains[chain.Selector].ProposerMcm diff --git a/deployment/ccip/changeset/deployer_group_test.go b/deployment/ccip/changeset/deployer_group_test.go index 12dcaa9076b..ba598ec74e8 100644 --- a/deployment/ccip/changeset/deployer_group_test.go +++ b/deployment/ccip/changeset/deployer_group_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "math/big" @@ -8,6 +8,8 @@ import ( "github.com/stretchr/testify/require" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" ) @@ -15,19 +17,19 @@ type dummyDeployerGroupChangesetConfig struct { selector uint64 address common.Address mints []*big.Int - MCMS *MCMSConfig + MCMS *changeset.MCMSConfig } func dummyDeployerGroupGrantMintChangeset(e deployment.Environment, cfg dummyDeployerGroupChangesetConfig) (deployment.ChangesetOutput, error) { - state, err := LoadOnchainState(e) + state, err := changeset.LoadOnchainState(e) if err != nil { return deployment.ChangesetOutput{}, err } token := state.Chains[cfg.selector].LinkToken - group := NewDeployerGroup(e, state, cfg.MCMS) - deployer, err := group.getDeployer(cfg.selector) + group := changeset.NewDeployerGroup(e, state, cfg.MCMS) + deployer, err := group.GetDeployer(cfg.selector) if err != nil { return deployment.ChangesetOutput{}, err } @@ -37,19 +39,19 @@ func dummyDeployerGroupGrantMintChangeset(e deployment.Environment, cfg dummyDep return deployment.ChangesetOutput{}, err } - return group.enact("Grant mint role") + return group.Enact("Grant mint role") } func dummyDeployerGroupMintChangeset(e deployment.Environment, cfg dummyDeployerGroupChangesetConfig) (deployment.ChangesetOutput, error) { - state, err := LoadOnchainState(e) + state, err := changeset.LoadOnchainState(e) if err != nil { return deployment.ChangesetOutput{}, err } token := state.Chains[cfg.selector].LinkToken - group := NewDeployerGroup(e, state, cfg.MCMS) - deployer, err := group.getDeployer(cfg.selector) + group := changeset.NewDeployerGroup(e, state, cfg.MCMS) + deployer, err := group.GetDeployer(cfg.selector) if err != nil { return deployment.ChangesetOutput{}, err } @@ -61,7 +63,7 @@ func dummyDeployerGroupMintChangeset(e deployment.Environment, cfg dummyDeployer } } - return group.enact("Mint tokens") + return group.Enact("Mint tokens") } type deployerGroupTestCase struct { @@ -91,7 +93,7 @@ var deployerGroupTestCases = []deployerGroupTestCase{ func TestDeployerGroup(t *testing.T) { for _, tc := range deployerGroupTestCases { t.Run(tc.name, func(t *testing.T) { - e, _ := NewMemoryEnvironment(t, WithChains(2)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(2)) tc.cfg.selector = e.HomeChainSel tc.cfg.MCMS = nil @@ -105,7 +107,7 @@ func TestDeployerGroup(t *testing.T) { } else { require.NoError(t, err) - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) token := state.Chains[e.HomeChainSel].LinkToken @@ -131,16 +133,16 @@ func TestDeployerGroupMCMS(t *testing.T) { t.Skip("skipping test because it's not possible to verify error when using MCMS since we are explicitly failing the test in ApplyChangesets") } - e, _ := NewMemoryEnvironment(t, WithChains(2)) + e, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(2)) tc.cfg.selector = e.HomeChainSel - tc.cfg.MCMS = &MCMSConfig{ + tc.cfg.MCMS = &changeset.MCMSConfig{ MinDelay: 0, } - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) - timelocksPerChain := buildTimelockPerChain(e.Env, state) + timelocksPerChain := changeset.BuildTimelockPerChain(e.Env, state) contractsByChain := make(map[uint64][]common.Address) contractsByChain[e.HomeChainSel] = []common.Address{state.Chains[e.HomeChainSel].LinkToken.Address()} @@ -172,7 +174,7 @@ func TestDeployerGroupMCMS(t *testing.T) { }) require.NoError(t, err) - state, err = LoadOnchainState(e.Env) + state, err = changeset.LoadOnchainState(e.Env) require.NoError(t, err) token := state.Chains[e.HomeChainSel].LinkToken diff --git a/deployment/ccip/changeset/save_existing_test.go b/deployment/ccip/changeset/save_existing_test.go index 080ed80481a..f575bc005f2 100644 --- a/deployment/ccip/changeset/save_existing_test.go +++ b/deployment/ccip/changeset/save_existing_test.go @@ -1,4 +1,4 @@ -package changeset +package changeset_test import ( "math/big" @@ -9,6 +9,7 @@ import ( "go.uber.org/zap/zapcore" "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" "github.com/smartcontractkit/chainlink/deployment/environment/memory" @@ -35,32 +36,32 @@ func TestSaveExistingCCIP(t *testing.T) { }, { Address: common.BigToAddress(big.NewInt(2)), - TypeAndVersion: deployment.NewTypeAndVersion(WETH9, deployment.Version1_0_0), + TypeAndVersion: deployment.NewTypeAndVersion(changeset.WETH9, deployment.Version1_0_0), ChainSelector: chain1, }, { Address: common.BigToAddress(big.NewInt(3)), - TypeAndVersion: deployment.NewTypeAndVersion(TokenAdminRegistry, deployment.Version1_5_0), + TypeAndVersion: deployment.NewTypeAndVersion(changeset.TokenAdminRegistry, deployment.Version1_5_0), ChainSelector: chain1, }, { Address: common.BigToAddress(big.NewInt(4)), - TypeAndVersion: deployment.NewTypeAndVersion(RegistryModule, deployment.Version1_5_0), + TypeAndVersion: deployment.NewTypeAndVersion(changeset.RegistryModule, deployment.Version1_5_0), ChainSelector: chain2, }, { Address: common.BigToAddress(big.NewInt(5)), - TypeAndVersion: deployment.NewTypeAndVersion(Router, deployment.Version1_2_0), + TypeAndVersion: deployment.NewTypeAndVersion(changeset.Router, deployment.Version1_2_0), ChainSelector: chain2, }, }, } - output, err := commonchangeset.SaveExistingContracts(e, cfg) + output, err := commonchangeset.SaveExistingContractsChangeset(e, cfg) require.NoError(t, err) err = e.ExistingAddresses.Merge(output.AddressBook) require.NoError(t, err) - state, err := LoadOnchainState(e) + state, err := changeset.LoadOnchainState(e) require.NoError(t, err) require.Equal(t, state.Chains[chain1].LinkToken.Address(), common.BigToAddress(big.NewInt(1))) require.Equal(t, state.Chains[chain1].Weth9.Address(), common.BigToAddress(big.NewInt(2))) diff --git a/deployment/ccip/changeset/state_test.go b/deployment/ccip/changeset/state_test.go index f7d06efa66d..c46df8b1dc7 100644 --- a/deployment/ccip/changeset/state_test.go +++ b/deployment/ccip/changeset/state_test.go @@ -1,14 +1,17 @@ -package changeset +package changeset_test import ( "testing" "github.com/stretchr/testify/require" + + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" ) func TestSmokeState(t *testing.T) { - tenv, _ := NewMemoryEnvironment(t, WithChains(3)) - state, err := LoadOnchainState(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) + state, err := changeset.LoadOnchainState(tenv.Env) require.NoError(t, err) _, err = state.View(tenv.Env.AllChainSelectors()) require.NoError(t, err) diff --git a/deployment/ccip/changeset/test_usdc_helpers.go b/deployment/ccip/changeset/test_usdc_helpers.go deleted file mode 100644 index c9dd87b866e..00000000000 --- a/deployment/ccip/changeset/test_usdc_helpers.go +++ /dev/null @@ -1,260 +0,0 @@ -package changeset - -import ( - "math/big" - - "golang.org/x/sync/errgroup" - - "github.com/ethereum/go-ethereum/common" - - "github.com/smartcontractkit/chainlink-ccip/pkg/reader" - "github.com/smartcontractkit/chainlink-common/pkg/logger" - - "github.com/smartcontractkit/chainlink/deployment" - "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" - "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_usdc_token_messenger" - "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_usdc_token_transmitter" - "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/usdc_token_pool" - "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/burn_mint_erc677" -) - -func ConfigureUSDCTokenPools( - lggr logger.Logger, - chains map[uint64]deployment.Chain, - src, dst uint64, - state CCIPOnChainState, -) (*burn_mint_erc677.BurnMintERC677, *burn_mint_erc677.BurnMintERC677, error) { - srcToken := state.Chains[src].BurnMintTokens677[USDCSymbol] - dstToken := state.Chains[dst].BurnMintTokens677[USDCSymbol] - srcPool := state.Chains[src].USDCTokenPool - dstPool := state.Chains[dst].USDCTokenPool - - args := []struct { - sourceChain deployment.Chain - dstChainSel uint64 - state CCIPChainState - srcToken *burn_mint_erc677.BurnMintERC677 - srcPool *usdc_token_pool.USDCTokenPool - dstToken *burn_mint_erc677.BurnMintERC677 - dstPool *usdc_token_pool.USDCTokenPool - }{ - { - chains[src], - dst, - state.Chains[src], - srcToken, - srcPool, - dstToken, - dstPool, - }, - { - chains[dst], - src, - state.Chains[dst], - dstToken, - dstPool, - srcToken, - srcPool, - }, - } - - configurePoolGrp := errgroup.Group{} - for _, arg := range args { - configurePoolGrp.Go(configureSingleChain(lggr, arg.sourceChain, arg.dstChainSel, arg.state, arg.srcToken, arg.srcPool, arg.dstToken, arg.dstPool)) - } - if err := configurePoolGrp.Wait(); err != nil { - return nil, nil, err - } - return srcToken, dstToken, nil -} - -func configureSingleChain( - lggr logger.Logger, - sourceChain deployment.Chain, - dstChainSel uint64, - state CCIPChainState, - srcToken *burn_mint_erc677.BurnMintERC677, - srcPool *usdc_token_pool.USDCTokenPool, - dstToken *burn_mint_erc677.BurnMintERC677, - dstPool *usdc_token_pool.USDCTokenPool, -) func() error { - return func() error { - if err := attachTokenToTheRegistry(sourceChain, state, sourceChain.DeployerKey, srcToken.Address(), srcPool.Address()); err != nil { - lggr.Errorw("Failed to attach token to the registry", "err", err, "token", srcToken.Address(), "pool", srcPool.Address()) - return err - } - - if err := setUSDCTokenPoolCounterPart(sourceChain, srcPool, dstChainSel, sourceChain.DeployerKey, dstToken.Address(), dstPool.Address()); err != nil { - lggr.Errorw("Failed to set counter part", "err", err, "srcPool", srcPool.Address(), "dstPool", dstPool.Address()) - return err - } - - for _, addr := range []common.Address{ - srcPool.Address(), - state.MockUSDCTokenMessenger.Address(), - state.MockUSDCTransmitter.Address(), - } { - if err := grantMintBurnPermissions(lggr, sourceChain, srcToken, sourceChain.DeployerKey, addr); err != nil { - lggr.Errorw("Failed to grant mint/burn permissions", "err", err, "token", srcToken.Address(), "address", addr) - return err - } - } - return nil - } -} - -func UpdateFeeQuoterForUSDC( - lggr logger.Logger, - chain deployment.Chain, - state CCIPChainState, - dstChain uint64, - usdcToken *burn_mint_erc677.BurnMintERC677, -) error { - config := []fee_quoter.FeeQuoterTokenTransferFeeConfigArgs{ - { - DestChainSelector: dstChain, - TokenTransferFeeConfigs: []fee_quoter.FeeQuoterTokenTransferFeeConfigSingleTokenArgs{ - { - Token: usdcToken.Address(), - TokenTransferFeeConfig: fee_quoter.FeeQuoterTokenTransferFeeConfig{ - MinFeeUSDCents: 50, - MaxFeeUSDCents: 50_000, - DeciBps: 0, - DestGasOverhead: 180_000, - DestBytesOverhead: 640, - IsEnabled: true, - }, - }, - }, - }, - } - - tx, err := state.FeeQuoter.ApplyTokenTransferFeeConfigUpdates( - chain.DeployerKey, - config, - []fee_quoter.FeeQuoterTokenTransferFeeConfigRemoveArgs{}, - ) - if err != nil { - lggr.Errorw("Failed to apply token transfer fee config updates", "err", err, "config", config) - return err - } - - _, err = chain.Confirm(tx) - return err -} - -func DeployUSDC( - lggr logger.Logger, - chain deployment.Chain, - addresses deployment.AddressBook, - rmnProxy common.Address, - router common.Address, -) ( - *burn_mint_erc677.BurnMintERC677, - *usdc_token_pool.USDCTokenPool, - *mock_usdc_token_messenger.MockE2EUSDCTokenMessenger, - *mock_usdc_token_transmitter.MockE2EUSDCTransmitter, - error, -) { - token, err := deployment.DeployContract(lggr, chain, addresses, - func(chain deployment.Chain) deployment.ContractDeploy[*burn_mint_erc677.BurnMintERC677] { - tokenAddress, tx, tokenContract, err2 := burn_mint_erc677.DeployBurnMintERC677( - chain.DeployerKey, - chain.Client, - USDCName, - string(USDCSymbol), - UsdcDecimals, - big.NewInt(0), - ) - return deployment.ContractDeploy[*burn_mint_erc677.BurnMintERC677]{ - Address: tokenAddress, - Contract: tokenContract, - Tx: tx, - Tv: deployment.NewTypeAndVersion(USDCToken, deployment.Version1_0_0), - Err: err2, - } - }) - if err != nil { - lggr.Errorw("Failed to deploy USDC token", "chain", chain.String(), "err", err) - return nil, nil, nil, nil, err - } - - tx, err := token.Contract.GrantMintRole(chain.DeployerKey, chain.DeployerKey.From) - if err != nil { - lggr.Errorw("Failed to grant mint role", "chain", chain.String(), "token", token.Contract.Address(), "err", err) - return nil, nil, nil, nil, err - } - _, err = chain.Confirm(tx) - if err != nil { - return nil, nil, nil, nil, err - } - - transmitter, err := deployment.DeployContract(lggr, chain, addresses, - func(chain deployment.Chain) deployment.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, - ) - return deployment.ContractDeploy[*mock_usdc_token_transmitter.MockE2EUSDCTransmitter]{ - Address: transmitterAddress, - Contract: transmitterContract, - Tx: tx, - Tv: deployment.NewTypeAndVersion(USDCMockTransmitter, deployment.Version1_0_0), - Err: err2, - } - }) - if err != nil { - lggr.Errorw("Failed to deploy mock USDC transmitter", "chain", chain.String(), "err", err) - return nil, nil, nil, nil, err - } - - messenger, err := deployment.DeployContract(lggr, chain, addresses, - func(chain deployment.Chain) deployment.ContractDeploy[*mock_usdc_token_messenger.MockE2EUSDCTokenMessenger] { - messengerAddress, tx, messengerContract, err2 := mock_usdc_token_messenger.DeployMockE2EUSDCTokenMessenger( - chain.DeployerKey, - chain.Client, - 0, - transmitter.Address, - ) - return deployment.ContractDeploy[*mock_usdc_token_messenger.MockE2EUSDCTokenMessenger]{ - Address: messengerAddress, - Contract: messengerContract, - Tx: tx, - Tv: deployment.NewTypeAndVersion(USDCTokenMessenger, deployment.Version1_0_0), - Err: err2, - } - }) - if err != nil { - lggr.Errorw("Failed to deploy USDC token messenger", "chain", chain.String(), "err", err) - return nil, nil, nil, nil, err - } - - tokenPool, err := deployment.DeployContract(lggr, chain, addresses, - func(chain deployment.Chain) deployment.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, - ) - return deployment.ContractDeploy[*usdc_token_pool.USDCTokenPool]{ - Address: tokenPoolAddress, - Contract: tokenPoolContract, - Tx: tx, - Tv: deployment.NewTypeAndVersion(USDCTokenPool, deployment.Version1_0_0), - Err: err2, - } - }) - if err != nil { - lggr.Errorw("Failed to deploy USDC token pool", "chain", chain.String(), "err", err) - return nil, nil, nil, nil, err - } - - return token.Contract, tokenPool.Contract, messenger.Contract, transmitter.Contract, nil -} diff --git a/deployment/ccip/changeset/test_assertions.go b/deployment/ccip/changeset/testhelpers/test_assertions.go similarity index 92% rename from deployment/ccip/changeset/test_assertions.go rename to deployment/ccip/changeset/testhelpers/test_assertions.go index ba1b5fa4a88..768788cef1a 100644 --- a/deployment/ccip/changeset/test_assertions.go +++ b/deployment/ccip/changeset/testhelpers/test_assertions.go @@ -1,4 +1,4 @@ -package changeset +package testhelpers import ( "context" @@ -19,6 +19,8 @@ import ( commonutils "github.com/smartcontractkit/chainlink-common/pkg/utils" "github.com/smartcontractkit/chainlink-common/pkg/utils/tests" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/environment/memory" "github.com/smartcontractkit/chainlink/deployment" @@ -29,7 +31,7 @@ import ( func ConfirmGasPriceUpdatedForAll( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, startBlocks map[uint64]*uint64, gasPrice *big.Int, ) { @@ -82,7 +84,7 @@ func ConfirmGasPriceUpdated( func ConfirmTokenPriceUpdatedForAll( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, startBlocks map[uint64]*uint64, linkPrice *big.Int, wethPrice *big.Int, @@ -167,7 +169,7 @@ type SourceDestPair struct { func ConfirmCommitForAllWithExpectedSeqNums( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, expectedSeqNums map[SourceDestPair]uint64, startBlocks map[uint64]*uint64, ) { @@ -267,7 +269,7 @@ func (c *commitReportTracker) allCommited(sourceChainSelector uint64) bool { func ConfirmMultipleCommits( t *testing.T, chains map[uint64]deployment.Chain, - state map[uint64]CCIPChainState, + state map[uint64]changeset.CCIPChainState, startBlocks map[uint64]*uint64, enforceSingleCommit bool, expectedSeqNums map[SourceDestPair]ccipocr3.SeqNumRange, @@ -413,7 +415,7 @@ func ConfirmCommitWithExpectedSeqNumRange( func ConfirmExecWithSeqNrsForAll( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, expectedSeqNums map[SourceDestPair][]uint64, startBlocks map[uint64]*uint64, ) (executionStates map[SourceDestPair]map[uint64]int) { @@ -656,3 +658,39 @@ func AssertEqualFeeConfig(t *testing.T, want, have fee_quoter.FeeQuoterDestChain assert.Equal(t, want.MaxNumberOfTokensPerMsg, have.MaxNumberOfTokensPerMsg) assert.Equal(t, want.MaxPerMsgGasLimit, have.MaxPerMsgGasLimit) } + +// AssertTimelockOwnership asserts that the ownership of the contracts has been transferred +// to the appropriate timelock contract on each chain. +func AssertTimelockOwnership( + t *testing.T, + e DeployedEnv, + chains []uint64, + state changeset.CCIPOnChainState, +) { + // check that the ownership has been transferred correctly + for _, chain := range chains { + for _, contract := range []common.Address{ + state.Chains[chain].OnRamp.Address(), + state.Chains[chain].OffRamp.Address(), + state.Chains[chain].FeeQuoter.Address(), + state.Chains[chain].NonceManager.Address(), + state.Chains[chain].RMNRemote.Address(), + } { + owner, _, err := commonchangeset.LoadOwnableContract(contract, e.Env.Chains[chain].Client) + require.NoError(t, err) + require.Equal(t, state.Chains[chain].Timelock.Address(), owner) + } + } + + // check home chain contracts ownership + homeChainTimelockAddress := state.Chains[e.HomeChainSel].Timelock.Address() + for _, contract := range []common.Address{ + state.Chains[e.HomeChainSel].CapabilityRegistry.Address(), + state.Chains[e.HomeChainSel].CCIPHome.Address(), + state.Chains[e.HomeChainSel].RMNHome.Address(), + } { + owner, _, err := commonchangeset.LoadOwnableContract(contract, e.Env.Chains[e.HomeChainSel].Client) + require.NoError(t, err) + require.Equal(t, homeChainTimelockAddress, owner) + } +} diff --git a/deployment/ccip/changeset/test_environment.go b/deployment/ccip/changeset/testhelpers/test_environment.go similarity index 82% rename from deployment/ccip/changeset/test_environment.go rename to deployment/ccip/changeset/testhelpers/test_environment.go index 16994211010..040dce9f17f 100644 --- a/deployment/ccip/changeset/test_environment.go +++ b/deployment/ccip/changeset/testhelpers/test_environment.go @@ -1,4 +1,4 @@ -package changeset +package testhelpers import ( "context" @@ -20,6 +20,7 @@ import ( jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/internal" "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types" @@ -44,7 +45,7 @@ type TestConfigs struct { // TODO: This should be CreateContracts so the booleans make sense? CreateJobAndContracts bool PrerequisiteDeploymentOnly bool - V1_5Cfg V1_5DeploymentConfig + V1_5Cfg changeset.V1_5DeploymentConfig Chains int // only used in memory mode, for docker mode, this is determined by the integration-test config toml input ChainIDs []uint64 // only used in memory mode, for docker mode, this is determined by the integration-test config toml input NumOfUsersPerChain int // only used in memory mode, for docker mode, this is determined by the integration-test config toml input @@ -53,7 +54,7 @@ type TestConfigs struct { IsUSDC bool IsUSDCAttestationMissing bool IsMultiCall3 bool - OCRConfigOverride func(CCIPOCRParams) CCIPOCRParams + OCRConfigOverride func(*changeset.CCIPOCRParams) RMNEnabled bool NumOfRMNNodes int LinkPrice *big.Int @@ -93,8 +94,8 @@ func DefaultTestConfigs() *TestConfigs { NumOfUsersPerChain: 1, Nodes: 4, Bootstraps: 1, - LinkPrice: MockLinkPrice, - WethPrice: MockWethPrice, + LinkPrice: changeset.MockLinkPrice, + WethPrice: changeset.MockWethPrice, CreateJobAndContracts: true, } } @@ -107,7 +108,7 @@ func WithMultiCall3() TestOps { } } -func WithPrerequisiteDeployment(v1_5Cfg *V1_5DeploymentConfig) TestOps { +func WithPrerequisiteDeploymentOnly(v1_5Cfg *changeset.V1_5DeploymentConfig) TestOps { return func(testCfg *TestConfigs) { testCfg.PrerequisiteDeploymentOnly = true if v1_5Cfg != nil { @@ -116,7 +117,7 @@ func WithPrerequisiteDeployment(v1_5Cfg *V1_5DeploymentConfig) TestOps { } } -func WithChainIds(chainIDs []uint64) TestOps { +func WithChainIDs(chainIDs []uint64) TestOps { return func(testCfg *TestConfigs) { testCfg.ChainIDs = chainIDs } @@ -143,7 +144,7 @@ func WithRMNEnabled(numOfNode int) TestOps { } } -func WithOCRConfigOverride(override func(CCIPOCRParams) CCIPOCRParams) TestOps { +func WithOCRConfigOverride(override func(*changeset.CCIPOCRParams)) TestOps { return func(testCfg *TestConfigs) { testCfg.OCRConfigOverride = override } @@ -161,25 +162,25 @@ func WithUSDC() TestOps { } } -func WithChains(numChains int) TestOps { +func WithNumOfChains(numChains int) TestOps { return func(testCfg *TestConfigs) { testCfg.Chains = numChains } } -func WithUsersPerChain(numUsers int) TestOps { +func WithNumOfUsersPerChain(numUsers int) TestOps { return func(testCfg *TestConfigs) { testCfg.NumOfUsersPerChain = numUsers } } -func WithNodes(numNodes int) TestOps { +func WithNumOfNodes(numNodes int) TestOps { return func(testCfg *TestConfigs) { testCfg.Nodes = numNodes } } -func WithBootstraps(numBootstraps int) TestOps { +func WithNumOfBootstrapNodes(numBootstraps int) TestOps { return func(testCfg *TestConfigs) { testCfg.Bootstraps = numBootstraps } @@ -205,7 +206,7 @@ type DeployedEnv struct { func (d *DeployedEnv) TimelockContracts(t *testing.T) map[uint64]*proposalutils.TimelockExecutionContracts { timelocks := make(map[uint64]*proposalutils.TimelockExecutionContracts) - state, err := LoadOnchainState(d.Env) + state, err := changeset.LoadOnchainState(d.Env) require.NoError(t, err) for chain, chainState := range state.Chains { timelocks[chain] = &proposalutils.TimelockExecutionContracts{ @@ -218,7 +219,7 @@ func (d *DeployedEnv) TimelockContracts(t *testing.T) map[uint64]*proposalutils. func (d *DeployedEnv) SetupJobs(t *testing.T) { ctx := testcontext.Get(t) - out, err := CCIPCapabilityJobspec(d.Env, struct{}{}) + out, err := changeset.CCIPCapabilityJobspecChangeset(d.Env, struct{}{}) require.NoError(t, err) for nodeID, jobs := range out.JobSpecs { for _, job := range jobs { @@ -354,21 +355,21 @@ func NewEnvironmentWithPrerequisitesContracts(t *testing.T, tEnv TestEnvironment for _, c := range e.Env.AllChainSelectors() { mcmsCfg[c] = proposalutils.SingleGroupTimelockConfig(t) } - var prereqCfg []DeployPrerequisiteConfigPerChain + prereqCfg := make([]changeset.DeployPrerequisiteConfigPerChain, 0) for _, chain := range allChains { - var opts []PrerequisiteOpt + var opts []changeset.PrerequisiteOpt if tc != nil { if tc.IsUSDC { - opts = append(opts, WithUSDCEnabled()) + opts = append(opts, changeset.WithUSDCEnabled()) } if tc.IsMultiCall3 { - opts = append(opts, WithMultiCall3Enabled()) + opts = append(opts, changeset.WithMultiCall3Enabled()) } } - if tc.V1_5Cfg != (V1_5DeploymentConfig{}) { - opts = append(opts, WithLegacyDeploymentEnabled(tc.V1_5Cfg)) + if tc.V1_5Cfg != (changeset.V1_5DeploymentConfig{}) { + opts = append(opts, changeset.WithLegacyDeploymentEnabled(tc.V1_5Cfg)) } - prereqCfg = append(prereqCfg, DeployPrerequisiteConfigPerChain{ + prereqCfg = append(prereqCfg, changeset.DeployPrerequisiteConfigPerChain{ ChainSelector: chain, Opts: opts, }) @@ -380,8 +381,8 @@ func NewEnvironmentWithPrerequisitesContracts(t *testing.T, tEnv TestEnvironment Config: allChains, }, { - Changeset: commonchangeset.WrapChangeSet(DeployPrerequisites), - Config: DeployPrerequisiteConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployPrerequisitesChangeset), + Config: changeset.DeployPrerequisiteConfig{ Configs: prereqCfg, }, }, @@ -422,18 +423,18 @@ func NewEnvironmentWithJobsAndContracts(t *testing.T, tEnv TestEnvironment) Depl mcmsCfg[c] = proposalutils.SingleGroupTimelockConfig(t) } - var prereqCfg []DeployPrerequisiteConfigPerChain + prereqCfg := make([]changeset.DeployPrerequisiteConfigPerChain, 0) for _, chain := range allChains { - var opts []PrerequisiteOpt + var opts []changeset.PrerequisiteOpt if tc != nil { if tc.IsUSDC { - opts = append(opts, WithUSDCEnabled()) + opts = append(opts, changeset.WithUSDCEnabled()) } if tc.IsMultiCall3 { - opts = append(opts, WithMultiCall3Enabled()) + opts = append(opts, changeset.WithMultiCall3Enabled()) } } - prereqCfg = append(prereqCfg, DeployPrerequisiteConfigPerChain{ + prereqCfg = append(prereqCfg, changeset.DeployPrerequisiteConfigPerChain{ ChainSelector: chain, Opts: opts, }) @@ -446,8 +447,8 @@ func NewEnvironmentWithJobsAndContracts(t *testing.T, tEnv TestEnvironment) Depl Config: allChains, }, { - Changeset: commonchangeset.WrapChangeSet(DeployPrerequisites), - Config: DeployPrerequisiteConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployPrerequisitesChangeset), + Config: changeset.DeployPrerequisiteConfig{ Configs: prereqCfg, }, }, @@ -462,8 +463,8 @@ func NewEnvironmentWithJobsAndContracts(t *testing.T, tEnv TestEnvironment) Depl // now we update RMNProxy to point to RMNRemote e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(SetRMNRemoteOnRMNProxy), - Config: SetRMNRemoteOnRMNProxyConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetRMNRemoteOnRMNProxyChangeset), + Config: changeset.SetRMNRemoteOnRMNProxyConfig{ ChainSelectors: allChains, }, }, @@ -481,8 +482,8 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn // no proposals to be made, timelock can be passed as nil here e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(DeployHomeChain), - Config: DeployHomeChainConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployHomeChainChangeset), + Config: changeset.DeployHomeChainConfig{ HomeChainSel: e.HomeChainSel, RMNDynamicConfig: NewTestRMNDynamicConfig(), RMNStaticConfig: NewTestRMNStaticConfig(), @@ -493,8 +494,8 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn }, }, { - Changeset: commonchangeset.WrapChangeSet(DeployChainContracts), - Config: DeployChainContractsConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.DeployChainContractsChangeset), + Config: changeset.DeployChainContractsConfig{ ChainSelectors: allChains, HomeChainSelector: e.HomeChainSel, }, @@ -502,13 +503,13 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn }) require.NoError(t, err) - state, err := LoadOnchainState(e.Env) + state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) // Assert link present require.NotNil(t, state.Chains[e.FeedChainSel].LinkToken) require.NotNil(t, state.Chains[e.FeedChainSel].Weth9) - tokenConfig := NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) + tokenConfig := changeset.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) var tokenDataProviders []pluginconfig.TokenDataObserverConfig if tc.IsUSDC { endpoint := tEnv.MockUSDCAttestationServer(t, tc.IsUSDCAttestationMissing) @@ -533,8 +534,8 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn }}) } // Build the per chain config. - ocrConfigs := make(map[uint64]CCIPOCRParams) - chainConfigs := make(map[uint64]ChainConfig) + ocrConfigs := make(map[uint64]changeset.CCIPOCRParams) + chainConfigs := make(map[uint64]changeset.ChainConfig) timelockContractsPerChain := make(map[uint64]*proposalutils.TimelockExecutionContracts) nodeInfo, err := deployment.NodeInfo(e.Env.NodeIDs, e.Env.Offchain) require.NoError(t, err) @@ -544,12 +545,12 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn CallProxy: state.Chains[chain].CallProxy, } tokenInfo := tokenConfig.GetTokenInfo(e.Env.Logger, state.Chains[chain].LinkToken, state.Chains[chain].Weth9) - ocrParams := DefaultOCRParams(e.FeedChainSel, tokenInfo, tokenDataProviders, true, true) - if tc.OCRConfigOverride != nil { - ocrParams = tc.OCRConfigOverride(ocrParams) - } + ocrParams := changeset.DeriveCCIPOCRParams(changeset.WithDefaultCommitOffChainConfig(e.FeedChainSel, tokenInfo), + changeset.WithDefaultExecuteOffChainConfig(tokenDataProviders), + changeset.WithOCRParamOverride(tc.OCRConfigOverride), + ) ocrConfigs[chain] = ocrParams - chainConfigs[chain] = ChainConfig{ + chainConfigs[chain] = changeset.ChainConfig{ Readers: nodeInfo.NonBootstraps().PeerIDs(), FChain: uint8(len(nodeInfo.NonBootstraps().PeerIDs()) / 3), EncodableChainConfig: chainconfig.ChainConfig{ @@ -563,21 +564,21 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, timelockContractsPerChain, []commonchangeset.ChangesetApplication{ { // Add the chain configs for the new chains. - Changeset: commonchangeset.WrapChangeSet(UpdateChainConfig), - Config: UpdateChainConfigConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateChainConfigChangeset), + Config: changeset.UpdateChainConfigConfig{ HomeChainSelector: e.HomeChainSel, RemoteChainAdds: chainConfigs, }, }, { // Add the DONs and candidate commit OCR instances for the chain. - Changeset: commonchangeset.WrapChangeSet(AddDonAndSetCandidateChangeset), - Config: AddDonAndSetCandidateChangesetConfig{ - SetCandidateConfigBase: SetCandidateConfigBase{ + Changeset: commonchangeset.WrapChangeSet(changeset.AddDonAndSetCandidateChangeset), + Config: changeset.AddDonAndSetCandidateChangesetConfig{ + SetCandidateConfigBase: changeset.SetCandidateConfigBase{ HomeChainSelector: e.HomeChainSel, FeedChainSelector: e.FeedChainSel, }, - PluginInfo: SetCandidatePluginInfo{ + PluginInfo: changeset.SetCandidatePluginInfo{ OCRConfigPerRemoteChainSelector: ocrConfigs, PluginType: types.PluginTypeCCIPCommit, }, @@ -585,13 +586,13 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn }, { // Add the exec OCR instances for the new chains. - Changeset: commonchangeset.WrapChangeSet(SetCandidateChangeset), - Config: SetCandidateChangesetConfig{ - SetCandidateConfigBase: SetCandidateConfigBase{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetCandidateChangeset), + Config: changeset.SetCandidateChangesetConfig{ + SetCandidateConfigBase: changeset.SetCandidateConfigBase{ HomeChainSelector: e.HomeChainSel, FeedChainSelector: e.FeedChainSel, }, - PluginInfo: []SetCandidatePluginInfo{ + PluginInfo: []changeset.SetCandidatePluginInfo{ { OCRConfigPerRemoteChainSelector: ocrConfigs, PluginType: types.PluginTypeCCIPExec, @@ -601,10 +602,10 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn }, { // Promote everything - Changeset: commonchangeset.WrapChangeSet(PromoteCandidateChangeset), - Config: PromoteCandidateChangesetConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.PromoteCandidateChangeset), + Config: changeset.PromoteCandidateChangesetConfig{ HomeChainSelector: e.HomeChainSel, - PluginInfo: []PromoteCandidatePluginInfo{ + PluginInfo: []changeset.PromoteCandidatePluginInfo{ { PluginType: types.PluginTypeCCIPCommit, RemoteChainSelectors: allChains, @@ -618,21 +619,21 @@ func AddCCIPContractsToEnvironment(t *testing.T, allChains []uint64, tEnv TestEn }, { // Enable the OCR config on the remote chains. - Changeset: commonchangeset.WrapChangeSet(SetOCR3OffRamp), - Config: SetOCR3OffRampConfig{ + Changeset: commonchangeset.WrapChangeSet(changeset.SetOCR3OffRampChangeset), + Config: changeset.SetOCR3OffRampConfig{ HomeChainSel: e.HomeChainSel, RemoteChainSels: allChains, }, }, { - Changeset: commonchangeset.WrapChangeSet(CCIPCapabilityJobspec), + Changeset: commonchangeset.WrapChangeSet(changeset.CCIPCapabilityJobspecChangeset), }, }) require.NoError(t, err) ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks) - state, err = LoadOnchainState(e.Env) + state, err = changeset.LoadOnchainState(e.Env) require.NoError(t, err) require.NotNil(t, state.Chains[e.HomeChainSel].CapabilityRegistry) require.NotNil(t, state.Chains[e.HomeChainSel].CCIPHome) diff --git a/deployment/ccip/changeset/test_helpers.go b/deployment/ccip/changeset/testhelpers/test_helpers.go similarity index 89% rename from deployment/ccip/changeset/test_helpers.go rename to deployment/ccip/changeset/testhelpers/test_helpers.go index e0edbc93e12..fc08dc3c6b3 100644 --- a/deployment/ccip/changeset/test_helpers.go +++ b/deployment/ccip/changeset/testhelpers/test_helpers.go @@ -1,4 +1,4 @@ -package changeset +package testhelpers import ( "context" @@ -18,8 +18,10 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/pkg/errors" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" commoncs "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/keystone/generated/capabilities_registry" "github.com/smartcontractkit/chainlink/v2/core/services/relay" "github.com/ethereum/go-ethereum/common" @@ -105,11 +107,16 @@ func DeployTestContracts(t *testing.T, linkPrice *big.Int, wethPrice *big.Int, ) deployment.CapabilityRegistryConfig { - capReg, err := deployCapReg(lggr, - // deploying cap reg for the first time on a blank chain state - CCIPOnChainState{ - Chains: make(map[uint64]CCIPChainState), - }, ab, chains[homeChainSel]) + capReg, err := deployment.DeployContract(lggr, chains[homeChainSel], ab, + func(chain deployment.Chain) deployment.ContractDeploy[*capabilities_registry.CapabilitiesRegistry] { + crAddr, tx, cr, err2 := capabilities_registry.DeployCapabilitiesRegistry( + chain.DeployerKey, + chain.Client, + ) + return deployment.ContractDeploy[*capabilities_registry.CapabilitiesRegistry]{ + Address: crAddr, Contract: cr, Tv: deployment.NewTypeAndVersion(changeset.CapabilitiesRegistry, deployment.Version1_0_0), Tx: tx, Err: err2, + } + }) require.NoError(t, err) _, err = DeployFeeds(lggr, ab, chains[feedChainSel], linkPrice, wethPrice) @@ -178,7 +185,7 @@ func mockAttestationResponse(isFaulty bool) *httptest.Server { func CCIPSendRequest( e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, cfg *CCIPSendReqConfig, ) (*types.Transaction, uint64, error) { msg := router.ClientEVM2AnyMessage{ @@ -266,7 +273,7 @@ func CCIPSendCalldata( func TestSendRequest( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, src, dest uint64, testRouter bool, evm2AnyMessage router.ClientEVM2AnyMessage, @@ -325,7 +332,7 @@ func WithDestChain(destChain uint64) SendReqOpts { func DoSendRequest( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, opts ...SendReqOpts, ) (*onramp.OnRampCCIPMessageSent, error) { cfg := &CCIPSendReqConfig{} @@ -394,9 +401,9 @@ func AddLane(t *testing.T, e *DeployedEnv, from, to uint64, isTestRouter bool, g var err error e.Env, err = commoncs.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commoncs.ChangesetApplication{ { - Changeset: commoncs.WrapChangeSet(UpdateOnRampsDests), - Config: UpdateOnRampDestsConfig{ - UpdatesByChain: map[uint64]map[uint64]OnRampDestinationUpdate{ + Changeset: commoncs.WrapChangeSet(changeset.UpdateOnRampsDestsChangeset), + Config: changeset.UpdateOnRampDestsConfig{ + UpdatesByChain: map[uint64]map[uint64]changeset.OnRampDestinationUpdate{ from: { to: { IsEnabled: true, @@ -408,9 +415,9 @@ func AddLane(t *testing.T, e *DeployedEnv, from, to uint64, isTestRouter bool, g }, }, { - Changeset: commoncs.WrapChangeSet(UpdateFeeQuoterPricesCS), - Config: UpdateFeeQuoterPricesConfig{ - PricesByChain: map[uint64]FeeQuoterPriceUpdatePerSource{ + Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterPricesChangeset), + Config: changeset.UpdateFeeQuoterPricesConfig{ + PricesByChain: map[uint64]changeset.FeeQuoterPriceUpdatePerSource{ from: { TokenPrices: tokenPrices, GasPrices: gasprice, @@ -419,8 +426,8 @@ func AddLane(t *testing.T, e *DeployedEnv, from, to uint64, isTestRouter bool, g }, }, { - Changeset: commoncs.WrapChangeSet(UpdateFeeQuoterDests), - Config: UpdateFeeQuoterDestsConfig{ + Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterDestsChangeset), + Config: changeset.UpdateFeeQuoterDestsConfig{ UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{ from: { to: fqCfg, @@ -429,9 +436,9 @@ func AddLane(t *testing.T, e *DeployedEnv, from, to uint64, isTestRouter bool, g }, }, { - Changeset: commoncs.WrapChangeSet(UpdateOffRampSources), - Config: UpdateOffRampSourcesConfig{ - UpdatesByChain: map[uint64]map[uint64]OffRampSourceUpdate{ + Changeset: commoncs.WrapChangeSet(changeset.UpdateOffRampSourcesChangeset), + Config: changeset.UpdateOffRampSourcesConfig{ + UpdatesByChain: map[uint64]map[uint64]changeset.OffRampSourceUpdate{ to: { from: { IsEnabled: true, @@ -442,10 +449,10 @@ func AddLane(t *testing.T, e *DeployedEnv, from, to uint64, isTestRouter bool, g }, }, { - Changeset: commoncs.WrapChangeSet(UpdateRouterRamps), - Config: UpdateRouterRampsConfig{ + Changeset: commoncs.WrapChangeSet(changeset.UpdateRouterRampsChangeset), + Config: changeset.UpdateRouterRampsConfig{ TestRouter: isTestRouter, - UpdatesByChain: map[uint64]RouterUpdates{ + UpdatesByChain: map[uint64]changeset.RouterUpdates{ // onRamp update on source chain from: { OnRampUpdates: map[uint64]bool{ @@ -465,7 +472,7 @@ func AddLane(t *testing.T, e *DeployedEnv, from, to uint64, isTestRouter bool, g require.NoError(t, err) } -func AddLaneWithDefaultPricesAndFeeQuoterConfig(t *testing.T, e *DeployedEnv, state CCIPOnChainState, from, to uint64, isTestRouter bool) { +func AddLaneWithDefaultPricesAndFeeQuoterConfig(t *testing.T, e *DeployedEnv, state changeset.CCIPOnChainState, from, to uint64, isTestRouter bool) { stateChainFrom := state.Chains[from] AddLane(t, e, from, to, isTestRouter, map[uint64]*big.Int{ @@ -473,12 +480,12 @@ func AddLaneWithDefaultPricesAndFeeQuoterConfig(t *testing.T, e *DeployedEnv, st }, map[common.Address]*big.Int{ stateChainFrom.LinkToken.Address(): DefaultLinkPrice, stateChainFrom.Weth9.Address(): DefaultWethPrice, - }, DefaultFeeQuoterDestChainConfig()) + }, changeset.DefaultFeeQuoterDestChainConfig()) } // AddLanesForAll adds densely connected lanes for all chains in the environment so that each chain // is connected to every other chain except itself. -func AddLanesForAll(t *testing.T, e *DeployedEnv, state CCIPOnChainState) { +func AddLanesForAll(t *testing.T, e *DeployedEnv, state changeset.CCIPOnChainState) { for source := range e.Env.Chains { for dest := range e.Env.Chains { if source != dest { @@ -493,31 +500,6 @@ func ToPackedFee(execFee, daFee *big.Int) *big.Int { return new(big.Int).Or(daShifted, execFee) } -const ( - // MockLinkAggregatorDescription This is the description of the MockV3Aggregator.sol contract - //nolint:lll - // https://github.com/smartcontractkit/chainlink/blob/a348b98e90527520049c580000a86fb8ceff7fa7/contracts/src/v0.8/tests/MockV3Aggregator.sol#L76-L76 - MockLinkAggregatorDescription = "v0.8/tests/MockV3Aggregator.sol" - // MockWETHAggregatorDescription WETH use description from MockETHUSDAggregator.sol - //nolint:lll - // https://github.com/smartcontractkit/chainlink/blob/a348b98e90527520049c580000a86fb8ceff7fa7/contracts/src/v0.8/automation/testhelpers/MockETHUSDAggregator.sol#L19-L19 - MockWETHAggregatorDescription = "MockETHUSDAggregator" -) - -var ( - MockLinkPrice = deployment.E18Mult(500) - MockWethPrice = big.NewInt(9e8) - // MockDescriptionToTokenSymbol maps a mock feed description to token descriptor - MockDescriptionToTokenSymbol = map[string]TokenSymbol{ - MockLinkAggregatorDescription: LinkSymbol, - MockWETHAggregatorDescription: WethSymbol, - } - MockSymbolToDescription = map[TokenSymbol]string{ - LinkSymbol: MockLinkAggregatorDescription, - WethSymbol: MockWETHAggregatorDescription, - } -) - func DeployFeeds( lggr logger.Logger, ab deployment.AddressBook, @@ -525,13 +507,13 @@ func DeployFeeds( linkPrice *big.Int, wethPrice *big.Int, ) (map[string]common.Address, error) { - linkTV := deployment.NewTypeAndVersion(PriceFeed, deployment.Version1_0_0) + linkTV := deployment.NewTypeAndVersion(changeset.PriceFeed, deployment.Version1_0_0) mockLinkFeed := func(chain deployment.Chain) deployment.ContractDeploy[*aggregator_v3_interface.AggregatorV3Interface] { linkFeed, tx, _, err1 := mock_v3_aggregator_contract.DeployMockV3Aggregator( chain.DeployerKey, chain.Client, - LinkDecimals, // decimals - linkPrice, // initialAnswer + changeset.LinkDecimals, // decimals + linkPrice, // initialAnswer ) aggregatorCr, err2 := aggregator_v3_interface.NewAggregatorV3Interface(linkFeed, chain.Client) @@ -553,12 +535,12 @@ func DeployFeeds( } } - linkFeedAddress, linkFeedDescription, err := deploySingleFeed(lggr, ab, chain, mockLinkFeed, LinkSymbol) + linkFeedAddress, linkFeedDescription, err := deploySingleFeed(lggr, ab, chain, mockLinkFeed, changeset.LinkSymbol) if err != nil { return nil, err } - wethFeedAddress, wethFeedDescription, err := deploySingleFeed(lggr, ab, chain, mockWethFeed, WethSymbol) + wethFeedAddress, wethFeedDescription, err := deploySingleFeed(lggr, ab, chain, mockWethFeed, changeset.WethSymbol) if err != nil { return nil, err } @@ -576,7 +558,7 @@ func deploySingleFeed( ab deployment.AddressBook, chain deployment.Chain, deployFunc func(deployment.Chain) deployment.ContractDeploy[*aggregator_v3_interface.AggregatorV3Interface], - symbol TokenSymbol, + symbol changeset.TokenSymbol, ) (common.Address, string, error) { // tokenTV := deployment.NewTypeAndVersion(PriceFeed, deployment.Version1_0_0) mockTokenFeed, err := deployment.DeployContract(lggr, chain, ab, deployFunc) @@ -593,7 +575,7 @@ func deploySingleFeed( return common.Address{}, "", err } - if desc != MockSymbolToDescription[symbol] { + if desc != changeset.MockSymbolToDescription[symbol] { lggr.Errorw("Unexpected description for token", "symbol", symbol, "desc", desc) return common.Address{}, "", fmt.Errorf("unexpected description: %s", desc) } @@ -601,7 +583,7 @@ func deploySingleFeed( return mockTokenFeed.Address, desc, nil } -func ConfirmRequestOnSourceAndDest(t *testing.T, env deployment.Environment, state CCIPOnChainState, sourceCS, destCS, expectedSeqNr uint64) error { +func ConfirmRequestOnSourceAndDest(t *testing.T, env deployment.Environment, state changeset.CCIPOnChainState, sourceCS, destCS, expectedSeqNr uint64) error { latesthdr, err := env.Chains[destCS].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) startBlock := latesthdr.Number.Uint64() @@ -645,7 +627,7 @@ func DeployTransferableToken( chains map[uint64]deployment.Chain, src, dst uint64, srcActor, dstActor *bind.TransactOpts, - state CCIPOnChainState, + state changeset.CCIPOnChainState, addresses deployment.AddressBook, token string, ) (*burn_mint_erc677.BurnMintERC677, *burn_mint_token_pool.BurnMintTokenPool, *burn_mint_erc677.BurnMintERC677, *burn_mint_token_pool.BurnMintTokenPool, error) { @@ -689,7 +671,7 @@ func deployTokenPoolsInParallel( chains map[uint64]deployment.Chain, src, dst uint64, srcActor, dstActor *bind.TransactOpts, - state CCIPOnChainState, + state changeset.CCIPOnChainState, addresses deployment.AddressBook, token string, ) ( @@ -833,7 +815,7 @@ func setTokenPoolCounterPart(chain deployment.Chain, tokenPool *burn_mint_token_ func attachTokenToTheRegistry( chain deployment.Chain, - state CCIPChainState, + state changeset.CCIPChainState, owner *bind.TransactOpts, token common.Address, tokenPool common.Address, @@ -889,10 +871,10 @@ func deployTransferTokenOneEnd( return nil, nil, err } for address, v := range chainAddresses { - if deployment.NewTypeAndVersion(ARMProxy, deployment.Version1_0_0) == v { + if deployment.NewTypeAndVersion(changeset.ARMProxy, deployment.Version1_0_0) == v { rmnAddress = address } - if deployment.NewTypeAndVersion(Router, deployment.Version1_2_0) == v { + if deployment.NewTypeAndVersion(changeset.Router, deployment.Version1_2_0) == v { routerAddress = address } if rmnAddress != "" && routerAddress != "" { @@ -913,7 +895,7 @@ func deployTransferTokenOneEnd( big.NewInt(0).Mul(big.NewInt(1e9), big.NewInt(1e18)), ) return deployment.ContractDeploy[*burn_mint_erc677.BurnMintERC677]{ - Address: tokenAddress, Contract: token, Tx: tx, Tv: deployment.NewTypeAndVersion(BurnMintToken, deployment.Version1_0_0), Err: err2, + Address: tokenAddress, Contract: token, Tx: tx, Tv: deployment.NewTypeAndVersion(changeset.BurnMintToken, deployment.Version1_0_0), Err: err2, } }) if err != nil { @@ -942,7 +924,7 @@ func deployTransferTokenOneEnd( common.HexToAddress(routerAddress), ) return deployment.ContractDeploy[*burn_mint_token_pool.BurnMintTokenPool]{ - Address: tokenPoolAddress, Contract: tokenPoolContract, Tx: tx, Tv: deployment.NewTypeAndVersion(BurnMintTokenPool, deployment.Version1_5_1), Err: err2, + Address: tokenPoolAddress, Contract: tokenPoolContract, Tx: tx, Tv: deployment.NewTypeAndVersion(changeset.BurnMintTokenPool, deployment.Version1_5_1), Err: err2, } }) if err != nil { @@ -971,7 +953,7 @@ func NewMintTokenWithCustomSender(auth *bind.TransactOpts, sender *bind.Transact func MintAndAllow( t *testing.T, e deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, tokenMap map[uint64][]MintTokenInfo, ) { configurePoolGrp := errgroup.Group{} @@ -1014,7 +996,7 @@ func Transfer( ctx context.Context, t *testing.T, env deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, sourceChain, destChain uint64, tokens []router.ClientEVMTokenAmount, receiver common.Address, @@ -1060,7 +1042,7 @@ func TransferMultiple( ctx context.Context, t *testing.T, env deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, requests []TestTransferRequest, ) ( map[uint64]*uint64, @@ -1114,7 +1096,7 @@ func TransferAndWaitForSuccess( ctx context.Context, t *testing.T, env deployment.Environment, - state CCIPOnChainState, + state changeset.CCIPOnChainState, sourceChain, destChain uint64, tokens []router.ClientEVMTokenAmount, receiver common.Address, @@ -1253,3 +1235,41 @@ func DefaultRouterMessage(receiverAddress common.Address) router.ClientEVM2AnyMe ExtraArgs: nil, } } + +func GenTestTransferOwnershipConfig( + e DeployedEnv, + chains []uint64, + state changeset.CCIPOnChainState, +) commoncs.TransferToMCMSWithTimelockConfig { + var ( + timelocksPerChain = make(map[uint64]common.Address) + contracts = make(map[uint64][]common.Address) + ) + + // chain contracts + for _, chain := range chains { + timelocksPerChain[chain] = state.Chains[chain].Timelock.Address() + contracts[chain] = []common.Address{ + state.Chains[chain].OnRamp.Address(), + state.Chains[chain].OffRamp.Address(), + state.Chains[chain].FeeQuoter.Address(), + state.Chains[chain].NonceManager.Address(), + state.Chains[chain].RMNRemote.Address(), + state.Chains[chain].TestRouter.Address(), + state.Chains[chain].Router.Address(), + } + } + + // home chain + homeChainTimelockAddress := state.Chains[e.HomeChainSel].Timelock.Address() + timelocksPerChain[e.HomeChainSel] = homeChainTimelockAddress + contracts[e.HomeChainSel] = append(contracts[e.HomeChainSel], + state.Chains[e.HomeChainSel].CapabilityRegistry.Address(), + state.Chains[e.HomeChainSel].CCIPHome.Address(), + state.Chains[e.HomeChainSel].RMNHome.Address(), + ) + + return commoncs.TransferToMCMSWithTimelockConfig{ + ContractsByChain: contracts, + } +} diff --git a/deployment/ccip/changeset/test_params.go b/deployment/ccip/changeset/testhelpers/test_params.go similarity index 97% rename from deployment/ccip/changeset/test_params.go rename to deployment/ccip/changeset/testhelpers/test_params.go index 90331b50675..8e43c08919f 100644 --- a/deployment/ccip/changeset/test_params.go +++ b/deployment/ccip/changeset/testhelpers/test_params.go @@ -1,4 +1,4 @@ -package changeset +package testhelpers import ( "github.com/ethereum/go-ethereum/common" diff --git a/deployment/ccip/changeset/testhelpers/test_usdc_helpers.go b/deployment/ccip/changeset/testhelpers/test_usdc_helpers.go new file mode 100644 index 00000000000..ebaa3b8ec37 --- /dev/null +++ b/deployment/ccip/changeset/testhelpers/test_usdc_helpers.go @@ -0,0 +1,140 @@ +package testhelpers + +import ( + "golang.org/x/sync/errgroup" + + "github.com/ethereum/go-ethereum/common" + + "github.com/smartcontractkit/chainlink-common/pkg/logger" + + "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/usdc_token_pool" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/burn_mint_erc677" +) + +func ConfigureUSDCTokenPools( + lggr logger.Logger, + chains map[uint64]deployment.Chain, + src, dst uint64, + state changeset.CCIPOnChainState, +) (*burn_mint_erc677.BurnMintERC677, *burn_mint_erc677.BurnMintERC677, error) { + srcToken := state.Chains[src].BurnMintTokens677[changeset.USDCSymbol] + dstToken := state.Chains[dst].BurnMintTokens677[changeset.USDCSymbol] + srcPool := state.Chains[src].USDCTokenPool + dstPool := state.Chains[dst].USDCTokenPool + + args := []struct { + sourceChain deployment.Chain + dstChainSel uint64 + state changeset.CCIPChainState + srcToken *burn_mint_erc677.BurnMintERC677 + srcPool *usdc_token_pool.USDCTokenPool + dstToken *burn_mint_erc677.BurnMintERC677 + dstPool *usdc_token_pool.USDCTokenPool + }{ + { + chains[src], + dst, + state.Chains[src], + srcToken, + srcPool, + dstToken, + dstPool, + }, + { + chains[dst], + src, + state.Chains[dst], + dstToken, + dstPool, + srcToken, + srcPool, + }, + } + + configurePoolGrp := errgroup.Group{} + for _, arg := range args { + configurePoolGrp.Go(configureSingleChain(lggr, arg.sourceChain, arg.dstChainSel, arg.state, arg.srcToken, arg.srcPool, arg.dstToken, arg.dstPool)) + } + if err := configurePoolGrp.Wait(); err != nil { + return nil, nil, err + } + return srcToken, dstToken, nil +} + +func configureSingleChain( + lggr logger.Logger, + sourceChain deployment.Chain, + dstChainSel uint64, + state changeset.CCIPChainState, + srcToken *burn_mint_erc677.BurnMintERC677, + srcPool *usdc_token_pool.USDCTokenPool, + dstToken *burn_mint_erc677.BurnMintERC677, + dstPool *usdc_token_pool.USDCTokenPool, +) func() error { + return func() error { + if err := attachTokenToTheRegistry(sourceChain, state, sourceChain.DeployerKey, srcToken.Address(), srcPool.Address()); err != nil { + lggr.Errorw("Failed to attach token to the registry", "err", err, "token", srcToken.Address(), "pool", srcPool.Address()) + return err + } + + if err := setUSDCTokenPoolCounterPart(sourceChain, srcPool, dstChainSel, sourceChain.DeployerKey, dstToken.Address(), dstPool.Address()); err != nil { + lggr.Errorw("Failed to set counter part", "err", err, "srcPool", srcPool.Address(), "dstPool", dstPool.Address()) + return err + } + + for _, addr := range []common.Address{ + srcPool.Address(), + state.MockUSDCTokenMessenger.Address(), + state.MockUSDCTransmitter.Address(), + } { + if err := grantMintBurnPermissions(lggr, sourceChain, srcToken, sourceChain.DeployerKey, addr); err != nil { + lggr.Errorw("Failed to grant mint/burn permissions", "err", err, "token", srcToken.Address(), "address", addr) + return err + } + } + return nil + } +} + +func UpdateFeeQuoterForUSDC( + lggr logger.Logger, + chain deployment.Chain, + state changeset.CCIPChainState, + dstChain uint64, + usdcToken *burn_mint_erc677.BurnMintERC677, +) error { + config := []fee_quoter.FeeQuoterTokenTransferFeeConfigArgs{ + { + DestChainSelector: dstChain, + TokenTransferFeeConfigs: []fee_quoter.FeeQuoterTokenTransferFeeConfigSingleTokenArgs{ + { + Token: usdcToken.Address(), + TokenTransferFeeConfig: fee_quoter.FeeQuoterTokenTransferFeeConfig{ + MinFeeUSDCents: 50, + MaxFeeUSDCents: 50_000, + DeciBps: 0, + DestGasOverhead: 180_000, + DestBytesOverhead: 640, + IsEnabled: true, + }, + }, + }, + }, + } + + tx, err := state.FeeQuoter.ApplyTokenTransferFeeConfigUpdates( + chain.DeployerKey, + config, + []fee_quoter.FeeQuoterTokenTransferFeeConfigRemoveArgs{}, + ) + if err != nil { + lggr.Errorw("Failed to apply token transfer fee config updates", "err", err, "config", config) + return err + } + + _, err = chain.Confirm(tx) + return err +} diff --git a/deployment/ccip/changeset/v1_5/test_helpers.go b/deployment/ccip/changeset/testhelpers/v1_5/test_helpers.go similarity index 87% rename from deployment/ccip/changeset/v1_5/test_helpers.go rename to deployment/ccip/changeset/testhelpers/v1_5/test_helpers.go index 671089a5546..be2804c6527 100644 --- a/deployment/ccip/changeset/v1_5/test_helpers.go +++ b/deployment/ccip/changeset/testhelpers/v1_5/test_helpers.go @@ -21,35 +21,37 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" + v1_5changeset "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/v1_5" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/deployment/environment/memory" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/commit_store" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/evm_2_evm_offramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/evm_2_evm_onramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/price_registry_1_2_0" - "github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/testhelpers" + plugintesthelpers "github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/testhelpers" ) -func AddLanes(t *testing.T, e deployment.Environment, state changeset.CCIPOnChainState, pairs []changeset.SourceDestPair) deployment.Environment { +func AddLanes(t *testing.T, e deployment.Environment, state changeset.CCIPOnChainState, pairs []testhelpers.SourceDestPair) deployment.Environment { addLanesCfg, commitOCR2Configs, execOCR2Configs, jobspecs := LaneConfigsForChains(t, e, state, pairs) var err error e, err = commonchangeset.ApplyChangesets(t, e, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(DeployLanes), - Config: DeployLanesConfig{ + Changeset: commonchangeset.WrapChangeSet(v1_5changeset.DeployLanesChangeset), + Config: v1_5changeset.DeployLanesConfig{ Configs: addLanesCfg, }, }, { - Changeset: commonchangeset.WrapChangeSet(SetOCR2ConfigForTest), - Config: OCR2Config{ + Changeset: commonchangeset.WrapChangeSet(v1_5changeset.SetOCR2ConfigForTestChangeset), + Config: v1_5changeset.OCR2Config{ CommitConfigs: commitOCR2Configs, ExecConfigs: execOCR2Configs, }, }, { - Changeset: commonchangeset.WrapChangeSet(JobSpecsForLanes), - Config: JobSpecsForLanesConfig{ + Changeset: commonchangeset.WrapChangeSet(v1_5changeset.JobSpecsForLanesChangeset), + Config: v1_5changeset.JobSpecsForLanesConfig{ Configs: jobspecs, }, }, @@ -58,16 +60,16 @@ func AddLanes(t *testing.T, e deployment.Environment, state changeset.CCIPOnChai return e } -func LaneConfigsForChains(t *testing.T, env deployment.Environment, state changeset.CCIPOnChainState, pairs []changeset.SourceDestPair) ( - []DeployLaneConfig, - []CommitOCR2ConfigParams, - []ExecuteOCR2ConfigParams, - []JobSpecInput, +func LaneConfigsForChains(t *testing.T, env deployment.Environment, state changeset.CCIPOnChainState, pairs []testhelpers.SourceDestPair) ( + []v1_5changeset.DeployLaneConfig, + []v1_5changeset.CommitOCR2ConfigParams, + []v1_5changeset.ExecuteOCR2ConfigParams, + []v1_5changeset.JobSpecInput, ) { - var addLanesCfg []DeployLaneConfig - var commitOCR2Configs []CommitOCR2ConfigParams - var execOCR2Configs []ExecuteOCR2ConfigParams - var jobSpecs []JobSpecInput + addLanesCfg := make([]v1_5changeset.DeployLaneConfig, 0) + commitOCR2Configs := make([]v1_5changeset.CommitOCR2ConfigParams, 0) + execOCR2Configs := make([]v1_5changeset.ExecuteOCR2ConfigParams, 0) + jobSpecs := make([]v1_5changeset.JobSpecInput, 0) for _, pair := range pairs { dest := pair.DestChainSelector src := pair.SourceChainSelector @@ -91,7 +93,7 @@ func LaneConfigsForChains(t *testing.T, env deployment.Environment, state change require.NoError(t, err) destEVMChainId, err := strconv.ParseUint(destEVMChainIdStr, 10, 64) require.NoError(t, err) - jobSpecs = append(jobSpecs, JobSpecInput{ + jobSpecs = append(jobSpecs, v1_5changeset.JobSpecInput{ SourceChainSelector: src, DestinationChainSelector: dest, DestEVMChainID: destEVMChainId, @@ -100,7 +102,7 @@ func LaneConfigsForChains(t *testing.T, env deployment.Environment, state change }) srcLinkTokenAddr, err := sourceChainState.LinkTokenAddress() require.NoError(t, err) - addLanesCfg = append(addLanesCfg, DeployLaneConfig{ + addLanesCfg = append(addLanesCfg, v1_5changeset.DeployLaneConfig{ SourceChainSelector: src, DestinationChainSelector: dest, OnRampStaticCfg: evm_2_evm_onramp.EVM2EVMOnRampStaticConfig{ @@ -157,13 +159,13 @@ func LaneConfigsForChains(t *testing.T, env deployment.Environment, state change OnRampNopsAndWeight: []evm_2_evm_onramp.EVM2EVMOnRampNopAndWeight{}, OnRampRateLimiterCfg: evm_2_evm_onramp.RateLimiterConfig{ IsEnabled: true, - Capacity: testhelpers.LinkUSDValue(100), - Rate: testhelpers.LinkUSDValue(1), + Capacity: plugintesthelpers.LinkUSDValue(100), + Rate: plugintesthelpers.LinkUSDValue(1), }, OffRampRateLimiterCfg: evm_2_evm_offramp.RateLimiterConfig{ IsEnabled: true, - Capacity: testhelpers.LinkUSDValue(100), - Rate: testhelpers.LinkUSDValue(1), + Capacity: plugintesthelpers.LinkUSDValue(100), + Rate: plugintesthelpers.LinkUSDValue(1), }, InitialTokenPrices: []price_registry_1_2_0.InternalTokenPriceUpdate{ { @@ -182,7 +184,7 @@ func LaneConfigsForChains(t *testing.T, env deployment.Environment, state change }, }, }) - commitOCR2Configs = append(commitOCR2Configs, CommitOCR2ConfigParams{ + commitOCR2Configs = append(commitOCR2Configs, v1_5changeset.CommitOCR2ConfigParams{ SourceChainSelector: src, DestinationChainSelector: dest, OCR2ConfigParams: DefaultOCRParams(), @@ -194,7 +196,7 @@ func LaneConfigsForChains(t *testing.T, env deployment.Environment, state change InflightCacheExpiry: *config.MustNewDuration(5 * time.Second), PriceReportingDisabled: false, }) - execOCR2Configs = append(execOCR2Configs, ExecuteOCR2ConfigParams{ + execOCR2Configs = append(execOCR2Configs, v1_5changeset.ExecuteOCR2ConfigParams{ DestinationChainSelector: dest, SourceChainSelector: src, DestOptimisticConfirmations: 1, @@ -271,9 +273,9 @@ func SendRequest( t *testing.T, e deployment.Environment, state changeset.CCIPOnChainState, - opts ...changeset.SendReqOpts, + opts ...testhelpers.SendReqOpts, ) (*evm_2_evm_onramp.EVM2EVMOnRampCCIPSendRequested, error) { - cfg := &changeset.CCIPSendReqConfig{} + cfg := &testhelpers.CCIPSendReqConfig{} for _, opt := range opts { opt(cfg) } @@ -283,7 +285,7 @@ func SendRequest( } t.Logf("Sending CCIP request from chain selector %d to chain selector %d from sender %s", cfg.SourceChain, cfg.DestChain, cfg.Sender.From.String()) - tx, blockNum, err := changeset.CCIPSendRequest(e, state, cfg) + tx, blockNum, err := testhelpers.CCIPSendRequest(e, state, cfg) if err != nil { return nil, err } diff --git a/deployment/ccip/changeset/token_info.go b/deployment/ccip/changeset/token_info.go index 84f728df9f4..379119dba92 100644 --- a/deployment/ccip/changeset/token_info.go +++ b/deployment/ccip/changeset/token_info.go @@ -1,11 +1,16 @@ package changeset import ( + "math/big" + "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" "github.com/smartcontractkit/chainlink-ccip/pluginconfig" + + "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/link_token" "github.com/smartcontractkit/chainlink-common/pkg/logger" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/weth9" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/aggregator_v3_interface" ) @@ -20,9 +25,26 @@ const ( LinkDecimals = 18 WethDecimals = 18 UsdcDecimals = 6 + // MockLinkAggregatorDescription is the description of the MockV3Aggregator.sol contract + // https://github.com/smartcontractkit/chainlink/blob/a348b98e90527520049c580000a86fb8ceff7fa7/contracts/src/v0.8/tests/MockV3Aggregator.sol#L76-L76 + MockLinkAggregatorDescription = "v0.8/tests/MockV3Aggregator.sol" + // MockWETHAggregatorDescription is the description from MockETHUSDAggregator.sol + // https://github.com/smartcontractkit/chainlink/blob/a348b98e90527520049c580000a86fb8ceff7fa7/contracts/src/v0.8/automation/testhelpers/MockETHUSDAggregator.sol#L19-L19 + MockWETHAggregatorDescription = "MockETHUSDAggregator" ) var ( + MockLinkPrice = deployment.E18Mult(500) + MockWethPrice = big.NewInt(9e8) + // MockDescriptionToTokenSymbol maps a mock feed description to token descriptor + MockDescriptionToTokenSymbol = map[string]TokenSymbol{ + MockLinkAggregatorDescription: LinkSymbol, + MockWETHAggregatorDescription: WethSymbol, + } + MockSymbolToDescription = map[TokenSymbol]string{ + LinkSymbol: MockLinkAggregatorDescription, + WethSymbol: MockWETHAggregatorDescription, + } TestDeviationPPB = ccipocr3.NewBigIntFromInt64(1e9) ) diff --git a/deployment/ccip/changeset/v1_5/cs_jobspec.go b/deployment/ccip/changeset/v1_5/cs_jobspec.go index e1cd73f1e30..fd80a392136 100644 --- a/deployment/ccip/changeset/v1_5/cs_jobspec.go +++ b/deployment/ccip/changeset/v1_5/cs_jobspec.go @@ -10,6 +10,8 @@ import ( integrationtesthelpers "github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/testhelpers/integration" ) +var _ deployment.ChangeSet[JobSpecsForLanesConfig] = JobSpecsForLanesChangeset + type JobSpecsForLanesConfig struct { Configs []JobSpecInput } @@ -55,7 +57,7 @@ func (j JobSpecInput) Validate() error { return nil } -func JobSpecsForLanes(env deployment.Environment, c JobSpecsForLanesConfig) (deployment.ChangesetOutput, error) { +func JobSpecsForLanesChangeset(env deployment.Environment, c JobSpecsForLanesConfig) (deployment.ChangesetOutput, error) { if err := c.Validate(); err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("invalid JobSpecsForLanesConfig: %w", err) } diff --git a/deployment/ccip/changeset/v1_5/cs_lane_contracts.go b/deployment/ccip/changeset/v1_5/cs_lane_contracts.go index 25e14c898ff..6f6f0d54a69 100644 --- a/deployment/ccip/changeset/v1_5/cs_lane_contracts.go +++ b/deployment/ccip/changeset/v1_5/cs_lane_contracts.go @@ -14,7 +14,7 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" ) -var _ deployment.ChangeSet[DeployLanesConfig] = DeployLanes +var _ deployment.ChangeSet[DeployLanesConfig] = DeployLanesChangeset type DeployLanesConfig struct { Configs []DeployLaneConfig @@ -83,7 +83,22 @@ func (c *DeployLaneConfig) Validate(e deployment.Environment, state changeset.CC return nil } -func DeployLanes(env deployment.Environment, c DeployLanesConfig) (deployment.ChangesetOutput, error) { +func (c *DeployLaneConfig) populateAddresses(state changeset.CCIPOnChainState) error { + sourceChainState := state.Chains[c.SourceChainSelector] + srcLink, err := sourceChainState.LinkTokenAddress() + if err != nil { + return fmt.Errorf("failed to get LINK token address for source chain %d: %w", c.SourceChainSelector, err) + } + c.OnRampStaticCfg.LinkToken = srcLink + c.OnRampStaticCfg.RmnProxy = sourceChainState.RMNProxy.Address() + c.OnRampStaticCfg.TokenAdminRegistry = sourceChainState.TokenAdminRegistry.Address() + + c.OnRampDynamicCfg.Router = sourceChainState.Router.Address() + c.OnRampDynamicCfg.PriceRegistry = sourceChainState.PriceRegistry.Address() + return nil +} + +func DeployLanesChangeset(env deployment.Environment, c DeployLanesConfig) (deployment.ChangesetOutput, error) { state, err := changeset.LoadOnchainState(env) if err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("failed to load CCIP onchain state: %w", err) @@ -91,6 +106,12 @@ func DeployLanes(env deployment.Environment, c DeployLanesConfig) (deployment.Ch if err := c.Validate(env, state); err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("invalid DeployChainContractsConfig: %w", err) } + // populate addresses from the state + for i := range c.Configs { + if err := c.Configs[i].populateAddresses(state); err != nil { + return deployment.ChangesetOutput{}, err + } + } newAddresses := deployment.NewMemoryAddressBook() for _, cfg := range c.Configs { if err := deployLane(env, state, newAddresses, cfg); err != nil { diff --git a/deployment/ccip/changeset/v1_5/cs_ocr2_config.go b/deployment/ccip/changeset/v1_5/cs_ocr2_config.go index 497bcb53ad8..2babf666da2 100644 --- a/deployment/ccip/changeset/v1_5/cs_ocr2_config.go +++ b/deployment/ccip/changeset/v1_5/cs_ocr2_config.go @@ -17,6 +17,8 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/ccip/testhelpers" ) +var _ deployment.ChangeSet[OCR2Config] = SetOCR2ConfigForTestChangeset + type FinalOCR2Config struct { Signers []common.Address Transmitters []common.Address @@ -175,9 +177,9 @@ func (o OCR2Config) Validate(state changeset.CCIPOnChainState) error { return nil } -// SetOCR2ConfigForTest sets the OCR2 config on the chain for commit and offramp +// SetOCR2ConfigForTestChangeset sets the OCR2 config on the chain for commit and offramp // This is currently not suitable for prod environments it's only for testing -func SetOCR2ConfigForTest(env deployment.Environment, c OCR2Config) (deployment.ChangesetOutput, error) { +func SetOCR2ConfigForTestChangeset(env deployment.Environment, c OCR2Config) (deployment.ChangesetOutput, error) { state, err := changeset.LoadOnchainState(env) if err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("failed to load CCIP onchain state: %w", err) diff --git a/deployment/ccip/changeset/v1_5/cs_rmn.go b/deployment/ccip/changeset/v1_5/cs_rmn.go index df96645b9bf..ffe20294873 100644 --- a/deployment/ccip/changeset/v1_5/cs_rmn.go +++ b/deployment/ccip/changeset/v1_5/cs_rmn.go @@ -17,7 +17,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment/common/proposalutils" ) -var _ deployment.ChangeSet[PermaBlessCommitStoreConfig] = PermaBlessCommitStoreCS +var _ deployment.ChangeSet[PermaBlessCommitStoreConfig] = PermaBlessCommitStoreChangeset type PermaBlessConfigPerSourceChain struct { SourceChainSelector uint64 @@ -96,10 +96,10 @@ func (c PermaBlessCommitStoreConfig) Validate(env deployment.Environment) error return nil } -// PermaBlessCommitStoreCS permablesses the commit stores on the RMN contract +// PermaBlessCommitStoreChangeset permablesses the commit stores on the RMN contract // If commit store addresses are added to the permaBlessed list, those will be considered automatically blessed. // This changeset can add to or remove from the existing permaBlessed list. -func PermaBlessCommitStoreCS(env deployment.Environment, c PermaBlessCommitStoreConfig) (deployment.ChangesetOutput, error) { +func PermaBlessCommitStoreChangeset(env deployment.Environment, c PermaBlessCommitStoreConfig) (deployment.ChangesetOutput, error) { if err := c.Validate(env); err != nil { return deployment.ChangesetOutput{}, fmt.Errorf("invalid PermaBlessCommitStoreConfig: %w", err) } diff --git a/deployment/ccip/changeset/v1_5/e2e_test.go b/deployment/ccip/changeset/v1_5/e2e_test.go index 59d6a30066c..8911dcc8bf4 100644 --- a/deployment/ccip/changeset/v1_5/e2e_test.go +++ b/deployment/ccip/changeset/v1_5/e2e_test.go @@ -1,4 +1,4 @@ -package v1_5 +package v1_5_test import ( "context" @@ -9,6 +9,9 @@ import ( "github.com/stretchr/testify/require" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers/v1_5" + v1_5changeset "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/v1_5" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_contract" @@ -18,9 +21,9 @@ import ( // This test only works if the destination chain id is 1337 // Otherwise it shows error for offchain and onchain config digest mismatch func TestE2ELegacy(t *testing.T) { - e, _ := changeset.NewMemoryEnvironment( + e, _ := testhelpers.NewMemoryEnvironment( t, - changeset.WithPrerequisiteDeployment(&changeset.V1_5DeploymentConfig{ + testhelpers.WithPrerequisiteDeploymentOnly(&changeset.V1_5DeploymentConfig{ PriceRegStalenessThreshold: 60 * 60 * 24 * 14, // two weeks RMNConfig: &rmn_contract.RMNConfig{ BlessWeightThreshold: 2, @@ -36,8 +39,8 @@ func TestE2ELegacy(t *testing.T) { }, }, }), - changeset.WithChains(3), - changeset.WithChainIds([]uint64{chainselectors.GETH_TESTNET.EvmChainID})) + testhelpers.WithNumOfChains(3), + testhelpers.WithChainIDs([]uint64{chainselectors.GETH_TESTNET.EvmChainID})) state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) allChains := e.Env.AllChainSelectorsExcluding([]uint64{chainselectors.GETH_TESTNET.Selector}) @@ -46,18 +49,18 @@ func TestE2ELegacy(t *testing.T) { src, dest := allChains[1], chainselectors.GETH_TESTNET.Selector srcChain := e.Env.Chains[src] destChain := e.Env.Chains[dest] - pairs := []changeset.SourceDestPair{ + pairs := []testhelpers.SourceDestPair{ {SourceChainSelector: src, DestChainSelector: dest}, } - e.Env = AddLanes(t, e.Env, state, pairs) + e.Env = v1_5.AddLanes(t, e.Env, state, pairs) // permabless the commit stores e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(PermaBlessCommitStoreCS), - Config: PermaBlessCommitStoreConfig{ - Configs: map[uint64]PermaBlessCommitStoreConfigPerDest{ + Changeset: commonchangeset.WrapChangeSet(v1_5changeset.PermaBlessCommitStoreChangeset), + Config: v1_5changeset.PermaBlessCommitStoreConfig{ + Configs: map[uint64]v1_5changeset.PermaBlessCommitStoreConfigPerDest{ dest: { - Sources: []PermaBlessConfigPerSourceChain{ + Sources: []v1_5changeset.PermaBlessConfigPerSourceChain{ { SourceChainSelector: src, PermaBless: true, @@ -72,11 +75,11 @@ func TestE2ELegacy(t *testing.T) { // reload state after adding lanes state, err = changeset.LoadOnchainState(e.Env) require.NoError(t, err) - sentEvent, err := SendRequest(t, e.Env, state, - changeset.WithSourceChain(src), - changeset.WithDestChain(dest), - changeset.WithTestRouter(false), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + sentEvent, err := v1_5.SendRequest(t, e.Env, state, + testhelpers.WithSourceChain(src), + testhelpers.WithDestChain(dest), + testhelpers.WithTestRouter(false), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, @@ -88,6 +91,6 @@ func TestE2ELegacy(t *testing.T) { require.NotNil(t, sentEvent) destStartBlock, err := destChain.Client.HeaderByNumber(context.Background(), nil) require.NoError(t, err) - WaitForCommit(t, srcChain, destChain, state.Chains[dest].CommitStore[src], sentEvent.Message.SequenceNumber) - WaitForExecute(t, srcChain, destChain, state.Chains[dest].EVM2EVMOffRamp[src], []uint64{sentEvent.Message.SequenceNumber}, destStartBlock.Number.Uint64()) + v1_5.WaitForCommit(t, srcChain, destChain, state.Chains[dest].CommitStore[src], sentEvent.Message.SequenceNumber) + v1_5.WaitForExecute(t, srcChain, destChain, state.Chains[dest].EVM2EVMOffRamp[src], []uint64{sentEvent.Message.SequenceNumber}, destStartBlock.Number.Uint64()) } diff --git a/deployment/ccip/changeset/view_test.go b/deployment/ccip/changeset/view_test.go index 16d1f8a0dfc..cb798835cd7 100644 --- a/deployment/ccip/changeset/view_test.go +++ b/deployment/ccip/changeset/view_test.go @@ -1,14 +1,17 @@ -package changeset +package changeset_test import ( "testing" "github.com/stretchr/testify/require" + + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" ) func TestSmokeView(t *testing.T) { t.Parallel() - tenv, _ := NewMemoryEnvironment(t, WithChains(3)) - _, err := ViewCCIP(tenv.Env) + tenv, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(3)) + _, err := changeset.ViewCCIP(tenv.Env) require.NoError(t, err) } diff --git a/deployment/common/changeset/save_existing.go b/deployment/common/changeset/save_existing.go index 57e53607cdc..17fdc0a8025 100644 --- a/deployment/common/changeset/save_existing.go +++ b/deployment/common/changeset/save_existing.go @@ -11,7 +11,7 @@ import ( ) var ( - _ deployment.ChangeSet[ExistingContractsConfig] = SaveExistingContracts + _ deployment.ChangeSet[ExistingContractsConfig] = SaveExistingContractsChangeset ) type Contract struct { @@ -42,9 +42,9 @@ func (cfg ExistingContractsConfig) Validate() error { return nil } -// SaveExistingContracts saves the existing contracts to the address book. +// SaveExistingContractsChangeset saves the existing contracts to the address book. // Caller should update the environment's address book with the returned addresses. -func SaveExistingContracts(env deployment.Environment, cfg ExistingContractsConfig) (deployment.ChangesetOutput, error) { +func SaveExistingContractsChangeset(env deployment.Environment, cfg ExistingContractsConfig) (deployment.ChangesetOutput, error) { err := cfg.Validate() if err != nil { return deployment.ChangesetOutput{}, errors.Wrapf(deployment.ErrInvalidConfig, "%v", err) diff --git a/deployment/common/changeset/save_existing_test.go b/deployment/common/changeset/save_existing_test.go index 2a2618c8f54..a7e8c9068f3 100644 --- a/deployment/common/changeset/save_existing_test.go +++ b/deployment/common/changeset/save_existing_test.go @@ -43,7 +43,7 @@ func TestSaveExisting(t *testing.T) { }, } - output, err := SaveExistingContracts(dummyEnv, ExistingContracts) + output, err := SaveExistingContractsChangeset(dummyEnv, ExistingContracts) require.NoError(t, err) require.NoError(t, dummyEnv.ExistingAddresses.Merge(output.AddressBook)) addresses, err := dummyEnv.ExistingAddresses.Addresses() diff --git a/deployment/environment/crib/ccip_deployer.go b/deployment/environment/crib/ccip_deployer.go index 639e42b4024..9aa7972585d 100644 --- a/deployment/environment/crib/ccip_deployer.go +++ b/deployment/environment/crib/ccip_deployer.go @@ -12,8 +12,10 @@ import ( "github.com/smartcontractkit/chainlink-ccip/chainconfig" cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" + "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" "github.com/smartcontractkit/chainlink/deployment/environment/devenv" @@ -23,7 +25,7 @@ import ( ) // DeployHomeChainContracts deploys the home chain contracts so that the chainlink nodes can use the CR address in Capabilities.ExternalRegistry -// Afterwards, we call DeployHomeChain changeset with nodeinfo ( the peer id and all) +// Afterwards, we call DeployHomeChainChangeset changeset with nodeinfo ( the peer id and all) func DeployHomeChainContracts(ctx context.Context, lggr logger.Logger, envConfig devenv.EnvironmentConfig, homeChainSel uint64, feedChainSel uint64) (deployment.CapabilityRegistryConfig, deployment.AddressBook, error) { e, _, err := devenv.NewEnvironment(func() context.Context { return ctx }, lggr, envConfig) if err != nil { @@ -40,12 +42,12 @@ func DeployHomeChainContracts(ctx context.Context, lggr logger.Logger, envConfig p2pIds := nodes.NonBootstraps().PeerIDs() *e, err = commonchangeset.ApplyChangesets(nil, *e, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(changeset.DeployHomeChain), + Changeset: commonchangeset.WrapChangeSet(changeset.DeployHomeChainChangeset), Config: changeset.DeployHomeChainConfig{ HomeChainSel: homeChainSel, - RMNStaticConfig: changeset.NewTestRMNStaticConfig(), - RMNDynamicConfig: changeset.NewTestRMNDynamicConfig(), - NodeOperators: changeset.NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), + RMNStaticConfig: testhelpers.NewTestRMNStaticConfig(), + RMNDynamicConfig: testhelpers.NewTestRMNDynamicConfig(), + NodeOperators: testhelpers.NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), NodeP2PIDsPerNodeOpAdmin: map[string][][32]byte{ "NodeOperator": p2pIds, }, @@ -116,7 +118,7 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de // Setup because we only need to deploy the contracts and distribute job specs *e, err = commonchangeset.ApplyChangesets(nil, *e, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateChainConfig), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateChainConfigChangeset), Config: changeset.UpdateChainConfigConfig{ HomeChainSelector: homeChainSel, RemoteChainAdds: chainConfigs, @@ -127,7 +129,7 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de Config: chainSelectors, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.DeployPrerequisites), + Changeset: commonchangeset.WrapChangeSet(changeset.DeployPrerequisitesChangeset), Config: changeset.DeployPrerequisiteConfig{ Configs: prereqCfgs, }, @@ -137,14 +139,14 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de Config: cfg, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.DeployChainContracts), + Changeset: commonchangeset.WrapChangeSet(changeset.DeployChainContractsChangeset), Config: changeset.DeployChainContractsConfig{ ChainSelectors: chainSelectors, HomeChainSelector: homeChainSel, }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.CCIPCapabilityJobspec), + Changeset: commonchangeset.WrapChangeSet(changeset.CCIPCapabilityJobspecChangeset), Config: struct{}{}, }, }) @@ -159,7 +161,7 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de stateChain1 := state.Chains[from] newEnv, err := commonchangeset.ApplyChangesets(nil, *e, nil, []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOnRampsDests), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOnRampsDestsChangeset), Config: changeset.UpdateOnRampDestsConfig{ UpdatesByChain: map[uint64]map[uint64]changeset.OnRampDestinationUpdate{ from: { @@ -173,23 +175,23 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterPricesCS), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterPricesChangeset), Config: changeset.UpdateFeeQuoterPricesConfig{ PricesByChain: map[uint64]changeset.FeeQuoterPriceUpdatePerSource{ from: { TokenPrices: map[common.Address]*big.Int{ - stateChain1.LinkToken.Address(): changeset.DefaultLinkPrice, - stateChain1.Weth9.Address(): changeset.DefaultWethPrice, + stateChain1.LinkToken.Address(): testhelpers.DefaultLinkPrice, + stateChain1.Weth9.Address(): testhelpers.DefaultWethPrice, }, GasPrices: map[uint64]*big.Int{ - to: changeset.DefaultGasPrice, + to: testhelpers.DefaultGasPrice, }, }, }, }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterDests), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateFeeQuoterDestsChangeset), Config: changeset.UpdateFeeQuoterDestsConfig{ UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{ from: { @@ -199,7 +201,7 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOffRampSources), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOffRampSourcesChangeset), Config: changeset.UpdateOffRampSourcesConfig{ UpdatesByChain: map[uint64]map[uint64]changeset.OffRampSourceUpdate{ to: { @@ -212,7 +214,7 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateRouterRamps), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateRouterRampsChangeset), Config: changeset.UpdateRouterRampsConfig{ TestRouter: true, UpdatesByChain: map[uint64]changeset.RouterUpdates{ diff --git a/integration-tests/load/go.sum b/integration-tests/load/go.sum index 81be2e202ea..cf96d2d91aa 100644 --- a/integration-tests/load/go.sum +++ b/integration-tests/load/go.sum @@ -1393,16 +1393,12 @@ github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/slack-go/slack v0.15.0 h1:LE2lj2y9vqqiOf+qIIy0GvEoxgF1N5yLGZffmEZykt0= github.com/slack-go/slack v0.15.0/go.mod h1:hlGi5oXA+Gt+yWTPP0plCdRKmjsDxecdHxYQdlMQKOw= -github.com/smartcontractkit/ccip-owner-contracts v0.0.0-salt-fix h1:DPJD++yKLSx0EfT+U14P8vLVxjXFmoIETiCO9lVwQo8= -github.com/smartcontractkit/ccip-owner-contracts v0.0.0-salt-fix/go.mod h1:NnT6w4Kj42OFFXhSx99LvJZWPpMjmo4+CpDEWfw61xY= github.com/smartcontractkit/chain-selectors v1.0.36 h1:KSpO8I+JOiuyN4FuXsV471sPorGF//PAqwq2Cm4gRK0= github.com/smartcontractkit/chain-selectors v1.0.36/go.mod h1:xsKM0aN3YGcQKTPRPDDtPx2l4mlTN1Djmg0VVXV40b8= github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgBc2xpDKBco/Q4h4ydl6+UUU= github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20250110181647-9dba278f2103 h1:TeWnxdgSO2cYCKcBMwdkRcs/YdhSvXoWqqw7QWz/KeI= github.com/smartcontractkit/chainlink-ccip v0.0.0-20250110181647-9dba278f2103/go.mod h1:ncjd6mPZSRlelEqH/2KeLE1pU3UlqzBSn8RYkEoECzY= -github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20250103152858-8973fd0c912b h1:UBXi9Yj8YSMHDDaxQLu273x1fWjyEL9xP58nuJsqZfg= -github.com/smartcontractkit/chainlink-ccip/chains/solana v0.0.0-20250103152858-8973fd0c912b/go.mod h1:Bmwq4lNb5tE47sydN0TKetcLEGbgl+VxHEWp4S0LI60= github.com/smartcontractkit/chainlink-common v0.4.1-0.20250115094325-4e61572bb9bd h1:SX16W7pqXGyn6fHFgtlr/rUdLZzBtQ5O3Gt3a6sFL70= github.com/smartcontractkit/chainlink-common v0.4.1-0.20250115094325-4e61572bb9bd/go.mod h1:yti7e1+G9hhkYhj+L5sVUULn9Bn3bBL5/AxaNqdJ5YQ= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241202195413-82468150ac1e h1:PRoeby6ZlTuTkv2f+7tVU4+zboTfRzI+beECynF4JQ0= @@ -1413,16 +1409,12 @@ github.com/smartcontractkit/chainlink-feeds v0.1.1 h1:JzvUOM/OgGQA1sOqTXXl52R6An github.com/smartcontractkit/chainlink-feeds v0.1.1/go.mod h1:55EZ94HlKCfAsUiKUTNI7QlE/3d3IwTlsU3YNa/nBb4= github.com/smartcontractkit/chainlink-framework/multinode v0.0.0-20250115203616-a2ea5e50b260 h1:See2isL6KdrTJDlVKWv8qiyYqWhYUcubU2e5yKXV1oY= github.com/smartcontractkit/chainlink-framework/multinode v0.0.0-20250115203616-a2ea5e50b260/go.mod h1:4JqpgFy01LaqG1yM2iFTzwX3ZgcAvW9WdstBZQgPHzU= -github.com/smartcontractkit/chainlink-protos/job-distributor v0.6.0 h1:0ewLMbAz3rZrovdRUCgd028yOXX8KigB4FndAUdI2kM= -github.com/smartcontractkit/chainlink-protos/job-distributor v0.6.0/go.mod h1:/dVVLXrsp+V0AbcYGJo3XMzKg3CkELsweA/TTopCsKE= github.com/smartcontractkit/chainlink-protos/orchestrator v0.4.0 h1:ZBat8EBvE2LpSQR9U1gEbRV6PfAkiFdINmQ8nVnXIAQ= github.com/smartcontractkit/chainlink-protos/orchestrator v0.4.0/go.mod h1:m/A3lqD7ms/RsQ9BT5P2uceYY0QX5mIt4KQxT2G6qEo= github.com/smartcontractkit/chainlink-solana v1.1.1-0.20250110142550-e2a9566d39f3 h1:L6UDu0GzSKfz+/nMSz9yfYrgOpW1/OXhiVK60PxVsnY= github.com/smartcontractkit/chainlink-solana v1.1.1-0.20250110142550-e2a9566d39f3/go.mod h1:52U0UH8K0Qwu+HB1LMc+5V27ru2Tgy29YPT+2HkMevY= github.com/smartcontractkit/chainlink-starknet/relayer v0.1.1-0.20241202202529-2033490e77b8 h1:tNS7U9lrxkFvEuyxQv11HHOiV9LPDGC9wYEy+yM/Jv4= github.com/smartcontractkit/chainlink-starknet/relayer v0.1.1-0.20241202202529-2033490e77b8/go.mod h1:EBrEgcdIbwepqguClkv8Ohy7CbyWSJaE4EC9aBJlQK0= -github.com/smartcontractkit/chainlink-testing-framework/framework v0.4.2-0.20250110073248-456673e8eea2 h1:nTUoe7GZLw17nPLV5t3Vgf4U4pf+VW0Uko5xpNiKdKU= -github.com/smartcontractkit/chainlink-testing-framework/framework v0.4.2-0.20250110073248-456673e8eea2/go.mod h1:mMUqvS3BZfvN1OfK4OFTYf1+T0X6nwmSXJM2keaPsSM= github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2 h1:GDGrC5OGiV0RyM1znYWehSQXyZQWTOzrEeJRYmysPCE= github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2/go.mod h1:DsT43c1oTBmp3iQkMcoZOoKThwZvt8X3Pz6UmznJ4GY= github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.19 h1:9PMwKNqFKc5FXf4VchyD3CGzZelnSgi13fgVdT2X7T4= diff --git a/integration-tests/smoke/ccip/ccip_batching_test.go b/integration-tests/smoke/ccip/ccip_batching_test.go index 6c204fa45a3..38b068dad92 100644 --- a/integration-tests/smoke/ccip/ccip_batching_test.go +++ b/integration-tests/smoke/ccip/ccip_batching_test.go @@ -15,6 +15,7 @@ import ( "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" "github.com/smartcontractkit/chainlink-common/pkg/merklemulti" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/deployment" @@ -30,7 +31,7 @@ const ( ) type batchTestSetup struct { - e changeset.DeployedEnv + e testhelpers.DeployedEnv state changeset.CCIPOnChainState sourceChain1 uint64 sourceChain2 uint64 @@ -41,9 +42,9 @@ func newBatchTestSetup(t *testing.T) batchTestSetup { // Setup 3 chains, with 2 lanes going to the dest. e, _, _ := testsetups.NewIntegrationEnvironment( t, - changeset.WithMultiCall3(), - changeset.WithChains(3), - changeset.WithUsersPerChain(2), + testhelpers.WithMultiCall3(), + testhelpers.WithNumOfChains(3), + testhelpers.WithNumOfUsersPerChain(2), ) state, err := changeset.LoadOnchainState(e.Env) @@ -63,8 +64,8 @@ func newBatchTestSetup(t *testing.T) batchTestSetup { ) // connect sourceChain1 and sourceChain2 to destChain - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, sourceChain1, destChain, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, sourceChain2, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, sourceChain1, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, sourceChain2, destChain, false) return batchTestSetup{e, state, sourceChain1, sourceChain2, destChain} } @@ -72,7 +73,7 @@ func newBatchTestSetup(t *testing.T) batchTestSetup { func Test_CCIPBatching_MaxBatchSizeEVM(t *testing.T) { t.Parallel() - ctx := changeset.Context(t) + ctx := testhelpers.Context(t) setup := newBatchTestSetup(t) sourceChain1, sourceChain2, destChain, e, state := setup.sourceChain1, setup.sourceChain2, setup.destChain, setup.e, setup.state @@ -120,7 +121,7 @@ func Test_CCIPBatching_MaxBatchSizeEVM(t *testing.T) { } } - _, err := changeset.ConfirmCommitWithExpectedSeqNumRange( + _, err := testhelpers.ConfirmCommitWithExpectedSeqNumRange( t, e.Env.Chains[sourceChain], e.Env.Chains[destChain], @@ -141,7 +142,7 @@ func Test_CCIPBatching_MultiSource(t *testing.T) { t.Parallel() // Setup 3 chains, with 2 lanes going to the dest. - ctx := changeset.Context(t) + ctx := testhelpers.Context(t) setup := newBatchTestSetup(t) sourceChain1, sourceChain2, destChain, e, state := setup.sourceChain1, setup.sourceChain2, setup.destChain, setup.e, setup.state @@ -259,7 +260,7 @@ func Test_CCIPBatching_MultiSource(t *testing.T) { // assert that all states are successful for _, states := range execStates { for _, state := range states { - require.Equal(t, changeset.EXECUTION_STATE_SUCCESS, state) + require.Equal(t, testhelpers.EXECUTION_STATE_SUCCESS, state) } } } @@ -268,7 +269,7 @@ func Test_CCIPBatching_SingleSource(t *testing.T) { t.Parallel() // Setup 3 chains, with 2 lanes going to the dest. - ctx := changeset.Context(t) + ctx := testhelpers.Context(t) setup := newBatchTestSetup(t) sourceChain1, sourceChain2, destChain, e, state := setup.sourceChain1, setup.sourceChain2, setup.destChain, setup.e, setup.state @@ -296,7 +297,7 @@ func Test_CCIPBatching_SingleSource(t *testing.T) { ) require.NoError(t, err) - _, err = changeset.ConfirmCommitWithExpectedSeqNumRange( + _, err = testhelpers.ConfirmCommitWithExpectedSeqNumRange( t, e.Env.Chains[sourceChain], e.Env.Chains[destChain], @@ -307,7 +308,7 @@ func Test_CCIPBatching_SingleSource(t *testing.T) { ) require.NoErrorf(t, err, "failed to confirm commit from chain %d", sourceChain) - states, err := changeset.ConfirmExecWithSeqNrs( + states, err := testhelpers.ConfirmExecWithSeqNrs( t, e.Env.Chains[sourceChain], e.Env.Chains[destChain], @@ -318,7 +319,7 @@ func Test_CCIPBatching_SingleSource(t *testing.T) { require.NoError(t, err) // assert that all states are successful for _, state := range states { - require.Equal(t, changeset.EXECUTION_STATE_SUCCESS, state) + require.Equal(t, testhelpers.EXECUTION_STATE_SUCCESS, state) } } @@ -329,7 +330,7 @@ type outputErr[T any] struct { func assertExecAsync( t *testing.T, - e changeset.DeployedEnv, + e testhelpers.DeployedEnv, state changeset.CCIPOnChainState, sourceChainSelector, destChainSelector uint64, @@ -338,7 +339,7 @@ func assertExecAsync( errs chan<- outputErr[map[uint64]int], ) { defer wg.Done() - states, err := changeset.ConfirmExecWithSeqNrs( + states, err := testhelpers.ConfirmExecWithSeqNrs( t, e.Env.Chains[sourceChainSelector], e.Env.Chains[destChainSelector], @@ -352,7 +353,7 @@ func assertExecAsync( func assertCommitReportsAsync( t *testing.T, - e changeset.DeployedEnv, + e testhelpers.DeployedEnv, state changeset.CCIPOnChainState, sourceChainSelector, destChainSelector uint64, @@ -362,7 +363,7 @@ func assertCommitReportsAsync( errs chan<- outputErr[*offramp.OffRampCommitReportAccepted], ) { defer wg.Done() - commitReport, err := changeset.ConfirmCommitWithExpectedSeqNumRange( + commitReport, err := testhelpers.ConfirmCommitWithExpectedSeqNumRange( t, e.Env.Chains[sourceChainSelector], e.Env.Chains[destChainSelector], @@ -378,7 +379,7 @@ func assertCommitReportsAsync( func sendMessagesAsync( ctx context.Context, t *testing.T, - e changeset.DeployedEnv, + e testhelpers.DeployedEnv, state changeset.CCIPOnChainState, sourceChainSelector, destChainSelector uint64, @@ -498,7 +499,7 @@ func genMessages( Data: []byte(fmt.Sprintf("hello world %d", i)), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), - ExtraArgs: changeset.MakeEVMExtraArgsV2(50_000, false), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(50_000, false), } fee, err := sourceRouter.GetFee(&bind.CallOpts{Context: ctx}, destChainSelector, msg) @@ -508,7 +509,7 @@ func genMessages( totalValue.Add(totalValue, fee) - calldata, err := changeset.CCIPSendCalldata(destChainSelector, msg) + calldata, err := testhelpers.CCIPSendCalldata(destChainSelector, msg) if err != nil { return nil, nil, fmt.Errorf("generate calldata: %w", err) } diff --git a/integration-tests/smoke/ccip/ccip_fee_boosting_test.go b/integration-tests/smoke/ccip/ccip_fee_boosting_test.go index 49f603a39f4..d1800174a25 100644 --- a/integration-tests/smoke/ccip/ccip_fee_boosting_test.go +++ b/integration-tests/smoke/ccip/ccip_fee_boosting_test.go @@ -8,6 +8,7 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/config" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" commoncs "github.com/smartcontractkit/chainlink/deployment/common/changeset" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" @@ -36,7 +37,7 @@ var ( func Test_CCIPFeeBoosting(t *testing.T) { e, _, _ := testsetups.NewIntegrationEnvironment( t, - changeset.WithOCRConfigOverride(func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams { + testhelpers.WithOCRConfigOverride(func(params *changeset.CCIPOCRParams) { // Only 1 boost (=OCR round) is enough to cover the fee params.ExecuteOffChainConfig.RelativeBoostPerWaitHour = 10 // Disable token price updates @@ -45,7 +46,6 @@ func Test_CCIPFeeBoosting(t *testing.T) { params.CommitOffChainConfig.RemoteGasPriceBatchWriteFrequency = *config.MustNewDuration(1_000_000 * time.Hour) // Disable token price updates params.CommitOffChainConfig.TokenInfo = nil - return params }), ) @@ -81,9 +81,9 @@ func Test_CCIPFeeBoosting(t *testing.T) { ) t.Log("Adjusted gas price on dest chain:", adjustedGasPriceDest) - changeset.AddLane(t, &e, sourceChain, destChain, false, + testhelpers.AddLane(t, &e, sourceChain, destChain, false, map[uint64]*big.Int{ - destChain: changeset.ToPackedFee(adjustedGasPriceDest, big.NewInt(0)), + destChain: testhelpers.ToPackedFee(adjustedGasPriceDest, big.NewInt(0)), }, map[common.Address]*big.Int{ state.Chains[sourceChain].LinkToken.Address(): linkPrice, @@ -94,7 +94,7 @@ func Test_CCIPFeeBoosting(t *testing.T) { // Update token prices in destination chain FeeQuoter e.Env, err = commoncs.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commoncs.ChangesetApplication{ { - Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterPricesCS), + Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterPricesChangeset), Config: changeset.UpdateFeeQuoterPricesConfig{ PricesByChain: map[uint64]changeset.FeeQuoterPriceUpdatePerSource{ destChain: { @@ -110,13 +110,13 @@ func Test_CCIPFeeBoosting(t *testing.T) { require.NoError(t, err) startBlocks := make(map[uint64]*uint64) - expectedSeqNum := make(map[changeset.SourceDestPair]uint64) - expectedSeqNumExec := make(map[changeset.SourceDestPair][]uint64) + expectedSeqNum := make(map[testhelpers.SourceDestPair]uint64) + expectedSeqNumExec := make(map[testhelpers.SourceDestPair][]uint64) latesthdr, err := e.Env.Chains[sourceChain].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) block := latesthdr.Number.Uint64() - msgSentEvent := changeset.TestSendRequest(t, e.Env, state, sourceChain, destChain, false, router.ClientEVM2AnyMessage{ + msgSentEvent := testhelpers.TestSendRequest(t, e.Env, state, sourceChain, destChain, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[destChain].Receiver.Address().Bytes(), 32), Data: []byte("message that needs fee boosting"), TokenAmounts: nil, @@ -124,18 +124,18 @@ func Test_CCIPFeeBoosting(t *testing.T) { ExtraArgs: nil, }) startBlocks[sourceChain] = &block - expectedSeqNum[changeset.SourceDestPair{ + expectedSeqNum[testhelpers.SourceDestPair{ SourceChainSelector: sourceChain, DestChainSelector: destChain, }] = msgSentEvent.SequenceNumber - expectedSeqNumExec[changeset.SourceDestPair{ + expectedSeqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: sourceChain, DestChainSelector: destChain, }] = []uint64{msgSentEvent.SequenceNumber} e.Env, err = commoncs.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commoncs.ChangesetApplication{ { - Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterPricesCS), + Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterPricesChangeset), Config: changeset.UpdateFeeQuoterPricesConfig{ PricesByChain: map[uint64]changeset.FeeQuoterPriceUpdatePerSource{ sourceChain: { @@ -151,7 +151,7 @@ func Test_CCIPFeeBoosting(t *testing.T) { // Confirm gas prices are updated srcFeeQuoter := state.Chains[sourceChain].FeeQuoter - err = changeset.ConfirmGasPriceUpdated(t, e.Env.Chains[destChain], srcFeeQuoter, 0, originalGasPriceDestUSD) + err = testhelpers.ConfirmGasPriceUpdated(t, e.Env.Chains[destChain], srcFeeQuoter, 0, originalGasPriceDestUSD) require.NoError(t, err) // Confirm that fee boosting will be triggered @@ -162,11 +162,11 @@ func Test_CCIPFeeBoosting(t *testing.T) { replayBlocks := make(map[uint64]uint64) replayBlocks[sourceChain] = 1 replayBlocks[destChain] = 1 - changeset.ReplayLogs(t, e.Env.Offchain, replayBlocks) + testhelpers.ReplayLogs(t, e.Env.Offchain, replayBlocks) // Confirm that the message is committed and executed - changeset.ConfirmCommitForAllWithExpectedSeqNums(t, e.Env, state, expectedSeqNum, startBlocks) - changeset.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(t, e.Env, state, expectedSeqNum, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) } // TODO: Find a more accurate way to determine if fee boosting will be triggered diff --git a/integration-tests/smoke/ccip/ccip_fees_test.go b/integration-tests/smoke/ccip/ccip_fees_test.go index d0f9cc71683..7c329179e55 100644 --- a/integration-tests/smoke/ccip/ccip_fees_test.go +++ b/integration-tests/smoke/ccip/ccip_fees_test.go @@ -14,6 +14,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/assets" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" @@ -27,7 +28,7 @@ import ( func setupTokens( t *testing.T, state changeset.CCIPOnChainState, - tenv changeset.DeployedEnv, + tenv testhelpers.DeployedEnv, src, dest uint64, transferTokenMintAmount, feeTokenMintAmount *big.Int, @@ -39,7 +40,7 @@ func setupTokens( e := tenv.Env // Deploy the token to test transferring - srcToken, _, dstToken, _, err := changeset.DeployTransferableToken( + srcToken, _, dstToken, _, err := testhelpers.DeployTransferableToken( lggr, tenv.Env.Chains, src, @@ -103,7 +104,7 @@ func Test_CCIPFees(t *testing.T) { t.Parallel() tenv, _, _ := testsetups.NewIntegrationEnvironment( t, - changeset.WithMultiCall3(), + testhelpers.WithMultiCall3(), ) e := tenv.Env @@ -127,10 +128,10 @@ func Test_CCIPFees(t *testing.T) { ) // Ensure capreg logs are up to date. - changeset.ReplayLogs(t, e.Offchain, tenv.ReplayBlocks) + testhelpers.ReplayLogs(t, e.Offchain, tenv.ReplayBlocks) // Add all lanes - changeset.AddLanesForAll(t, &tenv, state) + testhelpers.AddLanesForAll(t, &tenv, state) t.Run("Send programmable token transfer pay with Link token", func(t *testing.T) { runFeeTokenTestCase(feeTokenTestCase{ @@ -222,10 +223,10 @@ func Test_CCIPFees(t *testing.T) { ExtraArgs: nil, } - _, _, err = changeset.CCIPSendRequest( + _, _, err = testhelpers.CCIPSendRequest( e, state, - &changeset.CCIPSendReqConfig{ + &testhelpers.CCIPSendReqConfig{ Sender: e.Chains[sourceChain].DeployerKey, IsTestRouter: true, SourceChain: sourceChain, @@ -291,7 +292,7 @@ func Test_CCIPFees(t *testing.T) { type feeTokenTestCase struct { t *testing.T src, dst uint64 - env changeset.DeployedEnv + env testhelpers.DeployedEnv srcToken, dstToken *burn_mint_erc677.BurnMintERC677 tokenAmounts []router.ClientEVMTokenAmount feeToken common.Address @@ -304,8 +305,8 @@ func runFeeTokenTestCase(tc feeTokenTestCase) { ctx := tests.Context(tc.t) // Need to keep track of the block number for each chain so that event subscription can be done from that block. startBlocks := make(map[uint64]*uint64) - expectedSeqNum := make(map[changeset.SourceDestPair]uint64) - expectedSeqNumExec := make(map[changeset.SourceDestPair][]uint64) + expectedSeqNum := make(map[testhelpers.SourceDestPair]uint64) + expectedSeqNumExec := make(map[testhelpers.SourceDestPair][]uint64) srcChain := tc.env.Env.Chains[tc.src] dstChain := tc.env.Env.Chains[tc.dst] @@ -374,7 +375,7 @@ func runFeeTokenTestCase(tc feeTokenTestCase) { tc.t.Logf("fee token balance before: %s, fee token enabled: %s", feeTokenBalanceBefore.String(), tc.feeToken.String()) - msgSentEvent := changeset.TestSendRequest( + msgSentEvent := testhelpers.TestSendRequest( tc.t, tc.env.Env, state, @@ -390,11 +391,11 @@ func runFeeTokenTestCase(tc feeTokenTestCase) { }, ) - expectedSeqNum[changeset.SourceDestPair{ + expectedSeqNum[testhelpers.SourceDestPair{ SourceChainSelector: tc.src, DestChainSelector: tc.dst, }] = msgSentEvent.SequenceNumber - expectedSeqNumExec[changeset.SourceDestPair{ + expectedSeqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: tc.src, DestChainSelector: tc.dst, }] = []uint64{msgSentEvent.SequenceNumber} @@ -427,7 +428,7 @@ func runFeeTokenTestCase(tc feeTokenTestCase) { ) // Wait for all commit reports to land. - changeset.ConfirmCommitForAllWithExpectedSeqNums(tc.t, tc.env.Env, state, expectedSeqNum, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(tc.t, tc.env.Env, state, expectedSeqNum, startBlocks) // After commit is reported on all chains, token prices should be updated in FeeQuoter. linkAddress := state.Chains[tc.dst].LinkToken.Address() @@ -439,7 +440,7 @@ func runFeeTokenTestCase(tc feeTokenTestCase) { require.Equal(tc.t, changeset.MockLinkPrice, timestampedPrice.Value) // Wait for all exec reports to land - changeset.ConfirmExecWithSeqNrsForAll(tc.t, tc.env.Env, state, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(tc.t, tc.env.Env, state, expectedSeqNumExec, startBlocks) if tc.assertTokenBalance { require.Len(tc.t, tc.tokenAmounts, 1) diff --git a/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go b/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go index 09023f1d321..0035be6f71c 100644 --- a/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go +++ b/integration-tests/smoke/ccip/ccip_gas_price_updates_test.go @@ -15,6 +15,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" ) @@ -22,19 +23,18 @@ import ( // Test_CCIPGasPriceUpdates tests that chain fee price updates are propagated correctly when // price reaches some deviation threshold or when the price has expired. func Test_CCIPGasPriceUpdates(t *testing.T) { - ctx := changeset.Context(t) + ctx := testhelpers.Context(t) callOpts := &bind.CallOpts{Context: ctx} var gasPriceExpiry = 5 * time.Second e, _, _ := testsetups.NewIntegrationEnvironment(t, - changeset.WithOCRConfigOverride(func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams { + testhelpers.WithOCRConfigOverride(func(params *changeset.CCIPOCRParams) { params.CommitOffChainConfig.RemoteGasPriceBatchWriteFrequency = *config.MustNewDuration(gasPriceExpiry) - return params }), ) state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) - changeset.AddLanesForAll(t, &e, state) + testhelpers.AddLanesForAll(t, &e, state) allChainSelectors := maps.Keys(e.Env.Chains) assert.GreaterOrEqual(t, len(allChainSelectors), 2, "test requires at least 2 chains") diff --git a/integration-tests/smoke/ccip/ccip_message_limitations_test.go b/integration-tests/smoke/ccip/ccip_message_limitations_test.go index 2882a34af63..01be93a01a1 100644 --- a/integration-tests/smoke/ccip/ccip_message_limitations_test.go +++ b/integration-tests/smoke/ccip/ccip_message_limitations_test.go @@ -15,6 +15,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" ) @@ -29,7 +30,7 @@ func Test_CCIPMessageLimitations(t *testing.T) { onChainState, err := changeset.LoadOnchainState(testEnv.Env) require.NoError(t, err) - changeset.AddLanesForAll(t, &testEnv, onChainState) + testhelpers.AddLanesForAll(t, &testEnv, onChainState) srcToken, _ := setupTokens( t, @@ -82,7 +83,7 @@ func Test_CCIPMessageLimitations(t *testing.T) { Receiver: common.LeftPadBytes(onChainState.Chains[chains[1]].Receiver.Address().Bytes(), 32), Data: []byte(strings.Repeat("0", int(chain0DestConfig.MaxDataBytes))), FeeToken: common.HexToAddress("0x0"), - ExtraArgs: changeset.MakeEVMExtraArgsV2(uint64(chain0DestConfig.MaxPerMsgGasLimit), true), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(uint64(chain0DestConfig.MaxPerMsgGasLimit), true), }, }, //{ // TODO: exec plugin never executed this message. CCIP-4471 @@ -136,7 +137,7 @@ func Test_CCIPMessageLimitations(t *testing.T) { Data: []byte("abc"), TokenAmounts: []router.ClientEVMTokenAmount{}, FeeToken: common.HexToAddress("0x0"), - ExtraArgs: changeset.MakeEVMExtraArgsV2(uint64(chain0DestConfig.MaxPerMsgGasLimit)+1, true), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(uint64(chain0DestConfig.MaxPerMsgGasLimit)+1, true), }, expRevert: true, }, @@ -145,18 +146,18 @@ func Test_CCIPMessageLimitations(t *testing.T) { // Need to keep track of the block number for each chain so that event subscription can be done from that block. startBlocks := make(map[uint64]*uint64) // Send a message from each chain to every other chain. - expectedSeqNum := make(map[changeset.SourceDestPair]uint64) - expectedSeqNumExec := make(map[changeset.SourceDestPair][]uint64) + expectedSeqNum := make(map[testhelpers.SourceDestPair]uint64) + expectedSeqNumExec := make(map[testhelpers.SourceDestPair][]uint64) for _, msg := range testMsgs { t.Logf("Sending msg: %s", msg.name) require.NotEqual(t, msg.fromChain, msg.toChain, "fromChain and toChain cannot be the same") startBlocks[msg.toChain] = nil - msgSentEvent, err := changeset.DoSendRequest( + msgSentEvent, err := testhelpers.DoSendRequest( t, testEnv.Env, onChainState, - changeset.WithSourceChain(msg.fromChain), - changeset.WithDestChain(msg.toChain), - changeset.WithTestRouter(false), - changeset.WithEvm2AnyMessage(msg.msg)) + testhelpers.WithSourceChain(msg.fromChain), + testhelpers.WithDestChain(msg.toChain), + testhelpers.WithTestRouter(false), + testhelpers.WithEvm2AnyMessage(msg.msg)) if msg.expRevert { t.Logf("Message reverted as expected") @@ -168,19 +169,19 @@ func Test_CCIPMessageLimitations(t *testing.T) { t.Logf("Message not reverted as expected") - expectedSeqNum[changeset.SourceDestPair{ + expectedSeqNum[testhelpers.SourceDestPair{ SourceChainSelector: msg.fromChain, DestChainSelector: msg.toChain, }] = msgSentEvent.SequenceNumber - expectedSeqNumExec[changeset.SourceDestPair{ + expectedSeqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: msg.fromChain, DestChainSelector: msg.toChain, }] = []uint64{msgSentEvent.SequenceNumber} } // Wait for all commit reports to land. - changeset.ConfirmCommitForAllWithExpectedSeqNums(t, testEnv.Env, onChainState, expectedSeqNum, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(t, testEnv.Env, onChainState, expectedSeqNum, startBlocks) // Wait for all exec reports to land - changeset.ConfirmExecWithSeqNrsForAll(t, testEnv.Env, onChainState, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, testEnv.Env, onChainState, expectedSeqNumExec, startBlocks) } diff --git a/integration-tests/smoke/ccip/ccip_messaging_test.go b/integration-tests/smoke/ccip/ccip_messaging_test.go index f010bab5ee1..3e28c7851ca 100644 --- a/integration-tests/smoke/ccip/ccip_messaging_test.go +++ b/integration-tests/smoke/ccip/ccip_messaging_test.go @@ -18,6 +18,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/offramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp" @@ -27,7 +28,7 @@ import ( type testCaseSetup struct { t *testing.T sender []byte - deployedEnv changeset.DeployedEnv + deployedEnv testhelpers.DeployedEnv onchainState changeset.CCIPOnChainState sourceChain, destChain uint64 } @@ -46,7 +47,7 @@ type messagingTestCaseOutput struct { func Test_CCIPMessaging(t *testing.T) { // Setup 2 chains and a single lane. - ctx := changeset.Context(t) + ctx := testhelpers.Context(t) e, _, _ := testsetups.NewIntegrationEnvironment(t) state, err := changeset.LoadOnchainState(e.Env) @@ -63,7 +64,7 @@ func Test_CCIPMessaging(t *testing.T) { ", dest chain selector:", destChain, ) // connect a single lane, source to dest - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, sourceChain, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, sourceChain, destChain, false) var ( replayed bool @@ -88,8 +89,8 @@ func Test_CCIPMessaging(t *testing.T) { }, common.HexToAddress("0xdead"), []byte("hello eoa"), - nil, // default extraArgs - changeset.EXECUTION_STATE_SUCCESS, // success because offRamp won't call an EOA + nil, // default extraArgs + testhelpers.EXECUTION_STATE_SUCCESS, // success because offRamp won't call an EOA ) }) @@ -102,8 +103,8 @@ func Test_CCIPMessaging(t *testing.T) { }, state.Chains[destChain].FeeQuoter.Address(), []byte("hello FeeQuoter"), - nil, // default extraArgs - changeset.EXECUTION_STATE_SUCCESS, // success because offRamp won't call a contract not implementing CCIPReceiver + nil, // default extraArgs + testhelpers.EXECUTION_STATE_SUCCESS, // success because offRamp won't call a contract not implementing CCIPReceiver ) }) @@ -119,7 +120,7 @@ func Test_CCIPMessaging(t *testing.T) { state.Chains[destChain].Receiver.Address(), []byte("hello CCIPReceiver"), nil, // default extraArgs - changeset.EXECUTION_STATE_SUCCESS, + testhelpers.EXECUTION_STATE_SUCCESS, func(t *testing.T) { iter, err := state.Chains[destChain].Receiver.FilterMessageReceived(&bind.FilterOpts{ Context: ctx, @@ -143,8 +144,8 @@ func Test_CCIPMessaging(t *testing.T) { }, state.Chains[destChain].Receiver.Address(), []byte("hello CCIPReceiver with low exec gas"), - changeset.MakeEVMExtraArgsV2(1, false), // 1 gas is too low. - changeset.EXECUTION_STATE_FAILURE, // state would be failed onchain due to low gas + testhelpers.MakeEVMExtraArgsV2(1, false), // 1 gas is too low. + testhelpers.EXECUTION_STATE_FAILURE, // state would be failed onchain due to low gas ) manuallyExecute(ctx, t, latestHead.Number.Uint64(), state, destChain, out, sourceChain, e, sender) @@ -162,7 +163,7 @@ func manuallyExecute( destChain uint64, out messagingTestCaseOutput, sourceChain uint64, - e changeset.DeployedEnv, + e testhelpers.DeployedEnv, sender []byte, ) { merkleRoot := getMerkleRoot( @@ -229,7 +230,7 @@ func manuallyExecute( newExecutionState, err := state.Chains[destChain].OffRamp.GetExecutionState(&bind.CallOpts{Context: ctx}, sourceChain, out.msgSentEvent.SequenceNumber) require.NoError(t, err) - require.Equal(t, uint8(changeset.EXECUTION_STATE_SUCCESS), newExecutionState) + require.Equal(t, uint8(testhelpers.EXECUTION_STATE_SUCCESS), newExecutionState) } func getMerkleRoot( @@ -285,12 +286,12 @@ func getMessageHash( return iter.Event.MessageHash } -func sleepAndReplay(t *testing.T, e changeset.DeployedEnv, sourceChain, destChain uint64) { +func sleepAndReplay(t *testing.T, e testhelpers.DeployedEnv, sourceChain, destChain uint64) { time.Sleep(30 * time.Second) replayBlocks := make(map[uint64]uint64) replayBlocks[sourceChain] = 1 replayBlocks[destChain] = 1 - changeset.ReplayLogs(t, e.Env.Offchain, replayBlocks) + testhelpers.ReplayLogs(t, e.Env.Offchain, replayBlocks) } func runMessagingTestCase( @@ -309,20 +310,20 @@ func runMessagingTestCase( require.Equal(tc.t, tc.nonce, latestNonce) startBlocks := make(map[uint64]*uint64) - msgSentEvent := changeset.TestSendRequest(tc.t, tc.deployedEnv.Env, tc.onchainState, tc.sourceChain, tc.destChain, false, router.ClientEVM2AnyMessage{ + msgSentEvent := testhelpers.TestSendRequest(tc.t, tc.deployedEnv.Env, tc.onchainState, tc.sourceChain, tc.destChain, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(receiver.Bytes(), 32), Data: msgData, TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: extraArgs, }) - expectedSeqNum := map[changeset.SourceDestPair]uint64{ + expectedSeqNum := map[testhelpers.SourceDestPair]uint64{ { SourceChainSelector: tc.sourceChain, DestChainSelector: tc.destChain, }: msgSentEvent.SequenceNumber, } - expectedSeqNumExec := map[changeset.SourceDestPair][]uint64{ + expectedSeqNumExec := map[testhelpers.SourceDestPair][]uint64{ { SourceChainSelector: tc.sourceChain, DestChainSelector: tc.destChain, @@ -336,20 +337,20 @@ func runMessagingTestCase( out.replayed = true } - changeset.ConfirmCommitForAllWithExpectedSeqNums(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNum, startBlocks) - execStates := changeset.ConfirmExecWithSeqNrsForAll(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNum, startBlocks) + execStates := testhelpers.ConfirmExecWithSeqNrsForAll(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNumExec, startBlocks) require.Equalf( tc.t, expectedExecutionState, - execStates[changeset.SourceDestPair{ + execStates[testhelpers.SourceDestPair{ SourceChainSelector: tc.sourceChain, DestChainSelector: tc.destChain, }][msgSentEvent.SequenceNumber], "wrong execution state for seq nr %d, expected %d, got %d", msgSentEvent.SequenceNumber, expectedExecutionState, - execStates[changeset.SourceDestPair{ + execStates[testhelpers.SourceDestPair{ SourceChainSelector: tc.sourceChain, DestChainSelector: tc.destChain, }][msgSentEvent.SequenceNumber], diff --git a/integration-tests/smoke/ccip/ccip_migration_to_v_1_6_test.go b/integration-tests/smoke/ccip/ccip_migration_to_v_1_6_test.go index 5c35be01f93..a0b62fe8182 100644 --- a/integration-tests/smoke/ccip/ccip_migration_to_v_1_6_test.go +++ b/integration-tests/smoke/ccip/ccip_migration_to_v_1_6_test.go @@ -12,6 +12,8 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" + v1_5testhelpers "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers/v1_5" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/v1_5" commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" @@ -26,7 +28,7 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { // Deploy 1.5 contracts (excluding pools to start, but including MCMS) . e, _, tEnv := testsetups.NewIntegrationEnvironment( t, - changeset.WithPrerequisiteDeployment( + testhelpers.WithPrerequisiteDeploymentOnly( &changeset.V1_5DeploymentConfig{ PriceRegStalenessThreshold: 60 * 60 * 24 * 14, // two weeks RMNConfig: &rmn_contract.RMNConfig{ @@ -43,11 +45,11 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { }, }, }), - changeset.WithChains(3), - changeset.WithUsersPerChain(2), + testhelpers.WithNumOfChains(3), + testhelpers.WithNumOfUsersPerChain(2), // for in-memory test it is important to set the dest chain id as 1337 otherwise the config digest will not match // between nodes' calculated digest and the digest set on the contract - changeset.WithChainIds([]uint64{chainselectors.GETH_TESTNET.EvmChainID}), + testhelpers.WithChainIDs([]uint64{chainselectors.GETH_TESTNET.EvmChainID}), ) state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) @@ -55,19 +57,19 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { require.Contains(t, e.Env.AllChainSelectors(), chainselectors.GETH_TESTNET.Selector) require.Len(t, allChainsExcept1337, 2) src1, src2, dest := allChainsExcept1337[0], allChainsExcept1337[1], chainselectors.GETH_TESTNET.Selector - pairs := []changeset.SourceDestPair{ + pairs := []testhelpers.SourceDestPair{ // as mentioned in the comment above, the dest chain id should be 1337 {SourceChainSelector: src1, DestChainSelector: dest}, {SourceChainSelector: src2, DestChainSelector: dest}, } // wire up all lanes // deploy onRamp, commit store, offramp , set ocr2config and send corresponding jobs - e.Env = v1_5.AddLanes(t, e.Env, state, pairs) + e.Env = v1_5testhelpers.AddLanes(t, e.Env, state, pairs) // permabless the commit stores e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(v1_5.PermaBlessCommitStoreCS), + Changeset: commonchangeset.WrapChangeSet(v1_5.PermaBlessCommitStoreChangeset), Config: v1_5.PermaBlessCommitStoreConfig{ Configs: map[uint64]v1_5.PermaBlessCommitStoreConfigPerDest{ dest: { @@ -93,11 +95,11 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { tEnv.UpdateDeployedEnvironment(e) // ensure that all lanes are functional for _, pair := range pairs { - sentEvent, err := v1_5.SendRequest(t, e.Env, state, - changeset.WithSourceChain(pair.SourceChainSelector), - changeset.WithDestChain(pair.DestChainSelector), - changeset.WithTestRouter(false), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + sentEvent, err := v1_5testhelpers.SendRequest(t, e.Env, state, + testhelpers.WithSourceChain(pair.SourceChainSelector), + testhelpers.WithDestChain(pair.DestChainSelector), + testhelpers.WithTestRouter(false), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[pair.DestChainSelector].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, @@ -110,8 +112,8 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { destChain := e.Env.Chains[pair.DestChainSelector] destStartBlock, err := destChain.Client.HeaderByNumber(context.Background(), nil) require.NoError(t, err) - v1_5.WaitForCommit(t, e.Env.Chains[pair.SourceChainSelector], destChain, state.Chains[dest].CommitStore[src1], sentEvent.Message.SequenceNumber) - v1_5.WaitForExecute(t, e.Env.Chains[pair.SourceChainSelector], destChain, state.Chains[dest].EVM2EVMOffRamp[src1], []uint64{sentEvent.Message.SequenceNumber}, destStartBlock.Number.Uint64()) + v1_5testhelpers.WaitForCommit(t, e.Env.Chains[pair.SourceChainSelector], destChain, state.Chains[dest].CommitStore[src1], sentEvent.Message.SequenceNumber) + v1_5testhelpers.WaitForExecute(t, e.Env.Chains[pair.SourceChainSelector], destChain, state.Chains[dest].EVM2EVMOffRamp[src1], []uint64{sentEvent.Message.SequenceNumber}, destStartBlock.Number.Uint64()) } // now that all 1.5 lanes work transfer ownership of the contracts to MCMS @@ -149,13 +151,13 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { // add 1.6 contracts to the environment and send 1.6 jobs // First we need to deploy Homechain contracts and restart the nodes with updated cap registry // in this test we have already deployed home chain contracts and the nodes are already running with the deployed cap registry. - e = changeset.AddCCIPContractsToEnvironment(t, e.Env.AllChainSelectors(), tEnv) + e = testhelpers.AddCCIPContractsToEnvironment(t, e.Env.AllChainSelectors(), tEnv) // Set RMNProxy to point to RMNRemote. // nonce manager should point to 1.5 ramps e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { // as we have already transferred ownership for RMNProxy to MCMS, it needs to be done via MCMS proposal - Changeset: commonchangeset.WrapChangeSet(changeset.SetRMNRemoteOnRMNProxy), + Changeset: commonchangeset.WrapChangeSet(changeset.SetRMNRemoteOnRMNProxyChangeset), Config: changeset.SetRMNRemoteOnRMNProxyConfig{ ChainSelectors: e.Env.AllChainSelectors(), MCMSConfig: &changeset.MCMSConfig{ @@ -164,7 +166,7 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateNonceManagersCS), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateNonceManagersChangeset), Config: changeset.UpdateNonceManagerConfig{ // we only have lanes between src1 --> dest UpdatesByChain: map[uint64]changeset.NonceManagerUpdate{ @@ -205,24 +207,24 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { require.NoError(t, err) // Enable a single 1.6 lane with test router - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, src1, dest, true) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &e, state, src1, dest, true) require.GreaterOrEqual(t, len(e.Users[src1]), 2) - changeset.ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks) + testhelpers.ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks) startBlocks := make(map[uint64]*uint64) latesthdr, err := e.Env.Chains[dest].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) block := latesthdr.Number.Uint64() startBlocks[dest] = &block - expectedSeqNumExec := make(map[changeset.SourceDestPair][]uint64) - msgSentEvent, err := changeset.DoSendRequest( + expectedSeqNumExec := make(map[testhelpers.SourceDestPair][]uint64) + msgSentEvent, err := testhelpers.DoSendRequest( t, e.Env, state, - changeset.WithSourceChain(src1), - changeset.WithDestChain(dest), - changeset.WithTestRouter(true), + testhelpers.WithSourceChain(src1), + testhelpers.WithDestChain(dest), + testhelpers.WithTestRouter(true), // Send traffic across single 1.6 lane with a DIFFERENT ( very important to not mess with real sender nonce) sender // from test router to ensure 1.6 is working. - changeset.WithSender(e.Users[src1][1]), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + testhelpers.WithSender(e.Users[src1][1]), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, @@ -231,21 +233,21 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { })) require.NoError(t, err) - expectedSeqNumExec[changeset.SourceDestPair{ + expectedSeqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: src1, DestChainSelector: dest, }] = []uint64{msgSentEvent.SequenceNumber} // Wait for all exec reports to land - changeset.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) // send a message from real router, the send requested event should be received in 1.5 onRamp // the request should get delivered to 1.5 offRamp - sentEventBeforeSwitch, err := v1_5.SendRequest(t, e.Env, state, - changeset.WithSourceChain(src1), - changeset.WithDestChain(dest), - changeset.WithTestRouter(false), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + sentEventBeforeSwitch, err := v1_5testhelpers.SendRequest(t, e.Env, state, + testhelpers.WithSourceChain(src1), + testhelpers.WithDestChain(dest), + testhelpers.WithTestRouter(false), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, @@ -259,7 +261,7 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { // now that the 1.6 lane is working, we can enable the real router e.Env, err = commonchangeset.ApplyChangesets(t, e.Env, e.TimelockContracts(t), []commonchangeset.ChangesetApplication{ { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOnRampsDests), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOnRampsDestsChangeset), Config: changeset.UpdateOnRampDestsConfig{ UpdatesByChain: map[uint64]map[uint64]changeset.OnRampDestinationUpdate{ src1: { @@ -273,7 +275,7 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { }, }, { - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOffRampSources), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateOffRampSourcesChangeset), Config: changeset.UpdateOffRampSourcesConfig{ UpdatesByChain: map[uint64]map[uint64]changeset.OffRampSourceUpdate{ dest: { @@ -287,7 +289,7 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { }, { // this needs to be MCMS proposal as the router contract is owned by MCMS - Changeset: commonchangeset.WrapChangeSet(changeset.UpdateRouterRamps), + Changeset: commonchangeset.WrapChangeSet(changeset.UpdateRouterRampsChangeset), Config: changeset.UpdateRouterRampsConfig{ TestRouter: false, MCMS: &changeset.MCMSConfig{ @@ -316,12 +318,12 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { // the request should get delivered to 1.6 offRamp destStartBlock, err := e.Env.Chains[dest].Client.HeaderByNumber(context.Background(), nil) require.NoError(t, err) - sentEventAfterSwitch, err := changeset.DoSendRequest( + sentEventAfterSwitch, err := testhelpers.DoSendRequest( t, e.Env, state, - changeset.WithSourceChain(src1), - changeset.WithDestChain(dest), - changeset.WithTestRouter(false), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + testhelpers.WithSourceChain(src1), + testhelpers.WithDestChain(dest), + testhelpers.WithTestRouter(false), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, @@ -330,22 +332,22 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { })) require.NoError(t, err) // verify that before switch message is received in 1.5 offRamp - v1_5.WaitForExecute(t, e.Env.Chains[src1], e.Env.Chains[dest], state.Chains[dest].EVM2EVMOffRamp[src1], + v1_5testhelpers.WaitForExecute(t, e.Env.Chains[src1], e.Env.Chains[dest], state.Chains[dest].EVM2EVMOffRamp[src1], []uint64{sentEventBeforeSwitch.Message.SequenceNumber}, destStartBlock.Number.Uint64()) // verify that after switch message is received in 1.6 offRamp - expectedSeqNumExec[changeset.SourceDestPair{ + expectedSeqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: src1, DestChainSelector: dest, }] = []uint64{sentEventAfterSwitch.SequenceNumber} - changeset.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, e.Env, state, expectedSeqNumExec, startBlocks) // confirm that the other lane src2->dest is still working with v1.5 - sentEventOnOtherLane, err := v1_5.SendRequest(t, e.Env, state, - changeset.WithSourceChain(src2), - changeset.WithDestChain(dest), - changeset.WithTestRouter(false), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + sentEventOnOtherLane, err := v1_5testhelpers.SendRequest(t, e.Env, state, + testhelpers.WithSourceChain(src2), + testhelpers.WithDestChain(dest), + testhelpers.WithTestRouter(false), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, @@ -355,6 +357,6 @@ func TestMigrateFromV1_5ToV1_6(t *testing.T) { ) require.NoError(t, err) require.NotNil(t, sentEventOnOtherLane) - v1_5.WaitForExecute(t, e.Env.Chains[src2], e.Env.Chains[dest], state.Chains[dest].EVM2EVMOffRamp[src2], + v1_5testhelpers.WaitForExecute(t, e.Env.Chains[src2], e.Env.Chains[dest], state.Chains[dest].EVM2EVMOffRamp[src2], []uint64{sentEventOnOtherLane.Message.SequenceNumber}, destStartBlock.Number.Uint64()) } diff --git a/integration-tests/smoke/ccip/ccip_ooo_execution_test.go b/integration-tests/smoke/ccip/ccip_ooo_execution_test.go index 272c87e9996..004dd3989f8 100644 --- a/integration-tests/smoke/ccip/ccip_ooo_execution_test.go +++ b/integration-tests/smoke/ccip/ccip_ooo_execution_test.go @@ -15,6 +15,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" @@ -35,9 +36,9 @@ func Test_OutOfOrderExecution(t *testing.T) { ctx := tests.Context(t) tenv, _, _ := testsetups.NewIntegrationEnvironment( t, - changeset.WithUSDC(), - changeset.WithUSDCAttestationMissing(), - changeset.WithUsersPerChain(2), + testhelpers.WithUSDC(), + testhelpers.WithUSDCAttestationMissing(), + testhelpers.WithNumOfUsersPerChain(2), ) e := tenv.Env @@ -54,7 +55,7 @@ func Test_OutOfOrderExecution(t *testing.T) { oneE18 := new(big.Int).SetUint64(1e18) - srcToken, _, destToken, _, err := changeset.DeployTransferableToken( + srcToken, _, destToken, _, err := testhelpers.DeployTransferableToken( lggr, tenv.Env.Chains, sourceChain, @@ -67,26 +68,26 @@ func Test_OutOfOrderExecution(t *testing.T) { ) require.NoError(t, err) - srcUSDC, destUSDC, err := changeset.ConfigureUSDCTokenPools(lggr, e.Chains, sourceChain, destChain, state) + srcUSDC, destUSDC, err := testhelpers.ConfigureUSDCTokenPools(lggr, e.Chains, sourceChain, destChain, state) require.NoError(t, err) - err = changeset.UpdateFeeQuoterForUSDC(lggr, e.Chains[sourceChain], state.Chains[sourceChain], destChain, srcUSDC) + err = testhelpers.UpdateFeeQuoterForUSDC(lggr, e.Chains[sourceChain], state.Chains[sourceChain], destChain, srcUSDC) require.NoError(t, err) - err = changeset.UpdateFeeQuoterForUSDC(lggr, e.Chains[destChain], state.Chains[destChain], sourceChain, destUSDC) + err = testhelpers.UpdateFeeQuoterForUSDC(lggr, e.Chains[destChain], state.Chains[destChain], sourceChain, destUSDC) require.NoError(t, err) - changeset.MintAndAllow( + testhelpers.MintAndAllow( t, e, state, - map[uint64][]changeset.MintTokenInfo{ + map[uint64][]testhelpers.MintTokenInfo{ sourceChain: { - changeset.NewMintTokenInfo(ownerSourceChain, srcToken, srcUSDC), - changeset.NewMintTokenWithCustomSender(ownerSourceChain, anotherSender, srcToken), + testhelpers.NewMintTokenInfo(ownerSourceChain, srcToken, srcUSDC), + testhelpers.NewMintTokenWithCustomSender(ownerSourceChain, anotherSender, srcToken), }, }, ) - changeset.AddLanesForAll(t, &tenv, state) + testhelpers.AddLanesForAll(t, &tenv, state) tokenTransfer := []router.ClientEVMTokenAmount{ { @@ -101,7 +102,7 @@ func Test_OutOfOrderExecution(t *testing.T) { }, } - identifier := changeset.SourceDestPair{ + identifier := testhelpers.SourceDestPair{ SourceChainSelector: sourceChain, DestChainSelector: destChain, } @@ -116,7 +117,7 @@ func Test_OutOfOrderExecution(t *testing.T) { // Out of order execution to the EOA should be properly executed firstReceiver := utils.RandomAddress() - firstMessage, _ := changeset.Transfer( + firstMessage, _ := testhelpers.Transfer( ctx, t, e, @@ -126,16 +127,16 @@ func Test_OutOfOrderExecution(t *testing.T) { tokenTransfer, firstReceiver, nil, - changeset.MakeEVMExtraArgsV2(0, true), + testhelpers.MakeEVMExtraArgsV2(0, true), ) - expectedStatuses[firstMessage.SequenceNumber] = changeset.EXECUTION_STATE_SUCCESS + expectedStatuses[firstMessage.SequenceNumber] = testhelpers.EXECUTION_STATE_SUCCESS t.Logf("Out of order messages sent from chain %d to chain %d with sequence number %d", sourceChain, destChain, firstMessage.SequenceNumber, ) // Ordered execution should fail because attestation is not present secondReceiver := utils.RandomAddress() - secondMsg, _ := changeset.Transfer( + secondMsg, _ := testhelpers.Transfer( ctx, t, e, @@ -153,7 +154,7 @@ func Test_OutOfOrderExecution(t *testing.T) { // Ordered token transfer should fail, because previous message cannot be executed thirdReceiver := utils.RandomAddress() - thirdMessage, _ := changeset.Transfer( + thirdMessage, _ := testhelpers.Transfer( ctx, t, e, @@ -163,7 +164,7 @@ func Test_OutOfOrderExecution(t *testing.T) { tokenTransfer, thirdReceiver, nil, - changeset.MakeEVMExtraArgsV2(0, false), + testhelpers.MakeEVMExtraArgsV2(0, false), ) t.Logf("Ordered token transfer from chain %d to chain %d with sequence number %d", sourceChain, destChain, thirdMessage.SequenceNumber, @@ -171,7 +172,7 @@ func Test_OutOfOrderExecution(t *testing.T) { // Out of order programmable token transfer should be executed fourthReceiver := state.Chains[destChain].Receiver.Address() - fourthMessage, _ := changeset.Transfer( + fourthMessage, _ := testhelpers.Transfer( ctx, t, e, @@ -181,34 +182,34 @@ func Test_OutOfOrderExecution(t *testing.T) { tokenTransfer, fourthReceiver, []byte("this message has enough gas to execute"), - changeset.MakeEVMExtraArgsV2(300_000, true), + testhelpers.MakeEVMExtraArgsV2(300_000, true), ) - expectedStatuses[fourthMessage.SequenceNumber] = changeset.EXECUTION_STATE_SUCCESS + expectedStatuses[fourthMessage.SequenceNumber] = testhelpers.EXECUTION_STATE_SUCCESS t.Logf("Out of order programmable token transfer from chain %d to chain %d with sequence number %d", sourceChain, destChain, fourthMessage.SequenceNumber, ) // Ordered token transfer, but using different sender, should be executed fifthReceiver := utils.RandomAddress() - fifthMessage, err := changeset.DoSendRequest(t, e, state, - changeset.WithSender(anotherSender), - changeset.WithSourceChain(sourceChain), - changeset.WithDestChain(destChain), - changeset.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ + fifthMessage, err := testhelpers.DoSendRequest(t, e, state, + testhelpers.WithSender(anotherSender), + testhelpers.WithSourceChain(sourceChain), + testhelpers.WithDestChain(destChain), + testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(fifthReceiver.Bytes(), 32), Data: nil, TokenAmounts: tokenTransfer, FeeToken: common.HexToAddress("0x0"), - ExtraArgs: changeset.MakeEVMExtraArgsV2(0, false), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(0, false), })) require.NoError(t, err) - expectedStatuses[fifthMessage.SequenceNumber] = changeset.EXECUTION_STATE_SUCCESS + expectedStatuses[fifthMessage.SequenceNumber] = testhelpers.EXECUTION_STATE_SUCCESS t.Logf("Ordered message send by %v from chain %d to chain %d with sequence number %d", anotherSender.From, sourceChain, destChain, fifthMessage.SequenceNumber, ) // All messages are committed, even these which are going to be reverted during the exec - _, err = changeset.ConfirmCommitWithExpectedSeqNumRange( + _, err = testhelpers.ConfirmCommitWithExpectedSeqNumRange( t, e.Chains[sourceChain], e.Chains[destChain], @@ -223,11 +224,11 @@ func Test_OutOfOrderExecution(t *testing.T) { ) require.NoError(t, err) - execStates := changeset.ConfirmExecWithSeqNrsForAll( + execStates := testhelpers.ConfirmExecWithSeqNrsForAll( t, e, state, - map[changeset.SourceDestPair][]uint64{ + map[testhelpers.SourceDestPair][]uint64{ identifier: { firstMessage.SequenceNumber, fourthMessage.SequenceNumber, @@ -240,21 +241,21 @@ func Test_OutOfOrderExecution(t *testing.T) { secondMsgState, err := state.Chains[destChain].OffRamp.GetExecutionState(&bind.CallOpts{Context: ctx}, sourceChain, secondMsg.SequenceNumber) require.NoError(t, err) - require.Equal(t, uint8(changeset.EXECUTION_STATE_UNTOUCHED), secondMsgState) + require.Equal(t, uint8(testhelpers.EXECUTION_STATE_UNTOUCHED), secondMsgState) thirdMsgState, err := state.Chains[destChain].OffRamp.GetExecutionState(&bind.CallOpts{Context: ctx}, sourceChain, thirdMessage.SequenceNumber) require.NoError(t, err) - require.Equal(t, uint8(changeset.EXECUTION_STATE_UNTOUCHED), thirdMsgState) + require.Equal(t, uint8(testhelpers.EXECUTION_STATE_UNTOUCHED), thirdMsgState) - changeset.WaitForTheTokenBalance(ctx, t, destToken.Address(), firstReceiver, e.Chains[destChain], oneE18) - changeset.WaitForTheTokenBalance(ctx, t, destUSDC.Address(), secondReceiver, e.Chains[destChain], big.NewInt(0)) - changeset.WaitForTheTokenBalance(ctx, t, destToken.Address(), thirdReceiver, e.Chains[destChain], big.NewInt(0)) - changeset.WaitForTheTokenBalance(ctx, t, destToken.Address(), fourthReceiver, e.Chains[destChain], oneE18) - changeset.WaitForTheTokenBalance(ctx, t, destToken.Address(), fifthReceiver, e.Chains[destChain], oneE18) + testhelpers.WaitForTheTokenBalance(ctx, t, destToken.Address(), firstReceiver, e.Chains[destChain], oneE18) + testhelpers.WaitForTheTokenBalance(ctx, t, destUSDC.Address(), secondReceiver, e.Chains[destChain], big.NewInt(0)) + testhelpers.WaitForTheTokenBalance(ctx, t, destToken.Address(), thirdReceiver, e.Chains[destChain], big.NewInt(0)) + testhelpers.WaitForTheTokenBalance(ctx, t, destToken.Address(), fourthReceiver, e.Chains[destChain], oneE18) + testhelpers.WaitForTheTokenBalance(ctx, t, destToken.Address(), fifthReceiver, e.Chains[destChain], oneE18) } func pickFirstAvailableUser( - tenv changeset.DeployedEnv, + tenv testhelpers.DeployedEnv, sourceChain uint64, e deployment.Environment, ) (*bind.TransactOpts, error) { diff --git a/integration-tests/contracts/ccipreader_test.go b/integration-tests/smoke/ccip/ccip_reader_test.go similarity index 96% rename from integration-tests/contracts/ccipreader_test.go rename to integration-tests/smoke/ccip/ccip_reader_test.go index b7ea027a568..f907c06f58f 100644 --- a/integration-tests/contracts/ccipreader_test.go +++ b/integration-tests/smoke/ccip/ccip_reader_test.go @@ -1,4 +1,4 @@ -package contracts +package smoke import ( "context" @@ -18,6 +18,7 @@ import ( "github.com/stretchr/testify/require" "go.uber.org/zap/zapcore" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" "github.com/smartcontractkit/chainlink/v2/core/utils/testutils/heavyweight" "github.com/smartcontractkit/chainlink-ccip/plugintypes" @@ -590,15 +591,15 @@ func TestCCIPReader_GetExpectedNextSequenceNumber(t *testing.T) { t.Parallel() ctx := tests.Context(t) //env := NewMemoryEnvironmentContractsOnly(t, logger.TestLogger(t), 2, 4, nil) - env, _ := changeset.NewMemoryEnvironment(t) + env, _ := testhelpers.NewMemoryEnvironment(t) state, err := changeset.LoadOnchainState(env.Env) require.NoError(t, err) selectors := env.Env.AllChainSelectors() destChain, srcChain := selectors[0], selectors[1] - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, destChain, srcChain, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, srcChain, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, destChain, srcChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, srcChain, destChain, false) reader := testSetupRealContracts( ctx, @@ -619,8 +620,8 @@ func TestCCIPReader_GetExpectedNextSequenceNumber(t *testing.T) { maxExpectedSeqNum := uint64(10) var i uint64 for i = 1; i < maxExpectedSeqNum; i++ { - msg := changeset.DefaultRouterMessage(state.Chains[destChain].Receiver.Address()) - msgSentEvent := changeset.TestSendRequest(t, env.Env, state, srcChain, destChain, false, msg) + msg := testhelpers.DefaultRouterMessage(state.Chains[destChain].Receiver.Address()) + msgSentEvent := testhelpers.TestSendRequest(t, env.Env, state, srcChain, destChain, false, msg) require.Equal(t, uint64(i), msgSentEvent.SequenceNumber) require.Equal(t, uint64(i), msgSentEvent.Message.Header.Nonce) // check outbound nonce incremented seqNum, err2 := reader.GetExpectedNextSequenceNumber(ctx, cs(srcChain), cs(destChain)) @@ -700,15 +701,15 @@ func TestCCIPReader_Nonces(t *testing.T) { func Test_GetChainFeePriceUpdates(t *testing.T) { t.Parallel() ctx := tests.Context(t) - env, _ := changeset.NewMemoryEnvironment(t) + env, _ := testhelpers.NewMemoryEnvironment(t) state, err := changeset.LoadOnchainState(env.Env) require.NoError(t, err) selectors := env.Env.AllChainSelectors() chain1, chain2 := selectors[0], selectors[1] - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, chain2, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, chain1, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, chain2, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, chain1, false) // Change the gas price for chain2 feeQuoter := state.Chains[chain1].FeeQuoter @@ -756,15 +757,15 @@ func Test_GetChainFeePriceUpdates(t *testing.T) { func Test_LinkPriceUSD(t *testing.T) { t.Parallel() ctx := tests.Context(t) - env, _ := changeset.NewMemoryEnvironment(t) + env, _ := testhelpers.NewMemoryEnvironment(t) state, err := changeset.LoadOnchainState(env.Env) require.NoError(t, err) selectors := env.Env.AllChainSelectors() chain1, chain2 := selectors[0], selectors[1] - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, chain2, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, chain1, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, chain2, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, chain1, false) reader := testSetupRealContracts( ctx, @@ -785,22 +786,22 @@ func Test_LinkPriceUSD(t *testing.T) { linkPriceUSD, err := reader.LinkPriceUSD(ctx) require.NoError(t, err) require.NotNil(t, linkPriceUSD.Int) - require.Equal(t, changeset.DefaultLinkPrice, linkPriceUSD.Int) + require.Equal(t, testhelpers.DefaultLinkPrice, linkPriceUSD.Int) } func Test_GetMedianDataAvailabilityGasConfig(t *testing.T) { t.Parallel() ctx := tests.Context(t) - env, _ := changeset.NewMemoryEnvironment(t, changeset.WithChains(4)) + env, _ := testhelpers.NewMemoryEnvironment(t, testhelpers.WithNumOfChains(4)) state, err := changeset.LoadOnchainState(env.Env) require.NoError(t, err) selectors := env.Env.AllChainSelectors() destChain, chain1, chain2, chain3 := selectors[0], selectors[1], selectors[2], selectors[3] - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, destChain, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, destChain, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain3, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, destChain, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain3, destChain, false) boundContracts := map[cciptypes.ChainSelector][]types.BoundContract{} for i, selector := range env.Env.AllChainSelectorsExcluding([]uint64{destChain}) { @@ -850,15 +851,15 @@ func Test_GetMedianDataAvailabilityGasConfig(t *testing.T) { func Test_GetWrappedNativeTokenPriceUSD(t *testing.T) { t.Parallel() ctx := tests.Context(t) - env, _ := changeset.NewMemoryEnvironment(t) + env, _ := testhelpers.NewMemoryEnvironment(t) state, err := changeset.LoadOnchainState(env.Env) require.NoError(t, err) selectors := env.Env.AllChainSelectors() chain1, chain2 := selectors[0], selectors[1] - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, chain2, false) - changeset.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, chain1, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain1, chain2, false) + testhelpers.AddLaneWithDefaultPricesAndFeeQuoterConfig(t, &env, state, chain2, chain1, false) reader := testSetupRealContracts( ctx, @@ -884,7 +885,7 @@ func Test_GetWrappedNativeTokenPriceUSD(t *testing.T) { // Only chainD has reader contracts bound require.Len(t, prices, 1) - require.Equal(t, changeset.DefaultWethPrice, prices[cciptypes.ChainSelector(chain1)].Int) + require.Equal(t, testhelpers.DefaultWethPrice, prices[cciptypes.ChainSelector(chain1)].Int) } // Benchmark Results: @@ -1341,7 +1342,7 @@ func testSetupRealContracts( destChain uint64, toBindContracts map[cciptypes.ChainSelector][]types.BoundContract, toMockBindings map[cciptypes.ChainSelector][]types.BoundContract, - env changeset.DeployedEnv, + env testhelpers.DeployedEnv, ) ccipreaderpkg.CCIPReader { db := pgtest.NewSqlxDB(t) lpOpts := logpoller.Opts{ diff --git a/integration-tests/smoke/ccip/ccip_rmn_test.go b/integration-tests/smoke/ccip/ccip_rmn_test.go index fcf17956dc0..d8f5aae0882 100644 --- a/integration-tests/smoke/ccip/ccip_rmn_test.go +++ b/integration-tests/smoke/ccip/ccip_rmn_test.go @@ -23,6 +23,7 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" "github.com/smartcontractkit/chainlink/deployment/environment/devenv" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home" @@ -245,7 +246,7 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { t.Logf("Running RMN test case: %s", tc.name) envWithRMN, rmnCluster, _ := testsetups.NewIntegrationEnvironment(t, - changeset.WithRMNEnabled(len(tc.rmnNodes)), + testhelpers.WithRMNEnabled(len(tc.rmnNodes)), ) t.Logf("envWithRmn: %#v", envWithRMN) @@ -286,7 +287,7 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { t.Logf("RMNHome candidateDigest after setting new candidate: %x", candidateDigest[:]) t.Logf("Promoting RMNHome candidate with candidateDigest: %x", candidateDigest[:]) - _, err = changeset.PromoteCandidateConfigChangeset(envWithRMN.Env, changeset.PromoteRMNHomeCandidateConfig{ + _, err = changeset.PromoteRMNHomeCandidateConfigChangeset(envWithRMN.Env, changeset.PromoteRMNHomeCandidateConfig{ HomeChainSelector: envWithRMN.HomeChainSel, DigestToPromote: candidateDigest, }) @@ -319,8 +320,8 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { tc.killMarkedRmnNodes(t, rmnCluster) - changeset.ReplayLogs(t, envWithRMN.Env.Offchain, envWithRMN.ReplayBlocks) - changeset.AddLanesForAll(t, &envWithRMN, onChainState) + testhelpers.ReplayLogs(t, envWithRMN.Env.Offchain, envWithRMN.ReplayBlocks) + testhelpers.AddLanesForAll(t, &envWithRMN, onChainState) disabledNodes := tc.disableOraclesIfThisIsACursingTestCase(ctx, t, envWithRMN) startBlocks, seqNumCommit, seqNumExec := tc.sendMessages(t, onChainState, envWithRMN) @@ -332,7 +333,7 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { tc.enableOracles(ctx, t, envWithRMN, disabledNodes) - expectedSeqNum := make(map[changeset.SourceDestPair]uint64) + expectedSeqNum := make(map[testhelpers.SourceDestPair]uint64) for k, v := range seqNumCommit { cursedSubjectsOfDest, exists := tc.pf.cursedSubjectsPerChainSel[k.DestChainSelector] shouldSkip := exists && (slices.Contains(cursedSubjectsOfDest, globalCurse) || @@ -354,13 +355,13 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { commitReportReceived := make(chan struct{}) go func() { if len(expectedSeqNum) > 0 { - changeset.ConfirmCommitForAllWithExpectedSeqNums(t, envWithRMN.Env, onChainState, expectedSeqNum, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(t, envWithRMN.Env, onChainState, expectedSeqNum, startBlocks) commitReportReceived <- struct{}{} } if len(seqNumCommit) > 0 && len(seqNumCommit) > len(expectedSeqNum) { // wait for a duration and assert that commit reports were not delivered for cursed source chains - changeset.ConfirmCommitForAllWithExpectedSeqNums(t, envWithRMN.Env, onChainState, seqNumCommit, startBlocks) + testhelpers.ConfirmCommitForAllWithExpectedSeqNums(t, envWithRMN.Env, onChainState, seqNumCommit, startBlocks) commitReportReceived <- struct{}{} } }() @@ -392,7 +393,7 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { if tc.waitForExec { t.Logf("⌛ Waiting for exec reports...") - changeset.ConfirmExecWithSeqNrsForAll(t, envWithRMN.Env, onChainState, seqNumExec, startBlocks) + testhelpers.ConfirmExecWithSeqNrsForAll(t, envWithRMN.Env, onChainState, seqNumExec, startBlocks) t.Logf("✅ Exec report") } } @@ -464,7 +465,7 @@ type testCasePopulatedFields struct { revokedCursedSubjectsPerChainSel map[uint64]map[uint64]time.Duration } -func (tc *rmnTestCase) populateFields(t *testing.T, envWithRMN changeset.DeployedEnv, rmnCluster devenv.RMNCluster) { +func (tc *rmnTestCase) populateFields(t *testing.T, envWithRMN testhelpers.DeployedEnv, rmnCluster devenv.RMNCluster) { require.GreaterOrEqual(t, len(envWithRMN.Env.Chains), 2, "test assumes at least two chains") for _, chain := range envWithRMN.Env.Chains { tc.pf.chainSelectors = append(tc.pf.chainSelectors, chain.Selector) @@ -553,7 +554,7 @@ func (tc rmnTestCase) killMarkedRmnNodes(t *testing.T, rmnCluster devenv.RMNClus } } -func (tc rmnTestCase) disableOraclesIfThisIsACursingTestCase(ctx context.Context, t *testing.T, envWithRMN changeset.DeployedEnv) []string { +func (tc rmnTestCase) disableOraclesIfThisIsACursingTestCase(ctx context.Context, t *testing.T, envWithRMN testhelpers.DeployedEnv) []string { disabledNodes := make([]string, 0) if len(tc.cursedSubjectsPerChain) > 0 { @@ -574,28 +575,28 @@ func (tc rmnTestCase) disableOraclesIfThisIsACursingTestCase(ctx context.Context return disabledNodes } -func (tc rmnTestCase) sendMessages(t *testing.T, onChainState changeset.CCIPOnChainState, envWithRMN changeset.DeployedEnv) (map[uint64]*uint64, map[changeset.SourceDestPair]uint64, map[changeset.SourceDestPair][]uint64) { +func (tc rmnTestCase) sendMessages(t *testing.T, onChainState changeset.CCIPOnChainState, envWithRMN testhelpers.DeployedEnv) (map[uint64]*uint64, map[testhelpers.SourceDestPair]uint64, map[testhelpers.SourceDestPair][]uint64) { startBlocks := make(map[uint64]*uint64) - seqNumCommit := make(map[changeset.SourceDestPair]uint64) - seqNumExec := make(map[changeset.SourceDestPair][]uint64) + seqNumCommit := make(map[testhelpers.SourceDestPair]uint64) + seqNumExec := make(map[testhelpers.SourceDestPair][]uint64) for _, msg := range tc.messagesToSend { fromChain := tc.pf.chainSelectors[msg.fromChainIdx] toChain := tc.pf.chainSelectors[msg.toChainIdx] for i := 0; i < msg.count; i++ { - msgSentEvent := changeset.TestSendRequest(t, envWithRMN.Env, onChainState, fromChain, toChain, false, router.ClientEVM2AnyMessage{ + msgSentEvent := testhelpers.TestSendRequest(t, envWithRMN.Env, onChainState, fromChain, toChain, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(onChainState.Chains[toChain].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - seqNumCommit[changeset.SourceDestPair{ + seqNumCommit[testhelpers.SourceDestPair{ SourceChainSelector: fromChain, DestChainSelector: toChain, }] = msgSentEvent.SequenceNumber - seqNumExec[changeset.SourceDestPair{ + seqNumExec[testhelpers.SourceDestPair{ SourceChainSelector: fromChain, DestChainSelector: toChain, }] = []uint64{msgSentEvent.SequenceNumber} @@ -609,7 +610,7 @@ func (tc rmnTestCase) sendMessages(t *testing.T, onChainState changeset.CCIPOnCh return startBlocks, seqNumCommit, seqNumExec } -func (tc rmnTestCase) callContractsToCurseChains(ctx context.Context, t *testing.T, onChainState changeset.CCIPOnChainState, envWithRMN changeset.DeployedEnv) { +func (tc rmnTestCase) callContractsToCurseChains(ctx context.Context, t *testing.T, onChainState changeset.CCIPOnChainState, envWithRMN testhelpers.DeployedEnv) { for _, remoteCfg := range tc.remoteChainsConfig { remoteSel := tc.pf.chainSelectors[remoteCfg.chainIdx] chState, ok := onChainState.Chains[remoteSel] @@ -644,7 +645,7 @@ func (tc rmnTestCase) callContractsToCurseChains(ctx context.Context, t *testing } } -func (tc rmnTestCase) callContractsToCurseAndRevokeCurse(ctx context.Context, eg *errgroup.Group, t *testing.T, onChainState changeset.CCIPOnChainState, envWithRMN changeset.DeployedEnv) { +func (tc rmnTestCase) callContractsToCurseAndRevokeCurse(ctx context.Context, eg *errgroup.Group, t *testing.T, onChainState changeset.CCIPOnChainState, envWithRMN testhelpers.DeployedEnv) { for _, remoteCfg := range tc.remoteChainsConfig { remoteSel := tc.pf.chainSelectors[remoteCfg.chainIdx] chState, ok := onChainState.Chains[remoteSel] @@ -700,7 +701,7 @@ func (tc rmnTestCase) callContractsToCurseAndRevokeCurse(ctx context.Context, eg } } -func (tc rmnTestCase) enableOracles(ctx context.Context, t *testing.T, envWithRMN changeset.DeployedEnv, nodeIDs []string) { +func (tc rmnTestCase) enableOracles(ctx context.Context, t *testing.T, envWithRMN testhelpers.DeployedEnv, nodeIDs []string) { for _, n := range nodeIDs { _, err := envWithRMN.Env.Offchain.EnableNode(ctx, &node.EnableNodeRequest{Id: n}) require.NoError(t, err) diff --git a/integration-tests/smoke/ccip/ccip_token_price_updates_test.go b/integration-tests/smoke/ccip/ccip_token_price_updates_test.go index e54790de24c..4c15eecc545 100644 --- a/integration-tests/smoke/ccip/ccip_token_price_updates_test.go +++ b/integration-tests/smoke/ccip/ccip_token_price_updates_test.go @@ -19,23 +19,23 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" ) func Test_CCIPTokenPriceUpdates(t *testing.T) { - ctx := changeset.Context(t) + ctx := testhelpers.Context(t) callOpts := &bind.CallOpts{Context: ctx} var tokenPriceExpiry = 5 * time.Second e, _, _ := testsetups.NewIntegrationEnvironment(t, - changeset.WithOCRConfigOverride(func(params changeset.CCIPOCRParams) changeset.CCIPOCRParams { + testhelpers.WithOCRConfigOverride(func(params *changeset.CCIPOCRParams) { params.CommitOffChainConfig.TokenPriceBatchWriteFrequency = *config.MustNewDuration(tokenPriceExpiry) - return params })) state, err := changeset.LoadOnchainState(e.Env) require.NoError(t, err) - changeset.AddLanesForAll(t, &e, state) + testhelpers.AddLanesForAll(t, &e, state) allChainSelectors := maps.Keys(e.Env.Chains) assert.GreaterOrEqual(t, len(allChainSelectors), 2, "test requires at least 2 chains") diff --git a/integration-tests/smoke/ccip/ccip_token_transfer_test.go b/integration-tests/smoke/ccip/ccip_token_transfer_test.go index 7946d6f8c7c..ef9a4bea8b8 100644 --- a/integration-tests/smoke/ccip/ccip_token_transfer_test.go +++ b/integration-tests/smoke/ccip/ccip_token_transfer_test.go @@ -12,6 +12,7 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/utils/tests" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" @@ -23,7 +24,7 @@ func TestTokenTransfer(t *testing.T) { ctx := tests.Context(t) tenv, _, _ := testsetups.NewIntegrationEnvironment(t, - changeset.WithUsersPerChain(3)) + testhelpers.WithNumOfUsersPerChain(3)) e := tenv.Env state, err := changeset.LoadOnchainState(e) @@ -43,7 +44,7 @@ func TestTokenTransfer(t *testing.T) { oneE18 := new(big.Int).SetUint64(1e18) // Deploy tokens and pool by CCIP Owner - srcToken, _, destToken, _, err := changeset.DeployTransferableToken( + srcToken, _, destToken, _, err := testhelpers.DeployTransferableToken( lggr, tenv.Env.Chains, sourceChain, @@ -57,7 +58,7 @@ func TestTokenTransfer(t *testing.T) { require.NoError(t, err) // Deploy Self Serve tokens and pool - selfServeSrcToken, _, selfServeDestToken, _, err := changeset.DeployTransferableToken( + selfServeSrcToken, _, selfServeDestToken, _, err := testhelpers.DeployTransferableToken( lggr, tenv.Env.Chains, sourceChain, @@ -69,25 +70,25 @@ func TestTokenTransfer(t *testing.T) { "SELF_SERVE_TOKEN", ) require.NoError(t, err) - changeset.AddLanesForAll(t, &tenv, state) + testhelpers.AddLanesForAll(t, &tenv, state) - changeset.MintAndAllow( + testhelpers.MintAndAllow( t, e, state, - map[uint64][]changeset.MintTokenInfo{ + map[uint64][]testhelpers.MintTokenInfo{ sourceChain: { - changeset.NewMintTokenInfo(selfServeSrcTokenPoolDeployer, selfServeSrcToken), - changeset.NewMintTokenInfo(ownerSourceChain, srcToken), + testhelpers.NewMintTokenInfo(selfServeSrcTokenPoolDeployer, selfServeSrcToken), + testhelpers.NewMintTokenInfo(ownerSourceChain, srcToken), }, destChain: { - changeset.NewMintTokenInfo(selfServeDestTokenPoolDeployer, selfServeDestToken), - changeset.NewMintTokenInfo(ownerDestChain, destToken), + testhelpers.NewMintTokenInfo(selfServeDestTokenPoolDeployer, selfServeDestToken), + testhelpers.NewMintTokenInfo(ownerDestChain, destToken), }, }, ) - tcs := []changeset.TestTransferRequest{ + tcs := []testhelpers.TestTransferRequest{ { Name: "Send token to EOA", SourceChain: sourceChain, @@ -102,7 +103,7 @@ func TestTokenTransfer(t *testing.T) { ExpectedTokenBalances: map[common.Address]*big.Int{ destToken.Address(): oneE18, }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "Send token to contract", @@ -118,7 +119,7 @@ func TestTokenTransfer(t *testing.T) { ExpectedTokenBalances: map[common.Address]*big.Int{ destToken.Address(): oneE18, }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "Send N tokens to contract", @@ -139,12 +140,12 @@ func TestTokenTransfer(t *testing.T) { }, }, Receiver: state.Chains[sourceChain].Receiver.Address(), - ExtraArgs: changeset.MakeEVMExtraArgsV2(300_000, false), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(300_000, false), ExpectedTokenBalances: map[common.Address]*big.Int{ selfServeSrcToken.Address(): new(big.Int).Add(oneE18, oneE18), srcToken.Address(): oneE18, }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "Sending token transfer with custom gasLimits to the EOA is successful", @@ -161,12 +162,12 @@ func TestTokenTransfer(t *testing.T) { }, }, Receiver: utils.RandomAddress(), - ExtraArgs: changeset.MakeEVMExtraArgsV2(1, false), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(1, false), ExpectedTokenBalances: map[common.Address]*big.Int{ selfServeSrcToken.Address(): oneE18, srcToken.Address(): new(big.Int).Add(oneE18, oneE18), }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "Sending PTT with too low gas limit leads to the revert when receiver is a contract", @@ -184,19 +185,19 @@ func TestTokenTransfer(t *testing.T) { }, Receiver: state.Chains[sourceChain].Receiver.Address(), Data: []byte("this should be reverted because gasLimit is too low, no tokens are transferred as well"), - ExtraArgs: changeset.MakeEVMExtraArgsV2(1, false), + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(1, false), ExpectedTokenBalances: map[common.Address]*big.Int{ selfServeSrcToken.Address(): big.NewInt(0), srcToken.Address(): big.NewInt(0), }, - ExpectedStatus: changeset.EXECUTION_STATE_FAILURE, + ExpectedStatus: testhelpers.EXECUTION_STATE_FAILURE, }, } startBlocks, expectedSeqNums, expectedExecutionStates, expectedTokenBalances := - changeset.TransferMultiple(ctx, t, e, state, tcs) + testhelpers.TransferMultiple(ctx, t, e, state, tcs) - err = changeset.ConfirmMultipleCommits( + err = testhelpers.ConfirmMultipleCommits( t, e.Chains, state.Chains, @@ -206,14 +207,14 @@ func TestTokenTransfer(t *testing.T) { ) require.NoError(t, err) - execStates := changeset.ConfirmExecWithSeqNrsForAll( + execStates := testhelpers.ConfirmExecWithSeqNrsForAll( t, e, state, - changeset.SeqNumberRangeToSlice(expectedSeqNums), + testhelpers.SeqNumberRangeToSlice(expectedSeqNums), startBlocks, ) require.Equal(t, expectedExecutionStates, execStates) - changeset.WaitForTokenBalances(ctx, t, e.Chains, expectedTokenBalances) + testhelpers.WaitForTokenBalances(ctx, t, e.Chains, expectedTokenBalances) } diff --git a/integration-tests/smoke/ccip/ccip_usdc_test.go b/integration-tests/smoke/ccip/ccip_usdc_test.go index 33af1570943..b64f8056c13 100644 --- a/integration-tests/smoke/ccip/ccip_usdc_test.go +++ b/integration-tests/smoke/ccip/ccip_usdc_test.go @@ -14,6 +14,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" @@ -33,9 +34,9 @@ func TestUSDCTokenTransfer(t *testing.T) { lggr := logger.TestLogger(t) ctx := tests.Context(t) tenv, _, _ := testsetups.NewIntegrationEnvironment(t, - changeset.WithUsersPerChain(3), - changeset.WithChains(3), - changeset.WithUSDC(), + testhelpers.WithNumOfUsersPerChain(3), + testhelpers.WithNumOfChains(3), + testhelpers.WithUSDC(), ) e := tenv.Env @@ -51,13 +52,13 @@ func TestUSDCTokenTransfer(t *testing.T) { ownerChainC := e.Chains[chainC].DeployerKey ownerChainB := e.Chains[chainB].DeployerKey - aChainUSDC, cChainUSDC, err := changeset.ConfigureUSDCTokenPools(lggr, e.Chains, chainA, chainC, state) + aChainUSDC, cChainUSDC, err := testhelpers.ConfigureUSDCTokenPools(lggr, e.Chains, chainA, chainC, state) require.NoError(t, err) - bChainUSDC, _, err := changeset.ConfigureUSDCTokenPools(lggr, e.Chains, chainB, chainC, state) + bChainUSDC, _, err := testhelpers.ConfigureUSDCTokenPools(lggr, e.Chains, chainB, chainC, state) require.NoError(t, err) - aChainToken, _, cChainToken, _, err := changeset.DeployTransferableToken( + aChainToken, _, cChainToken, _, err := testhelpers.DeployTransferableToken( lggr, tenv.Env.Chains, chainA, @@ -71,21 +72,21 @@ func TestUSDCTokenTransfer(t *testing.T) { require.NoError(t, err) // Add all lanes - changeset.AddLanesForAll(t, &tenv, state) + testhelpers.AddLanesForAll(t, &tenv, state) - changeset.MintAndAllow( + testhelpers.MintAndAllow( t, e, state, - map[uint64][]changeset.MintTokenInfo{ + map[uint64][]testhelpers.MintTokenInfo{ chainA: { - changeset.NewMintTokenInfo(ownerChainA, aChainUSDC, aChainToken), + testhelpers.NewMintTokenInfo(ownerChainA, aChainUSDC, aChainToken), }, chainB: { - changeset.NewMintTokenInfo(ownerChainB, bChainUSDC), + testhelpers.NewMintTokenInfo(ownerChainB, bChainUSDC), }, chainC: { - changeset.NewMintTokenInfo(ownerChainC, cChainUSDC, cChainToken), + testhelpers.NewMintTokenInfo(ownerChainC, cChainUSDC, cChainToken), }, }, ) @@ -96,7 +97,7 @@ func TestUSDCTokenTransfer(t *testing.T) { // MockE2EUSDCTransmitter always mint 1, see MockE2EUSDCTransmitter.sol for more details tinyOneCoin := new(big.Int).SetUint64(1) - tcs := []changeset.TestTransferRequest{ + tcs := []testhelpers.TestTransferRequest{ { Name: "single USDC token transfer to EOA", Receiver: utils.RandomAddress(), @@ -110,7 +111,7 @@ func TestUSDCTokenTransfer(t *testing.T) { ExpectedTokenBalances: map[common.Address]*big.Int{ aChainUSDC.Address(): tinyOneCoin, }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "multiple USDC tokens within the same message", @@ -131,7 +132,7 @@ func TestUSDCTokenTransfer(t *testing.T) { // 2 coins because of the same Receiver aChainUSDC.Address(): new(big.Int).Add(tinyOneCoin, tinyOneCoin), }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "USDC token together with another token transferred to EOA", @@ -152,7 +153,7 @@ func TestUSDCTokenTransfer(t *testing.T) { cChainUSDC.Address(): tinyOneCoin, cChainToken.Address(): new(big.Int).Mul(tinyOneCoin, big.NewInt(10)), }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "USDC programmable token transfer to valid contract receiver", @@ -169,7 +170,7 @@ func TestUSDCTokenTransfer(t *testing.T) { ExpectedTokenBalances: map[common.Address]*big.Int{ cChainUSDC.Address(): tinyOneCoin, }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, { Name: "USDC programmable token transfer with too little gas", @@ -186,8 +187,8 @@ func TestUSDCTokenTransfer(t *testing.T) { ExpectedTokenBalances: map[common.Address]*big.Int{ bChainUSDC.Address(): new(big.Int).SetUint64(0), }, - ExtraArgs: changeset.MakeEVMExtraArgsV2(1, false), - ExpectedStatus: changeset.EXECUTION_STATE_FAILURE, + ExtraArgs: testhelpers.MakeEVMExtraArgsV2(1, false), + ExpectedStatus: testhelpers.EXECUTION_STATE_FAILURE, }, { Name: "USDC token transfer from a different source chain", @@ -204,14 +205,14 @@ func TestUSDCTokenTransfer(t *testing.T) { ExpectedTokenBalances: map[common.Address]*big.Int{ cChainUSDC.Address(): tinyOneCoin, }, - ExpectedStatus: changeset.EXECUTION_STATE_SUCCESS, + ExpectedStatus: testhelpers.EXECUTION_STATE_SUCCESS, }, } startBlocks, expectedSeqNums, expectedExecutionStates, expectedTokenBalances := - changeset.TransferMultiple(ctx, t, e, state, tcs) + testhelpers.TransferMultiple(ctx, t, e, state, tcs) - err = changeset.ConfirmMultipleCommits( + err = testhelpers.ConfirmMultipleCommits( t, e.Chains, state.Chains, @@ -221,16 +222,16 @@ func TestUSDCTokenTransfer(t *testing.T) { ) require.NoError(t, err) - execStates := changeset.ConfirmExecWithSeqNrsForAll( + execStates := testhelpers.ConfirmExecWithSeqNrsForAll( t, e, state, - changeset.SeqNumberRangeToSlice(expectedSeqNums), + testhelpers.SeqNumberRangeToSlice(expectedSeqNums), startBlocks, ) require.Equal(t, expectedExecutionStates, execStates) - changeset.WaitForTokenBalances(ctx, t, e.Chains, expectedTokenBalances) + testhelpers.WaitForTokenBalances(ctx, t, e.Chains, expectedTokenBalances) } func updateFeeQuoters( @@ -242,17 +243,17 @@ func updateFeeQuoters( ) error { updateFeeQtrGrp := errgroup.Group{} updateFeeQtrGrp.Go(func() error { - return changeset.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainA], state.Chains[chainA], chainC, aChainUSDC) + return testhelpers.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainA], state.Chains[chainA], chainC, aChainUSDC) }) updateFeeQtrGrp.Go(func() error { - return changeset.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainB], state.Chains[chainB], chainC, bChainUSDC) + return testhelpers.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainB], state.Chains[chainB], chainC, bChainUSDC) }) updateFeeQtrGrp.Go(func() error { - err1 := changeset.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainC], state.Chains[chainC], chainA, cChainUSDC) + err1 := testhelpers.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainC], state.Chains[chainC], chainA, cChainUSDC) if err1 != nil { return err1 } - return changeset.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainC], state.Chains[chainC], chainB, cChainUSDC) + return testhelpers.UpdateFeeQuoterForUSDC(lggr, e.Chains[chainC], state.Chains[chainC], chainB, cChainUSDC) }) return updateFeeQtrGrp.Wait() } diff --git a/integration-tests/testsetups/ccip/test_helpers.go b/integration-tests/testsetups/ccip/test_helpers.go index 889c6b1cdf5..59a9bdb47ed 100644 --- a/integration-tests/testsetups/ccip/test_helpers.go +++ b/integration-tests/testsetups/ccip/test_helpers.go @@ -27,6 +27,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" + "github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers" integrationnodes "github.com/smartcontractkit/chainlink/integration-tests/types/config/node" evmcfg "github.com/smartcontractkit/chainlink/v2/core/chains/evm/config/toml" corechainlink "github.com/smartcontractkit/chainlink/v2/core/services/chainlink" @@ -52,23 +53,23 @@ import ( // DeployedLocalDevEnvironment is a helper struct for setting up a local dev environment with docker type DeployedLocalDevEnvironment struct { - changeset.DeployedEnv + testhelpers.DeployedEnv testEnv *test_env.CLClusterTestEnv DON *devenv.DON - GenericTCConfig *changeset.TestConfigs + GenericTCConfig *testhelpers.TestConfigs devEnvTestCfg tc.TestConfig devEnvCfg *devenv.EnvironmentConfig } -func (l *DeployedLocalDevEnvironment) DeployedEnvironment() changeset.DeployedEnv { +func (l *DeployedLocalDevEnvironment) DeployedEnvironment() testhelpers.DeployedEnv { return l.DeployedEnv } -func (l *DeployedLocalDevEnvironment) UpdateDeployedEnvironment(env changeset.DeployedEnv) { +func (l *DeployedLocalDevEnvironment) UpdateDeployedEnvironment(env testhelpers.DeployedEnv) { l.DeployedEnv = env } -func (l *DeployedLocalDevEnvironment) TestConfigs() *changeset.TestConfigs { +func (l *DeployedLocalDevEnvironment) TestConfigs() *testhelpers.TestConfigs { return l.GenericTCConfig } @@ -91,7 +92,7 @@ func (l *DeployedLocalDevEnvironment) StartChains(t *testing.T) { require.NotEmpty(t, feedSel, "feedSel should not be empty") chains, err := devenv.NewChains(lggr, envConfig.Chains) require.NoError(t, err) - replayBlocks, err := changeset.LatestBlocksByChain(ctx, chains) + replayBlocks, err := testhelpers.LatestBlocksByChain(ctx, chains) require.NoError(t, err) l.DeployedEnv.Users = users l.DeployedEnv.Env.Chains = chains @@ -152,8 +153,8 @@ func (l *DeployedLocalDevEnvironment) RestartChainlinkNodes(t *testing.T) error // if CCIP_V16_TEST_ENV is set to 'docker', it creates a docker environment with test config provided under testconfig/ccip/ccip.toml // It also creates a RMN cluster if the test config has RMN enabled // It returns the deployed environment and RMN cluster ( in case of RMN enabled) -func NewIntegrationEnvironment(t *testing.T, opts ...changeset.TestOps) (changeset.DeployedEnv, devenv.RMNCluster, changeset.TestEnvironment) { - testCfg := changeset.DefaultTestConfigs() +func NewIntegrationEnvironment(t *testing.T, opts ...testhelpers.TestOps) (testhelpers.DeployedEnv, devenv.RMNCluster, testhelpers.TestEnvironment) { + testCfg := testhelpers.DefaultTestConfigs() for _, opt := range opts { opt(testCfg) } @@ -161,21 +162,21 @@ func NewIntegrationEnvironment(t *testing.T, opts ...changeset.TestOps) (changes testCfg.MustSetEnvTypeOrDefault(t) require.NoError(t, testCfg.Validate(), "invalid test config") switch testCfg.Type { - case changeset.Memory: - dEnv, memEnv := changeset.NewMemoryEnvironment(t, opts...) + case testhelpers.Memory: + dEnv, memEnv := testhelpers.NewMemoryEnvironment(t, opts...) return dEnv, devenv.RMNCluster{}, memEnv - case changeset.Docker: + case testhelpers.Docker: dockerEnv := &DeployedLocalDevEnvironment{ GenericTCConfig: testCfg, } if testCfg.PrerequisiteDeploymentOnly { - deployedEnv := changeset.NewEnvironmentWithPrerequisitesContracts(t, dockerEnv) + deployedEnv := testhelpers.NewEnvironmentWithPrerequisitesContracts(t, dockerEnv) require.NotNil(t, dockerEnv.testEnv, "empty docker environment") dockerEnv.UpdateDeployedEnvironment(deployedEnv) return deployedEnv, devenv.RMNCluster{}, dockerEnv } if testCfg.RMNEnabled { - deployedEnv := changeset.NewEnvironmentWithJobsAndContracts(t, dockerEnv) + deployedEnv := testhelpers.NewEnvironmentWithJobsAndContracts(t, dockerEnv) l := logging.GetTestLogger(t) require.NotNil(t, dockerEnv.testEnv, "empty docker environment") config := GenerateTestRMNConfig(t, testCfg.NumOfRMNNodes, deployedEnv, MustNetworksToRPCMap(dockerEnv.testEnv.EVMNetworks)) @@ -194,25 +195,25 @@ func NewIntegrationEnvironment(t *testing.T, opts ...changeset.TestOps) (changes return deployedEnv, *rmnCluster, dockerEnv } if testCfg.CreateJobAndContracts { - deployedEnv := changeset.NewEnvironmentWithJobsAndContracts(t, dockerEnv) + deployedEnv := testhelpers.NewEnvironmentWithJobsAndContracts(t, dockerEnv) require.NotNil(t, dockerEnv.testEnv, "empty docker environment") dockerEnv.UpdateDeployedEnvironment(deployedEnv) return deployedEnv, devenv.RMNCluster{}, dockerEnv } if testCfg.CreateJob { - deployedEnv := changeset.NewEnvironmentWithJobs(t, dockerEnv) + deployedEnv := testhelpers.NewEnvironmentWithJobs(t, dockerEnv) require.NotNil(t, dockerEnv.testEnv, "empty docker environment") dockerEnv.UpdateDeployedEnvironment(deployedEnv) return deployedEnv, devenv.RMNCluster{}, dockerEnv } - deployedEnv := changeset.NewEnvironment(t, dockerEnv) + deployedEnv := testhelpers.NewEnvironment(t, dockerEnv) require.NotNil(t, dockerEnv.testEnv, "empty docker environment") dockerEnv.UpdateDeployedEnvironment(deployedEnv) return deployedEnv, devenv.RMNCluster{}, dockerEnv default: - require.Failf(t, "Type %s not supported in integration tests choose between %s and %s", string(testCfg.Type), changeset.Memory, changeset.Docker) + require.Failf(t, "Type %s not supported in integration tests choose between %s and %s", string(testCfg.Type), testhelpers.Memory, testhelpers.Docker) } - return changeset.DeployedEnv{}, devenv.RMNCluster{}, nil + return testhelpers.DeployedEnv{}, devenv.RMNCluster{}, nil } func MustNetworksToRPCMap(evmNetworks []*blockchain.EVMNetwork) map[uint64]string { @@ -243,7 +244,7 @@ func MustCCIPNameToRMNName(a string) string { return v } -func GenerateTestRMNConfig(t *testing.T, nRMNNodes int, tenv changeset.DeployedEnv, rpcMap map[uint64]string) map[string]devenv.RMNConfig { +func GenerateTestRMNConfig(t *testing.T, nRMNNodes int, tenv testhelpers.DeployedEnv, rpcMap map[uint64]string) map[string]devenv.RMNConfig { // Find the bootstrappers. nodes, err := deployment.NodeInfo(tenv.Env.NodeIDs, tenv.Env.Offchain) require.NoError(t, err)