From b2de0542a6dd1e50ffc3b15b7c16fef4dd059a8f Mon Sep 17 00:00:00 2001 From: Connor Stein Date: Tue, 19 Nov 2024 20:31:16 -0500 Subject: [PATCH 1/6] Extract MCMS to deployment/common (#15288) * Extract MCMS * Use changeset * Standardize package import names * Fix mcms test imports * Fix add lane * Fix bad merge * Extract common integration helper code * Fix go mod * Similar common helper for memeroy * Comments * Fix tests * Fix new test * Fix RMN test --- deployment/ccip/add_lane_test.go | 25 +-- .../ccip/changeset/active_candidate_test.go | 115 +++++--------- deployment/ccip/changeset/add_chain_test.go | 34 +++- deployment/ccip/changeset/deploy_chain.go | 3 +- .../ccip/changeset/deploy_chain_test.go | 18 ++- .../ccip/changeset/initial_deploy_test.go | 19 ++- deployment/ccip/deploy.go | 139 ++--------------- deployment/ccip/deploy_test.go | 54 +------ deployment/ccip/propose.go | 121 +-------------- deployment/ccip/state.go | 58 +++---- deployment/ccip/test_helpers.go | 87 ++++++++++- deployment/ccip/view/types/contract_state.go | 33 ---- deployment/ccip/view/view.go | 2 + .../changeset/deploy_mcms_with_timelock.go | 20 +++ deployment/common/changeset/internal/mcms.go | 137 ++++++++++++++++ .../common/changeset/internal/mcms_test.go | 58 +++++++ .../common/changeset/mcms_test_helpers.go | 115 ++++++++++++++ deployment/common/changeset/state.go | 99 ++++++++++++ deployment/common/types/types.go | 25 +++ deployment/common/view/v1_0/mcms.go | 146 ++++++++++++++++++ deployment/environment.go | 8 + .../ccip-tests/testsetups/test_helpers.go | 92 ++++++++--- integration-tests/go.mod | 2 +- .../smoke/ccip_messaging_test.go | 41 ----- integration-tests/smoke/ccip_rmn_test.go | 18 --- integration-tests/smoke/ccip_test.go | 85 +--------- integration-tests/smoke/ccip_usdc_test.go | 97 +----------- integration-tests/smoke/fee_boosting_test.go | 42 ----- 28 files changed, 913 insertions(+), 780 deletions(-) delete mode 100644 deployment/ccip/view/types/contract_state.go create mode 100644 deployment/common/changeset/deploy_mcms_with_timelock.go create mode 100644 deployment/common/changeset/internal/mcms.go create mode 100644 deployment/common/changeset/internal/mcms_test.go create mode 100644 deployment/common/changeset/mcms_test_helpers.go create mode 100644 deployment/common/changeset/state.go create mode 100644 deployment/common/types/types.go create mode 100644 deployment/common/view/v1_0/mcms.go diff --git a/deployment/ccip/add_lane_test.go b/deployment/ccip/add_lane_test.go index 5edfdae1ab0..5c87a089a1b 100644 --- a/deployment/ccip/add_lane_test.go +++ b/deployment/ccip/add_lane_test.go @@ -21,38 +21,15 @@ import ( func TestAddLane(t *testing.T) { t.Parallel() // We add more chains to the chainlink nodes than the number of chains where CCIP is deployed. - e := NewMemoryEnvironmentWithJobs(t, logger.TestLogger(t), 4, 4) + e := NewMemoryEnvironmentWithJobsAndContracts(t, logger.TestLogger(t), 2, 4) // Here we have CR + nodes set up, but no CCIP contracts deployed. state, err := LoadOnchainState(e.Env) require.NoError(t, err) selectors := e.Env.AllChainSelectors() - // deploy CCIP contracts on two chains chain1, chain2 := selectors[0], selectors[1] - feeds := state.Chains[e.FeedChainSel].USDFeeds - tokenConfig := NewTestTokenConfig(feeds) - newAddresses := deployment.NewMemoryAddressBook() - err = DeployPrerequisiteChainContracts(e.Env, newAddresses, e.Env.AllChainSelectors()) - require.NoError(t, err) - require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) - - // Set up CCIP contracts and a DON per chain. - newAddresses = deployment.NewMemoryAddressBook() - err = DeployCCIPContracts(e.Env, newAddresses, DeployCCIPContractConfig{ - HomeChainSel: e.HomeChainSel, - FeedChainSel: e.FeedChainSel, - TokenConfig: tokenConfig, - MCMSConfig: NewTestMCMSConfig(t, e.Env), - ChainsToDeploy: []uint64{chain1, chain2}, - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) - // We expect no lanes available on any chain. - state, err = LoadOnchainState(e.Env) - require.NoError(t, err) for _, sel := range []uint64{chain1, chain2} { chain := state.Chains[sel] offRamps, err := chain.Router.GetOffRamps(nil) diff --git a/deployment/ccip/changeset/active_candidate_test.go b/deployment/ccip/changeset/active_candidate_test.go index cd1d7604817..50115389a28 100644 --- a/deployment/ccip/changeset/active_candidate_test.go +++ b/deployment/ccip/changeset/active_candidate_test.go @@ -16,9 +16,8 @@ import ( "github.com/stretchr/testify/require" - jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" - ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" "github.com/smartcontractkit/chainlink/v2/core/logger" ) @@ -27,47 +26,10 @@ func TestActiveCandidate(t *testing.T) { t.Skipf("to be enabled after latest cl-ccip is compatible") lggr := logger.TestLogger(t) - ctx := ccdeploy.Context(t) - tenv := ccdeploy.NewMemoryEnvironment(t, lggr, 3, 5, ccdeploy.MockLinkPrice, ccdeploy.MockWethPrice) + tenv := ccdeploy.NewMemoryEnvironmentWithJobsAndContracts(t, lggr, 3, 5) e := tenv.Env - state, err := ccdeploy.LoadOnchainState(tenv.Env) require.NoError(t, err) - require.NotNil(t, state.Chains[tenv.HomeChainSel].LinkToken) - - feeds := state.Chains[tenv.FeedChainSel].USDFeeds - tokenConfig := ccdeploy.NewTestTokenConfig(feeds) - - output, err := InitialDeploy(tenv.Env, ccdeploy.DeployCCIPContractConfig{ - HomeChainSel: tenv.HomeChainSel, - FeedChainSel: tenv.FeedChainSel, - ChainsToDeploy: tenv.Env.AllChainSelectors(), - TokenConfig: tokenConfig, - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - // Get new state after migration. - require.NoError(t, tenv.Env.ExistingAddresses.Merge(output.AddressBook)) - state, err = ccdeploy.LoadOnchainState(tenv.Env) - require.NoError(t, err) - homeCS, destCS := tenv.HomeChainSel, tenv.FeedChainSel - - // Ensure capreg logs are up to date. - ccdeploy.ReplayLogs(t, e.Offchain, tenv.ReplayBlocks) - - // Apply the jobs. - for nodeID, jobs := range output.JobSpecs { - for _, job := range jobs { - // Note these auto-accept - _, err := e.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } // Add all lanes require.NoError(t, ccdeploy.AddLanesForAll(e, state)) @@ -111,23 +73,23 @@ func TestActiveCandidate(t *testing.T) { ccdeploy.ConfirmExecWithSeqNrForAll(t, e, state, expectedSeqNum, startBlocks) // transfer ownership - ccdeploy.TransferAllOwnership(t, state, homeCS, e) - acceptOwnershipProposal, err := ccdeploy.GenerateAcceptOwnershipProposal(state, homeCS, e.AllChainSelectors()) + ccdeploy.TransferAllOwnership(t, state, tenv.HomeChainSel, e) + acceptOwnershipProposal, err := ccdeploy.GenerateAcceptOwnershipProposal(state, tenv.HomeChainSel, e.AllChainSelectors()) require.NoError(t, err) - acceptOwnershipExec := ccdeploy.SignProposal(t, e, acceptOwnershipProposal) + acceptOwnershipExec := commonchangeset.SignProposal(t, e, acceptOwnershipProposal) for _, sel := range e.AllChainSelectors() { - ccdeploy.ExecuteProposal(t, e, acceptOwnershipExec, state, sel) + commonchangeset.ExecuteProposal(t, e, acceptOwnershipExec, state.Chains[sel].Timelock, sel) } // Apply the accept ownership proposal to all the chains. - err = ccdeploy.ConfirmRequestOnSourceAndDest(t, e, state, homeCS, destCS, 2) + err = ccdeploy.ConfirmRequestOnSourceAndDest(t, e, state, tenv.HomeChainSel, tenv.FeedChainSel, 2) require.NoError(t, err) // [ACTIVE, CANDIDATE] setup by setting candidate through cap reg - capReg, ccipHome := state.Chains[homeCS].CapabilityRegistry, state.Chains[homeCS].CCIPHome - donID, err := ccdeploy.DonIDForChain(capReg, ccipHome, destCS) + capReg, ccipHome := state.Chains[tenv.HomeChainSel].CapabilityRegistry, state.Chains[tenv.HomeChainSel].CCIPHome + donID, err := ccdeploy.DonIDForChain(capReg, ccipHome, tenv.FeedChainSel) require.NoError(t, err) - donInfo, err := state.Chains[homeCS].CapabilityRegistry.GetDON(nil, donID) + donInfo, err := state.Chains[tenv.HomeChainSel].CapabilityRegistry.GetDON(nil, donID) require.NoError(t, err) require.Equal(t, 5, len(donInfo.NodeP2PIds)) require.Equal(t, uint32(4), donInfo.ConfigCount) @@ -151,13 +113,14 @@ func TestActiveCandidate(t *testing.T) { // this will construct ocr3 configurations for the // commit and exec plugin we will be using - rmnHomeAddress := state.Chains[homeCS].RMNHome.Address() + rmnHomeAddress := state.Chains[tenv.HomeChainSel].RMNHome.Address() + tokenConfig := ccdeploy.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds) ocr3ConfigMap, err := ccdeploy.BuildOCR3ConfigForCCIPHome( deployment.XXXGenerateTestOCRSecrets(), - state.Chains[destCS].OffRamp, - e.Chains[destCS], - destCS, - tokenConfig.GetTokenInfo(e.Logger, state.Chains[destCS].LinkToken, state.Chains[destCS].Weth9), + state.Chains[tenv.FeedChainSel].OffRamp, + e.Chains[tenv.FeedChainSel], + tenv.FeedChainSel, + tokenConfig.GetTokenInfo(e.Logger, state.Chains[tenv.FeedChainSel].LinkToken, state.Chains[tenv.FeedChainSel].Weth9), nodes.NonBootstraps(), rmnHomeAddress, nil, @@ -166,82 +129,82 @@ func TestActiveCandidate(t *testing.T) { setCommitCandidateOp, err := ccdeploy.SetCandidateOnExistingDon( ocr3ConfigMap[cctypes.PluginTypeCCIPCommit], - state.Chains[homeCS].CapabilityRegistry, - state.Chains[homeCS].CCIPHome, - destCS, + state.Chains[tenv.HomeChainSel].CapabilityRegistry, + state.Chains[tenv.HomeChainSel].CCIPHome, + tenv.FeedChainSel, nodes.NonBootstraps(), ) require.NoError(t, err) setCommitCandidateProposal, err := ccdeploy.BuildProposalFromBatches(state, []timelock.BatchChainOperation{{ - ChainIdentifier: mcms.ChainIdentifier(homeCS), + ChainIdentifier: mcms.ChainIdentifier(tenv.HomeChainSel), Batch: setCommitCandidateOp, }}, "set new candidates on commit plugin", 0) require.NoError(t, err) - setCommitCandidateSigned := ccdeploy.SignProposal(t, e, setCommitCandidateProposal) - ccdeploy.ExecuteProposal(t, e, setCommitCandidateSigned, state, homeCS) + setCommitCandidateSigned := commonchangeset.SignProposal(t, e, setCommitCandidateProposal) + commonchangeset.ExecuteProposal(t, e, setCommitCandidateSigned, state.Chains[tenv.HomeChainSel].Timelock, tenv.HomeChainSel) // create the op for the commit plugin as well setExecCandidateOp, err := ccdeploy.SetCandidateOnExistingDon( ocr3ConfigMap[cctypes.PluginTypeCCIPExec], - state.Chains[homeCS].CapabilityRegistry, - state.Chains[homeCS].CCIPHome, - destCS, + state.Chains[tenv.HomeChainSel].CapabilityRegistry, + state.Chains[tenv.HomeChainSel].CCIPHome, + tenv.FeedChainSel, nodes.NonBootstraps(), ) require.NoError(t, err) setExecCandidateProposal, err := ccdeploy.BuildProposalFromBatches(state, []timelock.BatchChainOperation{{ - ChainIdentifier: mcms.ChainIdentifier(homeCS), + ChainIdentifier: mcms.ChainIdentifier(tenv.HomeChainSel), Batch: setExecCandidateOp, }}, "set new candidates on commit and exec plugins", 0) require.NoError(t, err) - setExecCandidateSigned := ccdeploy.SignProposal(t, e, setExecCandidateProposal) - ccdeploy.ExecuteProposal(t, e, setExecCandidateSigned, state, homeCS) + setExecCandidateSigned := commonchangeset.SignProposal(t, e, setExecCandidateProposal) + commonchangeset.ExecuteProposal(t, e, setExecCandidateSigned, state.Chains[tenv.HomeChainSel].Timelock, tenv.HomeChainSel) // check setup was successful by confirming number of nodes from cap reg - donInfo, err = state.Chains[homeCS].CapabilityRegistry.GetDON(nil, donID) + donInfo, err = state.Chains[tenv.HomeChainSel].CapabilityRegistry.GetDON(nil, donID) require.NoError(t, err) require.Equal(t, 4, len(donInfo.NodeP2PIds)) require.Equal(t, uint32(6), donInfo.ConfigCount) // [ACTIVE, CANDIDATE] done setup // [ACTIVE, CANDIDATE] make sure we can still send successful transaction without updating job specs - err = ccdeploy.ConfirmRequestOnSourceAndDest(t, e, state, homeCS, destCS, 3) + err = ccdeploy.ConfirmRequestOnSourceAndDest(t, e, state, tenv.HomeChainSel, tenv.FeedChainSel, 3) require.NoError(t, err) // [ACTIVE, CANDIDATE] done send successful transaction on active // [NEW ACTIVE, NO CANDIDATE] promote to active // confirm by getting old candidate digest and making sure new active matches - oldCandidateDigest, err := state.Chains[homeCS].CCIPHome.GetCandidateDigest(nil, donID, uint8(cctypes.PluginTypeCCIPExec)) + oldCandidateDigest, err := state.Chains[tenv.HomeChainSel].CCIPHome.GetCandidateDigest(nil, donID, uint8(cctypes.PluginTypeCCIPExec)) require.NoError(t, err) - promoteOps, err := ccdeploy.PromoteAllCandidatesForChainOps(state.Chains[homeCS].CapabilityRegistry, state.Chains[homeCS].CCIPHome, destCS, nodes.NonBootstraps()) + promoteOps, err := ccdeploy.PromoteAllCandidatesForChainOps(state.Chains[tenv.HomeChainSel].CapabilityRegistry, state.Chains[tenv.HomeChainSel].CCIPHome, tenv.FeedChainSel, nodes.NonBootstraps()) require.NoError(t, err) promoteProposal, err := ccdeploy.BuildProposalFromBatches(state, []timelock.BatchChainOperation{{ - ChainIdentifier: mcms.ChainIdentifier(homeCS), + ChainIdentifier: mcms.ChainIdentifier(tenv.HomeChainSel), Batch: promoteOps, }}, "promote candidates and revoke actives", 0) require.NoError(t, err) - promoteSigned := ccdeploy.SignProposal(t, e, promoteProposal) - ccdeploy.ExecuteProposal(t, e, promoteSigned, state, homeCS) + promoteSigned := commonchangeset.SignProposal(t, e, promoteProposal) + commonchangeset.ExecuteProposal(t, e, promoteSigned, state.Chains[tenv.HomeChainSel].Timelock, tenv.HomeChainSel) // [NEW ACTIVE, NO CANDIDATE] done promoting // [NEW ACTIVE, NO CANDIDATE] check onchain state - newActiveDigest, err := state.Chains[homeCS].CCIPHome.GetActiveDigest(nil, donID, uint8(cctypes.PluginTypeCCIPExec)) + newActiveDigest, err := state.Chains[tenv.HomeChainSel].CCIPHome.GetActiveDigest(nil, donID, uint8(cctypes.PluginTypeCCIPExec)) require.NoError(t, err) require.Equal(t, oldCandidateDigest, newActiveDigest) - newCandidateDigest, err := state.Chains[homeCS].CCIPHome.GetCandidateDigest(nil, donID, uint8(cctypes.PluginTypeCCIPCommit)) + newCandidateDigest, err := state.Chains[tenv.HomeChainSel].CCIPHome.GetCandidateDigest(nil, donID, uint8(cctypes.PluginTypeCCIPCommit)) require.NoError(t, err) require.Equal(t, newCandidateDigest, [32]byte{}) // [NEW ACTIVE, NO CANDIDATE] done checking on chain state // [NEW ACTIVE, NO CANDIDATE] send successful request on new active - donInfo, err = state.Chains[homeCS].CapabilityRegistry.GetDON(nil, donID) + donInfo, err = state.Chains[tenv.HomeChainSel].CapabilityRegistry.GetDON(nil, donID) require.NoError(t, err) require.Equal(t, uint32(8), donInfo.ConfigCount) - err = ccdeploy.ConfirmRequestOnSourceAndDest(t, e, state, homeCS, destCS, 4) + err = ccdeploy.ConfirmRequestOnSourceAndDest(t, e, state, tenv.HomeChainSel, tenv.FeedChainSel, 4) require.NoError(t, err) // [NEW ACTIVE, NO CANDIDATE] done sending successful request } diff --git a/deployment/ccip/changeset/add_chain_test.go b/deployment/ccip/changeset/add_chain_test.go index 2d79a76005d..76104871784 100644 --- a/deployment/ccip/changeset/add_chain_test.go +++ b/deployment/ccip/changeset/add_chain_test.go @@ -1,11 +1,13 @@ package changeset import ( + "math/big" "testing" "time" ccipdeployment "github.com/smartcontractkit/chainlink/deployment/ccip" - + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" + commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" "github.com/smartcontractkit/chainlink/v2/core/capabilities/ccip/types" "github.com/ethereum/go-ethereum/common" @@ -41,14 +43,27 @@ func TestAddChainInbound(t *testing.T) { require.NoError(t, err) require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) - tokenConfig := ccipdeployment.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) + cfg := commontypes.MCMSWithTimelockConfig{ + Canceller: commonchangeset.SingleGroupMCMS(t), + Bypasser: commonchangeset.SingleGroupMCMS(t), + Proposer: commonchangeset.SingleGroupMCMS(t), + TimelockExecutors: e.Env.AllDeployerKeys(), + TimelockMinDelay: big.NewInt(0), + } + out, err := commonchangeset.DeployMCMSWithTimelock(e.Env, map[uint64]commontypes.MCMSWithTimelockConfig{ + initialDeploy[0]: cfg, + initialDeploy[1]: cfg, + initialDeploy[2]: cfg, + }) + require.NoError(t, err) + require.NoError(t, e.Env.ExistingAddresses.Merge(out.AddressBook)) newAddresses = deployment.NewMemoryAddressBook() + tokenConfig := ccipdeployment.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) err = ccipdeployment.DeployCCIPContracts(e.Env, newAddresses, ccipdeployment.DeployCCIPContractConfig{ HomeChainSel: e.HomeChainSel, FeedChainSel: e.FeedChainSel, ChainsToDeploy: initialDeploy, TokenConfig: tokenConfig, - MCMSConfig: ccipdeployment.NewTestMCMSConfig(t, e.Env), OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), }) require.NoError(t, err) @@ -72,14 +87,19 @@ func TestAddChainInbound(t *testing.T) { require.NoError(t, err) // Deploy contracts to new chain + out, err = commonchangeset.DeployMCMSWithTimelock(e.Env, map[uint64]commontypes.MCMSWithTimelockConfig{ + newChain: cfg, + }) + require.NoError(t, err) + require.NoError(t, e.Env.ExistingAddresses.Merge(out.AddressBook)) + newAddresses = deployment.NewMemoryAddressBook() err = ccipdeployment.DeployPrerequisiteChainContracts(e.Env, newAddresses, []uint64{newChain}) require.NoError(t, err) require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) newAddresses = deployment.NewMemoryAddressBook() err = ccipdeployment.DeployChainContracts(e.Env, - e.Env.Chains[newChain], newAddresses, - ccipdeployment.NewTestMCMSConfig(t, e.Env), rmnHome) + e.Env.Chains[newChain], newAddresses, rmnHome) require.NoError(t, err) require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) state, err = ccipdeployment.LoadOnchainState(e.Env) @@ -117,10 +137,10 @@ func TestAddChainInbound(t *testing.T) { acceptOwnershipProposal, err := ccipdeployment.GenerateAcceptOwnershipProposal(state, e.HomeChainSel, initialDeploy) require.NoError(t, err) - acceptOwnershipExec := ccipdeployment.SignProposal(t, e.Env, acceptOwnershipProposal) + acceptOwnershipExec := commonchangeset.SignProposal(t, e.Env, acceptOwnershipProposal) // Apply the accept ownership proposal to all the chains. for _, sel := range initialDeploy { - ccipdeployment.ExecuteProposal(t, e.Env, acceptOwnershipExec, state, sel) + commonchangeset.ExecuteProposal(t, e.Env, acceptOwnershipExec, state.Chains[sel].Timelock, sel) } for _, chain := range initialDeploy { owner, err2 := state.Chains[chain].OnRamp.Owner(nil) diff --git a/deployment/ccip/changeset/deploy_chain.go b/deployment/ccip/changeset/deploy_chain.go index 68f350a9af7..633d01bbf4c 100644 --- a/deployment/ccip/changeset/deploy_chain.go +++ b/deployment/ccip/changeset/deploy_chain.go @@ -13,7 +13,7 @@ var _ deployment.ChangeSet[DeployChainContractsConfig] = DeployChainContracts func DeployChainContracts(env deployment.Environment, c DeployChainContractsConfig) (deployment.ChangesetOutput, error) { newAddresses := deployment.NewMemoryAddressBook() - err := ccipdeployment.DeployChainContractsForChains(env, newAddresses, c.HomeChainSelector, c.ChainSelectors, c.MCMSCfg) + err := ccipdeployment.DeployChainContractsForChains(env, newAddresses, c.HomeChainSelector, c.ChainSelectors) if err != nil { env.Logger.Errorw("Failed to deploy CCIP contracts", "err", err, "newAddresses", newAddresses) return deployment.ChangesetOutput{AddressBook: newAddresses}, deployment.MaybeDataErr(err) @@ -28,7 +28,6 @@ func DeployChainContracts(env deployment.Environment, c DeployChainContractsConf type DeployChainContractsConfig struct { ChainSelectors []uint64 HomeChainSelector uint64 - MCMSCfg ccipdeployment.MCMSConfig } func (c DeployChainContractsConfig) Validate() error { diff --git a/deployment/ccip/changeset/deploy_chain_test.go b/deployment/ccip/changeset/deploy_chain_test.go index b197c90eca5..0e5b7a8d270 100644 --- a/deployment/ccip/changeset/deploy_chain_test.go +++ b/deployment/ccip/changeset/deploy_chain_test.go @@ -1,6 +1,7 @@ package changeset import ( + "math/big" "testing" "github.com/stretchr/testify/require" @@ -8,6 +9,8 @@ import ( "github.com/smartcontractkit/chainlink/deployment" ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" + commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" "github.com/smartcontractkit/chainlink/deployment/environment/memory" "github.com/smartcontractkit/chainlink/v2/core/logger" ) @@ -45,11 +48,24 @@ func TestDeployChainContractsChangeset(t *testing.T) { require.NoError(t, err) require.NoError(t, e.ExistingAddresses.Merge(prerequisites.AddressBook)) + cfg := make(map[uint64]commontypes.MCMSWithTimelockConfig) + for _, chain := range e.AllChainSelectors() { + cfg[chain] = commontypes.MCMSWithTimelockConfig{ + Canceller: commonchangeset.SingleGroupMCMS(t), + Bypasser: commonchangeset.SingleGroupMCMS(t), + Proposer: commonchangeset.SingleGroupMCMS(t), + TimelockExecutors: e.AllDeployerKeys(), + TimelockMinDelay: big.NewInt(0), + } + } + output, err = commonchangeset.DeployMCMSWithTimelock(e, cfg) + require.NoError(t, err) + require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) + // deploy ccip chain contracts output, err = DeployChainContracts(e, DeployChainContractsConfig{ ChainSelectors: selectors, HomeChainSelector: homeChainSel, - MCMSCfg: ccdeploy.NewTestMCMSConfig(t, e), }) require.NoError(t, err) require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) diff --git a/deployment/ccip/changeset/initial_deploy_test.go b/deployment/ccip/changeset/initial_deploy_test.go index a3756022245..a299dd4971f 100644 --- a/deployment/ccip/changeset/initial_deploy_test.go +++ b/deployment/ccip/changeset/initial_deploy_test.go @@ -1,12 +1,16 @@ package changeset import ( + "math/big" "testing" "github.com/ethereum/go-ethereum/common" jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" + commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" + "github.com/smartcontractkit/chainlink/deployment" ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" @@ -32,12 +36,25 @@ func TestInitialDeploy(t *testing.T) { require.NoError(t, err) require.NoError(t, tenv.Env.ExistingAddresses.Merge(output.AddressBook)) + cfg := make(map[uint64]commontypes.MCMSWithTimelockConfig) + for _, chain := range e.AllChainSelectors() { + cfg[chain] = commontypes.MCMSWithTimelockConfig{ + Canceller: commonchangeset.SingleGroupMCMS(t), + Bypasser: commonchangeset.SingleGroupMCMS(t), + Proposer: commonchangeset.SingleGroupMCMS(t), + TimelockExecutors: e.AllDeployerKeys(), + TimelockMinDelay: big.NewInt(0), + } + } + output, err = commonchangeset.DeployMCMSWithTimelock(e, cfg) + require.NoError(t, err) + require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) + output, err = InitialDeploy(tenv.Env, ccdeploy.DeployCCIPContractConfig{ HomeChainSel: tenv.HomeChainSel, FeedChainSel: tenv.FeedChainSel, ChainsToDeploy: tenv.Env.AllChainSelectors(), TokenConfig: ccdeploy.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds), - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e), OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), }) require.NoError(t, err) diff --git a/deployment/ccip/deploy.go b/deployment/ccip/deploy.go index d1f6866190d..0dea0a8b1f8 100644 --- a/deployment/ccip/deploy.go +++ b/deployment/ccip/deploy.go @@ -8,12 +8,10 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/pkg/errors" - "github.com/smartcontractkit/ccip-owner-contracts/pkg/config" - owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" + cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" "github.com/smartcontractkit/chainlink-ccip/pluginconfig" commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" - "github.com/smartcontractkit/chainlink-common/pkg/logger" "github.com/smartcontractkit/chainlink/deployment" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/ccip_home" @@ -285,10 +283,7 @@ type DeployCCIPContractConfig struct { FeedChainSel uint64 ChainsToDeploy []uint64 TokenConfig TokenConfig - // I believe it makes sense to have the same signers across all chains - // since that's the point MCMS. - MCMSConfig MCMSConfig - USDCConfig USDCConfig + USDCConfig USDCConfig // For setting OCR configuration OCRSecrets deployment.OCRSecrets } @@ -302,7 +297,10 @@ type DeployCCIPContractConfig struct { // It then deploys the rest of the CCIP chain contracts to the selected chains // registers the nodes with the capability registry and creates a DON for // each new chain. TODO: Might be better to break this down a bit? -func DeployCCIPContracts(e deployment.Environment, ab deployment.AddressBook, c DeployCCIPContractConfig) error { +func DeployCCIPContracts( + e deployment.Environment, + ab deployment.AddressBook, + c DeployCCIPContractConfig) error { if c.OCRSecrets.IsEmpty() { return fmt.Errorf("OCR secrets are empty") } @@ -357,7 +355,7 @@ func DeployCCIPContracts(e deployment.Environment, ab deployment.AddressBook, c } } } - err = DeployChainContractsForChains(e, ab, c.HomeChainSel, c.ChainsToDeploy, c.MCMSConfig) + err = DeployChainContractsForChains(e, ab, c.HomeChainSel, c.ChainsToDeploy) if err != nil { e.Logger.Errorw("Failed to deploy chain contracts", "err", err) return err @@ -423,114 +421,11 @@ func DeployCCIPContracts(e deployment.Environment, ab deployment.AddressBook, c return nil } -type MCMSConfig struct { - Admin config.Config - Canceller config.Config - Bypasser config.Config - Proposer config.Config - Executors []common.Address -} - -func DeployMCMSWithConfig( - contractType deployment.ContractType, - lggr logger.Logger, - chain deployment.Chain, - ab deployment.AddressBook, - mcmConfig config.Config, -) (*deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig], error) { - groupQuorums, groupParents, signerAddresses, signerGroups := mcmConfig.ExtractSetConfigInputs() - mcm, err := deployment.DeployContract(lggr, chain, ab, - func(chain deployment.Chain) deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] { - mcmAddr, tx, mcm, err2 := owner_helpers.DeployManyChainMultiSig( - chain.DeployerKey, - chain.Client, - ) - return deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig]{ - mcmAddr, mcm, tx, deployment.NewTypeAndVersion(contractType, deployment.Version1_0_0), err2, - } - }) - if err != nil { - lggr.Errorw("Failed to deploy mcm", "err", err) - return mcm, err - } - mcmsTx, err := mcm.Contract.SetConfig(chain.DeployerKey, - signerAddresses, - signerGroups, // Signer 1 is int group 0 (root group) with quorum 1. - groupQuorums, - groupParents, - false, - ) - if _, err := deployment.ConfirmIfNoError(chain, mcmsTx, err); err != nil { - lggr.Errorw("Failed to confirm mcm config", "err", err) - return mcm, err - } - return mcm, nil -} - -type MCMSContracts struct { - Admin *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] - Canceller *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] - Bypasser *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] - Proposer *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] - Timelock *deployment.ContractDeploy[*owner_helpers.RBACTimelock] -} - -// DeployMCMSContracts deploys the MCMS contracts for the given configuration -// as well as the timelock. -func DeployMCMSContracts( - lggr logger.Logger, - chain deployment.Chain, +func DeployChainContractsForChains( + e deployment.Environment, ab deployment.AddressBook, - mcmConfig MCMSConfig, -) (*MCMSContracts, error) { - adminMCM, err := DeployMCMSWithConfig(AdminManyChainMultisig, lggr, chain, ab, mcmConfig.Admin) - if err != nil { - return nil, err - } - bypasser, err := DeployMCMSWithConfig(BypasserManyChainMultisig, lggr, chain, ab, mcmConfig.Bypasser) - if err != nil { - return nil, err - } - canceller, err := DeployMCMSWithConfig(CancellerManyChainMultisig, lggr, chain, ab, mcmConfig.Canceller) - if err != nil { - return nil, err - } - proposer, err := DeployMCMSWithConfig(ProposerManyChainMultisig, lggr, chain, ab, mcmConfig.Proposer) - if err != nil { - return nil, err - } - - timelock, err := deployment.DeployContract(lggr, chain, ab, - func(chain deployment.Chain) deployment.ContractDeploy[*owner_helpers.RBACTimelock] { - timelock, tx2, cc, err2 := owner_helpers.DeployRBACTimelock( - chain.DeployerKey, - chain.Client, - big.NewInt(0), // minDelay - adminMCM.Address, - []common.Address{proposer.Address}, // proposers - mcmConfig.Executors, //executors - []common.Address{canceller.Address}, // cancellers - []common.Address{bypasser.Address}, // bypassers - ) - return deployment.ContractDeploy[*owner_helpers.RBACTimelock]{ - timelock, cc, tx2, deployment.NewTypeAndVersion(RBACTimelock, deployment.Version1_0_0), err2, - } - }) - if err != nil { - lggr.Errorw("Failed to deploy timelock", "err", err) - return nil, err - } - lggr.Infow("deployed timelock", "addr", timelock.Address) - return &MCMSContracts{ - Admin: adminMCM, - Canceller: canceller, - Bypasser: bypasser, - Proposer: proposer, - Timelock: timelock, - }, nil -} - -func DeployChainContractsForChains(e deployment.Environment, ab deployment.AddressBook, homeChainSel uint64, chainsToDeploy []uint64, mcmsConfig MCMSConfig) error { + homeChainSel uint64, + chainsToDeploy []uint64) error { existingState, err := LoadOnchainState(e) if err != nil { e.Logger.Errorw("Failed to load existing onchain state", "err") @@ -577,7 +472,7 @@ func DeployChainContractsForChains(e deployment.Environment, ab deployment.Addre if existingState.Chains[chainSel].LinkToken == nil || existingState.Chains[chainSel].Weth9 == nil { return fmt.Errorf("fee tokens not found for chain %d", chainSel) } - err := DeployChainContracts(e, chain, ab, mcmsConfig, rmnHome) + err := DeployChainContracts(e, chain, ab, rmnHome) if err != nil { e.Logger.Errorw("Failed to deploy chain contracts", "chain", chainSel, "err", err) return fmt.Errorf("failed to deploy chain contracts for chain %d: %w", chainSel, err) @@ -590,13 +485,8 @@ func DeployChainContracts( e deployment.Environment, chain deployment.Chain, ab deployment.AddressBook, - mcmsConfig MCMSConfig, rmnHome *rmn_home.RMNHome, ) error { - mcmsContracts, err := DeployMCMSContracts(e.Logger, chain, ab, mcmsConfig) - if err != nil { - return err - } // check for existing contracts state, err := LoadOnchainState(e) if err != nil { @@ -610,6 +500,9 @@ func DeployChainContracts( if chainState.Weth9 == nil { return fmt.Errorf("weth9 not found for chain %d, deploy the prerequisites first", chain.Selector) } + if chainState.Timelock == nil { + return fmt.Errorf("timelock not found for chain %d, deploy the mcms contracts first", chain.Selector) + } weth9Contract := chainState.Weth9 if chainState.LinkToken == nil { return fmt.Errorf("link token not found for chain %d, deploy the prerequisites first", chain.Selector) @@ -768,7 +661,7 @@ func DeployChainContracts( LinkToken: linkTokenContract.Address(), TokenPriceStalenessThreshold: uint32(24 * 60 * 60), }, - []common.Address{mcmsContracts.Timelock.Address}, // timelock should be able to update, ramps added after + []common.Address{state.Chains[chain.Selector].Timelock.Address()}, // timelock should be able to update, ramps added after []common.Address{weth9Contract.Address(), linkTokenContract.Address()}, // fee tokens []fee_quoter.FeeQuoterTokenPriceFeedUpdate{}, []fee_quoter.FeeQuoterTokenTransferFeeConfigArgs{}, // TODO: tokens diff --git a/deployment/ccip/deploy_test.go b/deployment/ccip/deploy_test.go index 2ca9901ddbf..c2b71e093de 100644 --- a/deployment/ccip/deploy_test.go +++ b/deployment/ccip/deploy_test.go @@ -6,62 +6,20 @@ import ( "testing" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" - "github.com/smartcontractkit/chainlink/deployment" - "github.com/smartcontractkit/chainlink/deployment/environment/memory" "github.com/smartcontractkit/chainlink/v2/core/logger" ) func TestDeployCCIPContracts(t *testing.T) { lggr := logger.TestLogger(t) - e := memory.NewMemoryEnvironment(t, lggr, zapcore.InfoLevel, memory.MemoryEnvironmentConfig{ - Bootstraps: 1, - Chains: 2, - Nodes: 4, - }) - // Deploy all the CCIP contracts. - homeChainSel, feedChainSel := allocateCCIPChainSelectors(e.Chains) - _ = DeployTestContracts(t, lggr, e.ExistingAddresses, homeChainSel, feedChainSel, e.Chains, MockLinkPrice, MockWethPrice) - - nodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) - require.NoError(t, err) - - _, err = DeployHomeChain(lggr, e, e.ExistingAddresses, e.Chains[homeChainSel], - NewTestRMNStaticConfig(), - NewTestRMNDynamicConfig(), - NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), - map[string][][32]byte{ - "NodeOperator": nodes.NonBootstraps().PeerIDs(), - }, + e := NewMemoryEnvironmentWithJobsAndContracts(t, lggr, + 2, + 4, ) + // Deploy all the CCIP contracts. + state, err := LoadOnchainState(e.Env) require.NoError(t, err) - // Load the state after deploying the cap reg and feeds. - s, err := LoadOnchainState(e) - require.NoError(t, err) - require.NotNil(t, s.Chains[homeChainSel].CapabilityRegistry) - require.NotNil(t, s.Chains[homeChainSel].CCIPHome) - require.NotNil(t, s.Chains[feedChainSel].USDFeeds) - - newAddresses := deployment.NewMemoryAddressBook() - err = DeployPrerequisiteChainContracts(e, newAddresses, e.AllChainSelectors()) - require.NoError(t, err) - require.NoError(t, e.ExistingAddresses.Merge(newAddresses)) - - newAddresses = deployment.NewMemoryAddressBook() - err = DeployCCIPContracts(e, newAddresses, DeployCCIPContractConfig{ - HomeChainSel: homeChainSel, - FeedChainSel: feedChainSel, - ChainsToDeploy: e.AllChainSelectors(), - TokenConfig: NewTokenConfig(), - MCMSConfig: NewTestMCMSConfig(t, e), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, e.ExistingAddresses.Merge(newAddresses)) - state, err := LoadOnchainState(e) - require.NoError(t, err) - snap, err := state.View(e.AllChainSelectors()) + snap, err := state.View(e.Env.AllChainSelectors()) require.NoError(t, err) // Assert expect every deployed address to be in the address book. diff --git a/deployment/ccip/propose.go b/deployment/ccip/propose.go index 9d6ac417968..d7baf9ab542 100644 --- a/deployment/ccip/propose.go +++ b/deployment/ccip/propose.go @@ -1,138 +1,19 @@ package ccipdeployment import ( - "bytes" - "context" - "crypto/ecdsa" "fmt" "math/big" - "testing" "time" - "github.com/ethereum/go-ethereum/accounts/abi/bind" + mapset "github.com/deckarep/golang-set/v2" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - "github.com/smartcontractkit/ccip-owner-contracts/pkg/config" - owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/mcms" "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/timelock" chainsel "github.com/smartcontractkit/chain-selectors" - "github.com/stretchr/testify/require" - - mapset "github.com/deckarep/golang-set/v2" "github.com/smartcontractkit/chainlink/deployment" ) -var ( - TestXXXMCMSSigner *ecdsa.PrivateKey -) - -func init() { - key, err := crypto.GenerateKey() - if err != nil { - panic(err) - } - TestXXXMCMSSigner = key -} - -func SingleGroupMCMS(t *testing.T) config.Config { - publicKey := TestXXXMCMSSigner.Public().(*ecdsa.PublicKey) - // Convert the public key to an Ethereum address - address := crypto.PubkeyToAddress(*publicKey) - c, err := config.NewConfig(1, []common.Address{address}, []config.Config{}) - require.NoError(t, err) - return *c -} - -func NewTestMCMSConfig(t *testing.T, e deployment.Environment) MCMSConfig { - c := SingleGroupMCMS(t) - // All deployer keys can execute. - var executors []common.Address - for _, chain := range e.Chains { - executors = append(executors, chain.DeployerKey.From) - } - return MCMSConfig{ - Admin: c, - Bypasser: c, - Canceller: c, - Executors: executors, - Proposer: c, - } -} - -func SignProposal(t *testing.T, env deployment.Environment, proposal *timelock.MCMSWithTimelockProposal) *mcms.Executor { - executorClients := make(map[mcms.ChainIdentifier]mcms.ContractDeployBackend) - for _, chain := range env.Chains { - chainselc, exists := chainsel.ChainBySelector(chain.Selector) - require.True(t, exists) - chainSel := mcms.ChainIdentifier(chainselc.Selector) - executorClients[chainSel] = chain.Client - } - executor, err := proposal.ToExecutor(true) - require.NoError(t, err) - payload, err := executor.SigningHash() - require.NoError(t, err) - // Sign the payload - sig, err := crypto.Sign(payload.Bytes(), TestXXXMCMSSigner) - require.NoError(t, err) - mcmSig, err := mcms.NewSignatureFromBytes(sig) - require.NoError(t, err) - executor.Proposal.AddSignature(mcmSig) - require.NoError(t, executor.Proposal.Validate()) - return executor -} - -func ExecuteProposal(t *testing.T, env deployment.Environment, executor *mcms.Executor, - state CCIPOnChainState, sel uint64) { - t.Log("Executing proposal on chain", sel) - // Set the root. - tx, err2 := executor.SetRootOnChain(env.Chains[sel].Client, env.Chains[sel].DeployerKey, mcms.ChainIdentifier(sel)) - if err2 != nil { - require.NoError(t, deployment.MaybeDataErr(err2)) - } - _, err2 = env.Chains[sel].Confirm(tx) - require.NoError(t, err2) - - // TODO: This sort of helper probably should move to the MCMS lib. - // Execute all the transactions in the proposal which are for this chain. - for _, chainOp := range executor.Operations[mcms.ChainIdentifier(sel)] { - for idx, op := range executor.ChainAgnosticOps { - if bytes.Equal(op.Data, chainOp.Data) && op.To == chainOp.To { - opTx, err3 := executor.ExecuteOnChain(env.Chains[sel].Client, env.Chains[sel].DeployerKey, idx) - require.NoError(t, err3) - block, err3 := env.Chains[sel].Confirm(opTx) - require.NoError(t, err3) - t.Log("executed", chainOp) - it, err3 := state.Chains[sel].Timelock.FilterCallScheduled(&bind.FilterOpts{ - Start: block, - End: &block, - Context: context.Background(), - }, nil, nil) - require.NoError(t, err3) - var calls []owner_helpers.RBACTimelockCall - var pred, salt [32]byte - for it.Next() { - // Note these are the same for the whole batch, can overwrite - pred = it.Event.Predecessor - salt = it.Event.Salt - t.Log("scheduled", it.Event) - calls = append(calls, owner_helpers.RBACTimelockCall{ - Target: it.Event.Target, - Data: it.Event.Data, - Value: it.Event.Value, - }) - } - tx, err := state.Chains[sel].Timelock.ExecuteBatch( - env.Chains[sel].DeployerKey, calls, pred, salt) - require.NoError(t, err) - _, err = env.Chains[sel].Confirm(tx) - require.NoError(t, err) - } - } - } -} - func GenerateAcceptOwnershipProposal( state CCIPOnChainState, homeChain uint64, diff --git a/deployment/ccip/state.go b/deployment/ccip/state.go index dcbe52524cf..f7fad230cc4 100644 --- a/deployment/ccip/state.go +++ b/deployment/ccip/state.go @@ -17,6 +17,8 @@ import ( "github.com/smartcontractkit/chainlink/deployment/ccip/view/v1_2" "github.com/smartcontractkit/chainlink/deployment/ccip/view/v1_5" "github.com/smartcontractkit/chainlink/deployment/ccip/view/v1_6" + commoncs "github.com/smartcontractkit/chainlink/deployment/common/changeset" + commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" common_v1_0 "github.com/smartcontractkit/chainlink/deployment/common/view/v1_0" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/ccip_config" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/commit_store" @@ -30,8 +32,6 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/keystone/generated/capabilities_registry" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/shared/generated/burn_mint_erc677" - owner_wrappers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" - "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/nonce_manager" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/offramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp" @@ -46,6 +46,7 @@ import ( // CCIPChainState holds a Go binding for all the currently deployed CCIP contracts // on a chain. If a binding is nil, it means here is no such contract on the chain. type CCIPChainState struct { + commoncs.MCMSWithTimelockState OnRamp *onramp.OnRamp OffRamp *offramp.OffRamp FeeQuoter *fee_quoter.FeeQuoter @@ -74,11 +75,6 @@ type CCIPChainState struct { CapabilityRegistry *capabilities_registry.CapabilitiesRegistry CCIPHome *ccip_home.CCIPHome RMNHome *rmn_home.RMNHome - AdminMcm *owner_wrappers.ManyChainMultiSig - BypasserMcm *owner_wrappers.ManyChainMultiSig - CancellerMcm *owner_wrappers.ManyChainMultiSig - ProposerMcm *owner_wrappers.ManyChainMultiSig - Timelock *owner_wrappers.RBACTimelock // TODO remove once staging upgraded. CCIPConfig *ccip_config.CCIPConfig @@ -173,6 +169,13 @@ func (c CCIPChainState) GenerateView() (view.ChainView, error) { } chainView.CapabilityRegistry[c.CapabilityRegistry.Address().Hex()] = capRegView } + if c.MCMSWithTimelockState.Timelock != nil { + mcmsView, err := c.MCMSWithTimelockState.GenerateMCMSWithTimelockView() + if err != nil { + return chainView, err + } + chainView.MCMSWithTimelock = mcmsView + } return chainView, nil } @@ -235,41 +238,20 @@ func LoadOnchainState(e deployment.Environment) (CCIPOnChainState, error) { } // LoadChainState Loads all state for a chain into state -// Modifies map in place func LoadChainState(chain deployment.Chain, addresses map[string]deployment.TypeAndVersion) (CCIPChainState, error) { var state CCIPChainState + mcmsWithTimelock, err := commoncs.LoadMCMSWithTimelockState(chain, addresses) + if err != nil { + return state, err + } + state.MCMSWithTimelockState = *mcmsWithTimelock for address, tvStr := range addresses { switch tvStr.String() { - case deployment.NewTypeAndVersion(RBACTimelock, deployment.Version1_0_0).String(): - tl, err := owner_wrappers.NewRBACTimelock(common.HexToAddress(address), chain.Client) - if err != nil { - return state, err - } - state.Timelock = tl - case deployment.NewTypeAndVersion(AdminManyChainMultisig, deployment.Version1_0_0).String(): - mcms, err := owner_wrappers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) - if err != nil { - return state, err - } - state.AdminMcm = mcms - case deployment.NewTypeAndVersion(ProposerManyChainMultisig, deployment.Version1_0_0).String(): - mcms, err := owner_wrappers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) - if err != nil { - return state, err - } - state.ProposerMcm = mcms - case deployment.NewTypeAndVersion(BypasserManyChainMultisig, deployment.Version1_0_0).String(): - mcms, err := owner_wrappers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) - if err != nil { - return state, err - } - state.BypasserMcm = mcms - case deployment.NewTypeAndVersion(CancellerManyChainMultisig, deployment.Version1_0_0).String(): - mcms, err := owner_wrappers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) - if err != nil { - return state, err - } - state.CancellerMcm = mcms + case deployment.NewTypeAndVersion(commontypes.RBACTimelock, deployment.Version1_0_0).String(), + deployment.NewTypeAndVersion(commontypes.ProposerManyChainMultisig, deployment.Version1_0_0).String(), + deployment.NewTypeAndVersion(commontypes.CancellerManyChainMultisig, deployment.Version1_0_0).String(), + deployment.NewTypeAndVersion(commontypes.BypasserManyChainMultisig, deployment.Version1_0_0).String(): + continue case deployment.NewTypeAndVersion(CapabilitiesRegistry, deployment.Version1_0_0).String(): cr, err := capabilities_registry.NewCapabilitiesRegistry(common.HexToAddress(address), chain.Client) if err != nil { diff --git a/deployment/ccip/test_helpers.go b/deployment/ccip/test_helpers.go index d682a72eddc..f858164e720 100644 --- a/deployment/ccip/test_helpers.go +++ b/deployment/ccip/test_helpers.go @@ -4,22 +4,30 @@ import ( "context" "fmt" "math/big" + "net/http" + "net/http/httptest" "sort" "testing" "time" mapset "github.com/deckarep/golang-set/v2" "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" "github.com/pkg/errors" + + commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" + commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" + + "github.com/ethereum/go-ethereum/common" "github.com/stretchr/testify/require" "go.uber.org/multierr" "go.uber.org/zap/zapcore" chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/smartcontractkit/chainlink-ccip/pkg/reader" cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" "github.com/smartcontractkit/chainlink-common/pkg/logger" @@ -215,6 +223,79 @@ func NewMemoryEnvironmentWithJobs(t *testing.T, lggr logger.Logger, numChains in return e } +// mockAttestationResponse mocks the USDC attestation server, it returns random Attestation. +// We don't need to return exactly the same attestation, because our Mocked USDC contract doesn't rely on any specific +// value, but instead of that it just checks if the attestation is present. Therefore, it makes the test a bit simpler +// and doesn't require very detailed mocks. Please see tests in chainlink-ccip for detailed tests using real attestations +func mockAttestationResponse() *httptest.Server { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + response := `{ + "status": "complete", + "attestation": "0x9049623e91719ef2aa63c55f357be2529b0e7122ae552c18aff8db58b4633c4d3920ff03d3a6d1ddf11f06bf64d7fd60d45447ac81f527ba628877dc5ca759651b08ffae25a6d3b1411749765244f0a1c131cbfe04430d687a2e12fd9d2e6dc08e118ad95d94ad832332cf3c4f7a4f3da0baa803b7be024b02db81951c0f0714de1b" + }` + + _, err := w.Write([]byte(response)) + if err != nil { + panic(err) + } + })) + return server +} + +func NewMemoryEnvironmentWithJobsAndContracts(t *testing.T, lggr logger.Logger, numChains int, numNodes int) DeployedEnv { + e := NewMemoryEnvironment(t, lggr, numChains, numNodes, MockLinkPrice, MockWethPrice) + e.SetupJobs(t) + // Take first non-home chain as the new chain. + newAddresses := deployment.NewMemoryAddressBook() + err := DeployPrerequisiteChainContracts(e.Env, newAddresses, e.Env.AllChainSelectors()) + require.NoError(t, err) + require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) + + cfg := commontypes.MCMSWithTimelockConfig{ + Canceller: commonchangeset.SingleGroupMCMS(t), + Bypasser: commonchangeset.SingleGroupMCMS(t), + Proposer: commonchangeset.SingleGroupMCMS(t), + TimelockExecutors: e.Env.AllDeployerKeys(), + TimelockMinDelay: big.NewInt(0), + } + mcmsCfg := make(map[uint64]commontypes.MCMSWithTimelockConfig) + for _, c := range e.Env.AllChainSelectors() { + mcmsCfg[c] = cfg + } + out, err := commonchangeset.DeployMCMSWithTimelock(e.Env, mcmsCfg) + require.NoError(t, err) + require.NoError(t, e.Env.ExistingAddresses.Merge(out.AddressBook)) + state, err := LoadOnchainState(e.Env) + require.NoError(t, err) + + newAddresses = deployment.NewMemoryAddressBook() + tokenConfig := NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) + server := mockAttestationResponse() + defer server.Close() + endpoint := server.URL + err = DeployCCIPContracts(e.Env, newAddresses, DeployCCIPContractConfig{ + HomeChainSel: e.HomeChainSel, + FeedChainSel: e.FeedChainSel, + ChainsToDeploy: e.Env.AllChainSelectors(), + TokenConfig: tokenConfig, + OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), + USDCConfig: USDCConfig{ + Enabled: true, + USDCAttestationConfig: USDCAttestationConfig{ + API: endpoint, + APITimeout: commonconfig.MustNewDuration(time.Second), + APIInterval: commonconfig.MustNewDuration(500 * time.Millisecond), + }, + }, + }) + require.NoError(t, err) + require.NoError(t, e.Env.ExistingAddresses.Merge(newAddresses)) + state, err = LoadOnchainState(e.Env) + require.NoError(t, err) + + return e +} + func NewMemoryEnvironmentWithJobsAndPrices( t *testing.T, lggr logger.Logger, @@ -516,9 +597,9 @@ func ProcessChangeset(t *testing.T, e deployment.Environment, c deployment.Chang chains.Add(uint64(op.ChainIdentifier)) } - signed := SignProposal(t, e, &prop) + signed := commonchangeset.SignProposal(t, e, &prop) for _, sel := range chains.ToSlice() { - ExecuteProposal(t, e, signed, state, sel) + commonchangeset.ExecuteProposal(t, e, signed, state.Chains[sel].Timelock, sel) } } } diff --git a/deployment/ccip/view/types/contract_state.go b/deployment/ccip/view/types/contract_state.go deleted file mode 100644 index f65c510af53..00000000000 --- a/deployment/ccip/view/types/contract_state.go +++ /dev/null @@ -1,33 +0,0 @@ -package types - -import ( - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" -) - -type ContractMetaData struct { - TypeAndVersion string `json:"typeAndVersion,omitempty"` - Address common.Address `json:"address,omitempty"` - Owner common.Address `json:"owner,omitempty"` -} - -func NewContractMetaData(tv Meta, addr common.Address) (ContractMetaData, error) { - tvStr, err := tv.TypeAndVersion(nil) - if err != nil { - return ContractMetaData{}, err - } - owner, err := tv.Owner(nil) - if err != nil { - return ContractMetaData{}, err - } - return ContractMetaData{ - TypeAndVersion: tvStr, - Address: addr, - Owner: owner, - }, nil -} - -type Meta interface { - TypeAndVersion(opts *bind.CallOpts) (string, error) - Owner(opts *bind.CallOpts) (common.Address, error) -} diff --git a/deployment/ccip/view/view.go b/deployment/ccip/view/view.go index 9ef8583bdf6..318e09100b9 100644 --- a/deployment/ccip/view/view.go +++ b/deployment/ccip/view/view.go @@ -26,6 +26,7 @@ type ChainView struct { OnRamp map[string]v1_6.OnRampView `json:"onRamp,omitempty"` OffRamp map[string]v1_6.OffRampView `json:"offRamp,omitempty"` CapabilityRegistry map[string]common_v1_0.CapabilityRegistryView `json:"capabilityRegistry,omitempty"` + MCMSWithTimelock common_v1_0.MCMSWithTimelockView `json:"mcmsWithTimelock,omitempty"` } func NewChain() ChainView { @@ -44,6 +45,7 @@ func NewChain() ChainView { OnRamp: make(map[string]v1_6.OnRampView), OffRamp: make(map[string]v1_6.OffRampView), CapabilityRegistry: make(map[string]common_v1_0.CapabilityRegistryView), + MCMSWithTimelock: common_v1_0.MCMSWithTimelockView{}, } } diff --git a/deployment/common/changeset/deploy_mcms_with_timelock.go b/deployment/common/changeset/deploy_mcms_with_timelock.go new file mode 100644 index 00000000000..c36e1f1575b --- /dev/null +++ b/deployment/common/changeset/deploy_mcms_with_timelock.go @@ -0,0 +1,20 @@ +package changeset + +import ( + "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/common/changeset/internal" + "github.com/smartcontractkit/chainlink/deployment/common/types" +) + +var _ deployment.ChangeSet[map[uint64]types.MCMSWithTimelockConfig] = DeployMCMSWithTimelock + +func DeployMCMSWithTimelock(e deployment.Environment, cfgByChain map[uint64]types.MCMSWithTimelockConfig) (deployment.ChangesetOutput, error) { + newAddresses := deployment.NewMemoryAddressBook() + err := internal.DeployMCMSWithTimelockContractsBatch( + e.Logger, e.Chains, newAddresses, cfgByChain, + ) + if err != nil { + return deployment.ChangesetOutput{AddressBook: newAddresses}, err + } + return deployment.ChangesetOutput{AddressBook: newAddresses}, nil +} diff --git a/deployment/common/changeset/internal/mcms.go b/deployment/common/changeset/internal/mcms.go new file mode 100644 index 00000000000..1e2fb958aae --- /dev/null +++ b/deployment/common/changeset/internal/mcms.go @@ -0,0 +1,137 @@ +package internal + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/config" + owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" + + "github.com/smartcontractkit/chainlink-common/pkg/logger" + "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/common/types" + "github.com/smartcontractkit/chainlink/deployment/common/view/v1_0" +) + +func DeployMCMSWithConfig( + contractType deployment.ContractType, + lggr logger.Logger, + chain deployment.Chain, + ab deployment.AddressBook, + mcmConfig config.Config, +) (*deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig], error) { + groupQuorums, groupParents, signerAddresses, signerGroups := mcmConfig.ExtractSetConfigInputs() + mcm, err := deployment.DeployContract[*owner_helpers.ManyChainMultiSig](lggr, chain, ab, + func(chain deployment.Chain) deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] { + mcmAddr, tx, mcm, err2 := owner_helpers.DeployManyChainMultiSig( + chain.DeployerKey, + chain.Client, + ) + return deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig]{ + mcmAddr, mcm, tx, deployment.NewTypeAndVersion(contractType, deployment.Version1_0_0), err2, + } + }) + if err != nil { + lggr.Errorw("Failed to deploy mcm", "err", err) + return mcm, err + } + mcmsTx, err := mcm.Contract.SetConfig(chain.DeployerKey, + signerAddresses, + // Signer 1 is int group 0 (root group) with quorum 1. + signerGroups, + groupQuorums, + groupParents, + false, + ) + if _, err := deployment.ConfirmIfNoError(chain, mcmsTx, err); err != nil { + lggr.Errorw("Failed to confirm mcm config", "err", err) + return mcm, err + } + return mcm, nil +} + +// MCMSWithTimelockDeploy holds a bundle of MCMS contract deploys. +type MCMSWithTimelockDeploy struct { + Canceller *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] + Bypasser *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] + Proposer *deployment.ContractDeploy[*owner_helpers.ManyChainMultiSig] + Timelock *deployment.ContractDeploy[*owner_helpers.RBACTimelock] +} + +func DeployMCMSWithTimelockContractsBatch( + lggr logger.Logger, + chains map[uint64]deployment.Chain, + ab deployment.AddressBook, + cfgByChain map[uint64]types.MCMSWithTimelockConfig, +) error { + for chainSel, cfg := range cfgByChain { + _, err := DeployMCMSWithTimelockContracts(lggr, chains[chainSel], ab, cfg) + if err != nil { + return err + } + } + return nil +} + +// DeployMCMSWithTimelockContracts deploys an MCMS for +// each of the timelock roles Bypasser, ProposerMcm, Canceller. +// MCMS contracts for the given configuration +// as well as the timelock. It's not necessarily the only way to use +// the timelock and MCMS, but its reasonable pattern. +func DeployMCMSWithTimelockContracts( + lggr logger.Logger, + chain deployment.Chain, + ab deployment.AddressBook, + config types.MCMSWithTimelockConfig, +) (*MCMSWithTimelockDeploy, error) { + bypasser, err := DeployMCMSWithConfig(types.BypasserManyChainMultisig, lggr, chain, ab, config.Bypasser) + if err != nil { + return nil, err + } + canceller, err := DeployMCMSWithConfig(types.CancellerManyChainMultisig, lggr, chain, ab, config.Canceller) + if err != nil { + return nil, err + } + proposer, err := DeployMCMSWithConfig(types.ProposerManyChainMultisig, lggr, chain, ab, config.Proposer) + if err != nil { + return nil, err + } + + timelock, err := deployment.DeployContract[*owner_helpers.RBACTimelock](lggr, chain, ab, + func(chain deployment.Chain) deployment.ContractDeploy[*owner_helpers.RBACTimelock] { + timelock, tx2, cc, err2 := owner_helpers.DeployRBACTimelock( + chain.DeployerKey, + chain.Client, + config.TimelockMinDelay, + // Deployer is the initial admin. + // TODO: Could expose this as config? + // Or keep this enforced to follow the same pattern? + chain.DeployerKey.From, + []common.Address{proposer.Address}, // proposers + config.TimelockExecutors, //executors + []common.Address{canceller.Address}, // cancellers + []common.Address{bypasser.Address}, // bypassers + ) + return deployment.ContractDeploy[*owner_helpers.RBACTimelock]{ + timelock, cc, tx2, deployment.NewTypeAndVersion(types.RBACTimelock, deployment.Version1_0_0), err2, + } + }) + if err != nil { + lggr.Errorw("Failed to deploy timelock", "err", err) + return nil, err + } + lggr.Infow("deployed timelock", "addr", timelock.Address) + // We grant the timelock the admin role on the MCMS contracts. + tx, err := timelock.Contract.GrantRole(chain.DeployerKey, + v1_0.ADMIN_ROLE.ID, timelock.Address) + if _, err := deployment.ConfirmIfNoError(chain, tx, err); err != nil { + lggr.Errorw("Failed to grant timelock admin role", "err", err) + return nil, err + } + // After the proposer cycle is validated, + // we can remove the deployer as an admin. + return &MCMSWithTimelockDeploy{ + Canceller: canceller, + Bypasser: bypasser, + Proposer: proposer, + Timelock: timelock, + }, nil +} diff --git a/deployment/common/changeset/internal/mcms_test.go b/deployment/common/changeset/internal/mcms_test.go new file mode 100644 index 00000000000..9969a0e5bc9 --- /dev/null +++ b/deployment/common/changeset/internal/mcms_test.go @@ -0,0 +1,58 @@ +package internal_test + +import ( + "encoding/json" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/stretchr/testify/require" + + "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/common/changeset" + "github.com/smartcontractkit/chainlink/deployment/common/changeset/internal" + "github.com/smartcontractkit/chainlink/deployment/common/types" + "github.com/smartcontractkit/chainlink/deployment/environment/memory" + "github.com/smartcontractkit/chainlink/v2/core/logger" +) + +func TestDeployMCMSWithConfig(t *testing.T) { + lggr := logger.TestLogger(t) + chains := memory.NewMemoryChainsWithChainIDs(t, []uint64{ + chainsel.TEST_90000001.EvmChainID, + }) + ab := deployment.NewMemoryAddressBook() + _, err := internal.DeployMCMSWithConfig(types.ProposerManyChainMultisig, + lggr, chains[chainsel.TEST_90000001.Selector], ab, changeset.SingleGroupMCMS(t)) + require.NoError(t, err) +} + +func TestDeployMCMSWithTimelockContracts(t *testing.T) { + lggr := logger.TestLogger(t) + chains := memory.NewMemoryChainsWithChainIDs(t, []uint64{ + chainsel.TEST_90000001.EvmChainID, + }) + ab := deployment.NewMemoryAddressBook() + _, err := internal.DeployMCMSWithTimelockContracts(lggr, + chains[chainsel.TEST_90000001.Selector], + ab, types.MCMSWithTimelockConfig{ + Canceller: changeset.SingleGroupMCMS(t), + Bypasser: changeset.SingleGroupMCMS(t), + Proposer: changeset.SingleGroupMCMS(t), + TimelockExecutors: []common.Address{ + chains[chainsel.TEST_90000001.Selector].DeployerKey.From, + }, + TimelockMinDelay: big.NewInt(0), + }) + require.NoError(t, err) + addresses, err := ab.AddressesForChain(chainsel.TEST_90000001.Selector) + require.NoError(t, err) + require.Len(t, addresses, 4) + mcmsState, err := changeset.LoadMCMSWithTimelockState(chains[chainsel.TEST_90000001.Selector], addresses) + require.NoError(t, err) + v, err := mcmsState.GenerateMCMSWithTimelockView() + b, err := json.MarshalIndent(v, "", " ") + require.NoError(t, err) + t.Log(string(b)) +} diff --git a/deployment/common/changeset/mcms_test_helpers.go b/deployment/common/changeset/mcms_test_helpers.go new file mode 100644 index 00000000000..3951149815c --- /dev/null +++ b/deployment/common/changeset/mcms_test_helpers.go @@ -0,0 +1,115 @@ +package changeset + +import ( + "bytes" + "context" + "crypto/ecdsa" + "testing" + + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/config" + owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/mcms" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/timelock" + chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/stretchr/testify/require" + + "github.com/smartcontractkit/chainlink/deployment" +) + +var ( + // TestXXXMCMSSigner is a throwaway private key used for signing MCMS proposals. + // in tests. + TestXXXMCMSSigner *ecdsa.PrivateKey +) + +func init() { + key, err := crypto.GenerateKey() + if err != nil { + panic(err) + } + TestXXXMCMSSigner = key +} + +func SingleGroupMCMS(t *testing.T) config.Config { + publicKey := TestXXXMCMSSigner.Public().(*ecdsa.PublicKey) + // Convert the public key to an Ethereum address + address := crypto.PubkeyToAddress(*publicKey) + c, err := config.NewConfig(1, []common.Address{address}, []config.Config{}) + require.NoError(t, err) + return *c +} + +func SignProposal(t *testing.T, env deployment.Environment, proposal *timelock.MCMSWithTimelockProposal) *mcms.Executor { + executorClients := make(map[mcms.ChainIdentifier]mcms.ContractDeployBackend) + for _, chain := range env.Chains { + chainselc, exists := chainsel.ChainBySelector(chain.Selector) + require.True(t, exists) + chainSel := mcms.ChainIdentifier(chainselc.Selector) + executorClients[chainSel] = chain.Client + } + executor, err := proposal.ToExecutor(true) + require.NoError(t, err) + payload, err := executor.SigningHash() + require.NoError(t, err) + // Sign the payload + sig, err := crypto.Sign(payload.Bytes(), TestXXXMCMSSigner) + require.NoError(t, err) + mcmSig, err := mcms.NewSignatureFromBytes(sig) + require.NoError(t, err) + executor.Proposal.AddSignature(mcmSig) + require.NoError(t, executor.Proposal.Validate()) + return executor +} + +func ExecuteProposal(t *testing.T, env deployment.Environment, executor *mcms.Executor, + timelock *owner_helpers.RBACTimelock, sel uint64) { + t.Log("Executing proposal on chain", sel) + // Set the root. + tx, err2 := executor.SetRootOnChain(env.Chains[sel].Client, env.Chains[sel].DeployerKey, mcms.ChainIdentifier(sel)) + if err2 != nil { + require.NoError(t, deployment.MaybeDataErr(err2)) + } + _, err2 = env.Chains[sel].Confirm(tx) + require.NoError(t, err2) + + // TODO: This sort of helper probably should move to the MCMS lib. + // Execute all the transactions in the proposal which are for this chain. + for _, chainOp := range executor.Operations[mcms.ChainIdentifier(sel)] { + for idx, op := range executor.ChainAgnosticOps { + if bytes.Equal(op.Data, chainOp.Data) && op.To == chainOp.To { + opTx, err3 := executor.ExecuteOnChain(env.Chains[sel].Client, env.Chains[sel].DeployerKey, idx) + require.NoError(t, err3) + block, err3 := env.Chains[sel].Confirm(opTx) + require.NoError(t, err3) + t.Log("executed", chainOp) + it, err3 := timelock.FilterCallScheduled(&bind.FilterOpts{ + Start: block, + End: &block, + Context: context.Background(), + }, nil, nil) + require.NoError(t, err3) + var calls []owner_helpers.RBACTimelockCall + var pred, salt [32]byte + for it.Next() { + // Note these are the same for the whole batch, can overwrite + pred = it.Event.Predecessor + salt = it.Event.Salt + t.Log("scheduled", it.Event) + calls = append(calls, owner_helpers.RBACTimelockCall{ + Target: it.Event.Target, + Data: it.Event.Data, + Value: it.Event.Value, + }) + } + tx, err := timelock.ExecuteBatch( + env.Chains[sel].DeployerKey, calls, pred, salt) + require.NoError(t, err) + _, err = env.Chains[sel].Confirm(tx) + require.NoError(t, err) + } + } + } +} diff --git a/deployment/common/changeset/state.go b/deployment/common/changeset/state.go new file mode 100644 index 00000000000..38a1d02c044 --- /dev/null +++ b/deployment/common/changeset/state.go @@ -0,0 +1,99 @@ +package changeset + +import ( + "errors" + + "github.com/ethereum/go-ethereum/common" + owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" + + "github.com/smartcontractkit/chainlink/deployment" + "github.com/smartcontractkit/chainlink/deployment/common/types" + "github.com/smartcontractkit/chainlink/deployment/common/view/v1_0" +) + +// MCMSWithTimelockState holds the Go bindings +// for a MCMSWithTimelock contract deployment. +// It is public for use in product specific packages. +type MCMSWithTimelockState struct { + CancellerMcm *owner_helpers.ManyChainMultiSig + BypasserMcm *owner_helpers.ManyChainMultiSig + ProposerMcm *owner_helpers.ManyChainMultiSig + Timelock *owner_helpers.RBACTimelock +} + +func (state MCMSWithTimelockState) Validate() error { + if state.Timelock == nil { + return errors.New("timelock not found") + } + if state.CancellerMcm == nil { + return errors.New("canceller not found") + } + if state.ProposerMcm == nil { + return errors.New("proposer not found") + } + if state.BypasserMcm == nil { + return errors.New("bypasser not found") + } + return nil +} + +func (state MCMSWithTimelockState) GenerateMCMSWithTimelockView() (v1_0.MCMSWithTimelockView, error) { + if err := state.Validate(); err != nil { + return v1_0.MCMSWithTimelockView{}, err + } + timelockView, err := v1_0.GenerateTimelockView(*state.Timelock) + if err != nil { + return v1_0.MCMSWithTimelockView{}, nil + } + bypasserView, err := v1_0.GenerateMCMSView(*state.BypasserMcm) + if err != nil { + return v1_0.MCMSWithTimelockView{}, nil + } + proposerView, err := v1_0.GenerateMCMSView(*state.ProposerMcm) + if err != nil { + return v1_0.MCMSWithTimelockView{}, nil + } + cancellerView, err := v1_0.GenerateMCMSView(*state.CancellerMcm) + if err != nil { + return v1_0.MCMSWithTimelockView{}, nil + } + return v1_0.MCMSWithTimelockView{ + Timelock: timelockView, + Bypasser: bypasserView, + Proposer: proposerView, + Canceller: cancellerView, + }, nil +} + +func LoadMCMSWithTimelockState(chain deployment.Chain, addresses map[string]deployment.TypeAndVersion) (*MCMSWithTimelockState, error) { + state := MCMSWithTimelockState{} + for address, tvStr := range addresses { + switch tvStr.String() { + case deployment.NewTypeAndVersion(types.RBACTimelock, deployment.Version1_0_0).String(): + tl, err := owner_helpers.NewRBACTimelock(common.HexToAddress(address), chain.Client) + if err != nil { + return nil, err + } + state.Timelock = tl + case deployment.NewTypeAndVersion(types.ProposerManyChainMultisig, deployment.Version1_0_0).String(): + mcms, err := owner_helpers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) + if err != nil { + return nil, err + } + state.ProposerMcm = mcms + case deployment.NewTypeAndVersion(types.BypasserManyChainMultisig, deployment.Version1_0_0).String(): + mcms, err := owner_helpers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) + if err != nil { + return nil, err + } + state.BypasserMcm = mcms + case deployment.NewTypeAndVersion(types.CancellerManyChainMultisig, deployment.Version1_0_0).String(): + mcms, err := owner_helpers.NewManyChainMultiSig(common.HexToAddress(address), chain.Client) + if err != nil { + return nil, err + } + state.CancellerMcm = mcms + } + } + return &state, nil +} diff --git a/deployment/common/types/types.go b/deployment/common/types/types.go new file mode 100644 index 00000000000..0efb226d73b --- /dev/null +++ b/deployment/common/types/types.go @@ -0,0 +1,25 @@ +package types + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/config" + + "github.com/smartcontractkit/chainlink/deployment" +) + +const ( + BypasserManyChainMultisig deployment.ContractType = "BypasserManyChainMultiSig" + CancellerManyChainMultisig deployment.ContractType = "CancellerManyChainMultiSig" + ProposerManyChainMultisig deployment.ContractType = "ProposerManyChainMultiSig" + RBACTimelock deployment.ContractType = "RBACTimelock" +) + +type MCMSWithTimelockConfig struct { + Canceller config.Config + Bypasser config.Config + Proposer config.Config + TimelockExecutors []common.Address + TimelockMinDelay *big.Int +} diff --git a/deployment/common/view/v1_0/mcms.go b/deployment/common/view/v1_0/mcms.go new file mode 100644 index 00000000000..25ca614a553 --- /dev/null +++ b/deployment/common/view/v1_0/mcms.go @@ -0,0 +1,146 @@ +package v1_0 + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/config" + owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" + + "github.com/smartcontractkit/chainlink/deployment/common/view/types" + "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" +) + +type Role struct { + ID common.Hash + Name string +} + +const ( + EXECUTOR_ROLE_STR = "EXECUTOR_ROLE" + BYPASSER_ROLE_STR = "BYPASSER_ROLE" + CANCELLER_ROLE_STR = "CANCELLER_ROLE" + PROPOSER_ROLE_STR = "PROPOSER_ROLE" + ADMIN_ROLE_STR = "ADMIN_ROLE" +) + +// https://github.com/smartcontractkit/ccip-owner-contracts/blob/9d81692b324ce7ea2ef8a75e683889edbc7e2dd0/src/RBACTimelock.sol#L71 +// Just to avoid invoking the Go binding to get these. +var ( + ADMIN_ROLE = Role{ + ID: utils.MustHash(ADMIN_ROLE_STR), + Name: ADMIN_ROLE_STR, + } + PROPOSER_ROLE = Role{ + ID: utils.MustHash(PROPOSER_ROLE_STR), + Name: PROPOSER_ROLE_STR, + } + BYPASSER_ROLE = Role{ + ID: utils.MustHash(BYPASSER_ROLE_STR), + Name: BYPASSER_ROLE_STR, + } + CANCELLER_ROLE = Role{ + ID: utils.MustHash(CANCELLER_ROLE_STR), + Name: CANCELLER_ROLE_STR, + } + EXECUTOR_ROLE = Role{ + ID: utils.MustHash(EXECUTOR_ROLE_STR), + Name: EXECUTOR_ROLE_STR, + } +) + +type MCMSView struct { + types.ContractMetaData + // Note config is json marshallable. + Config config.Config `json:"config"` +} + +func GenerateMCMSView(mcms owner_helpers.ManyChainMultiSig) (MCMSView, error) { + owner, err := mcms.Owner(nil) + if err != nil { + return MCMSView{}, nil + } + c, err := mcms.GetConfig(nil) + if err != nil { + return MCMSView{}, nil + } + parsedConfig, err := config.NewConfigFromRaw(c) + if err != nil { + return MCMSView{}, nil + } + return MCMSView{ + // Has no type and version on the contract + ContractMetaData: types.ContractMetaData{ + Owner: owner, + Address: mcms.Address(), + }, + Config: *parsedConfig, + }, nil +} + +type TimelockView struct { + types.ContractMetaData + MembersByRole map[string][]common.Address `json:"membersByRole"` +} + +func GenerateTimelockView(tl owner_helpers.RBACTimelock) (TimelockView, error) { + membersByRole := make(map[string][]common.Address) + for _, role := range []Role{ADMIN_ROLE, PROPOSER_ROLE, BYPASSER_ROLE, CANCELLER_ROLE, EXECUTOR_ROLE} { + numMembers, err := tl.GetRoleMemberCount(nil, role.ID) + if err != nil { + return TimelockView{}, nil + } + for i := int64(0); i < numMembers.Int64(); i++ { + member, err2 := tl.GetRoleMember(nil, role.ID, big.NewInt(i)) + if err2 != nil { + return TimelockView{}, nil + } + membersByRole[role.Name] = append(membersByRole[role.Name], member) + } + } + return TimelockView{ + // Has no type and version or owner. + ContractMetaData: types.ContractMetaData{ + Address: tl.Address(), + }, + MembersByRole: membersByRole, + }, nil +} + +type MCMSWithTimelockView struct { + Bypasser MCMSView `json:"bypasser"` + Canceller MCMSView `json:"canceller"` + Proposer MCMSView `json:"proposer"` + Timelock TimelockView `json:"timelock"` +} + +func GenerateMCMSWithTimelockView( + bypasser owner_helpers.ManyChainMultiSig, + canceller owner_helpers.ManyChainMultiSig, + proposer owner_helpers.ManyChainMultiSig, + timelock owner_helpers.RBACTimelock, +) (MCMSWithTimelockView, error) { + timelockView, err := GenerateTimelockView(timelock) + if err != nil { + return MCMSWithTimelockView{}, nil + } + bypasserView, err := GenerateMCMSView(bypasser) + if err != nil { + return MCMSWithTimelockView{}, nil + } + proposerView, err := GenerateMCMSView(proposer) + if err != nil { + return MCMSWithTimelockView{}, nil + } + cancellerView, err := GenerateMCMSView(canceller) + if err != nil { + return MCMSWithTimelockView{}, nil + } + + return MCMSWithTimelockView{ + Timelock: timelockView, + Bypasser: bypasserView, + Proposer: proposerView, + Canceller: cancellerView, + }, nil +} diff --git a/deployment/environment.go b/deployment/environment.go index 5d4e782b0fe..50301173a8d 100644 --- a/deployment/environment.go +++ b/deployment/environment.go @@ -128,6 +128,14 @@ func (e Environment) AllChainSelectorsExcluding(excluding []uint64) []uint64 { return selectors } +func (e Environment) AllDeployerKeys() []common.Address { + var deployerKeys []common.Address + for sel := range e.Chains { + deployerKeys = append(deployerKeys, e.Chains[sel].DeployerKey.From) + } + return deployerKeys +} + func ConfirmIfNoError(chain Chain, tx *types.Transaction, err error) (uint64, error) { if err != nil { //revive:disable diff --git a/integration-tests/ccip-tests/testsetups/test_helpers.go b/integration-tests/ccip-tests/testsetups/test_helpers.go index 4a480cdaa40..ea57f056945 100644 --- a/integration-tests/ccip-tests/testsetups/test_helpers.go +++ b/integration-tests/ccip-tests/testsetups/test_helpers.go @@ -6,9 +6,12 @@ import ( "os" "strconv" "testing" + "time" chainsel "github.com/smartcontractkit/chain-selectors" + commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" + jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" "github.com/smartcontractkit/chainlink-testing-framework/lib/blockchain" ctfconfig "github.com/smartcontractkit/chainlink-testing-framework/lib/config" ctftestenv "github.com/smartcontractkit/chainlink-testing-framework/lib/docker/test_env" @@ -18,6 +21,8 @@ import ( "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/ptr" "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" "github.com/smartcontractkit/chainlink-testing-framework/seth" + commonchangeset "github.com/smartcontractkit/chainlink/deployment/common/changeset" + commontypes "github.com/smartcontractkit/chainlink/deployment/common/types" "github.com/smartcontractkit/chainlink/deployment" ccipdeployment "github.com/smartcontractkit/chainlink/deployment/ccip" @@ -25,6 +30,7 @@ import ( "github.com/smartcontractkit/chainlink/deployment/environment/devenv" clclient "github.com/smartcontractkit/chainlink/deployment/environment/nodeclient" "github.com/smartcontractkit/chainlink/integration-tests/actions" + ccipactions "github.com/smartcontractkit/chainlink/integration-tests/ccip-tests/actions" "github.com/smartcontractkit/chainlink/integration-tests/contracts" "github.com/smartcontractkit/chainlink/integration-tests/docker/test_env" "github.com/smartcontractkit/chainlink/integration-tests/testconfig" @@ -109,6 +115,7 @@ func NewLocalDevEnvironment( require.NoError(t, err) require.NotNil(t, e) e.ExistingAddresses = ab + require.NotNil(t, testEnv.MockAdapter) e.MockAdapter = testEnv.MockAdapter envNodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) @@ -126,6 +133,69 @@ func NewLocalDevEnvironment( // fund the nodes FundNodes(t, zeroLogLggr, testEnv, cfg, don.PluginNodes()) + output, err := changeset.DeployPrerequisites(*e, changeset.DeployPrerequisiteConfig{ + ChainSelectors: e.AllChainSelectors(), + }) + require.NoError(t, err) + require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) + mcmsCfg := make(map[uint64]commontypes.MCMSWithTimelockConfig) + for _, chain := range e.AllChainSelectors() { + mcmsCfg[chain] = commontypes.MCMSWithTimelockConfig{ + Canceller: commonchangeset.SingleGroupMCMS(t), + Bypasser: commonchangeset.SingleGroupMCMS(t), + Proposer: commonchangeset.SingleGroupMCMS(t), + TimelockExecutors: e.AllDeployerKeys(), + TimelockMinDelay: big.NewInt(0), + } + } + output, err = commonchangeset.DeployMCMSWithTimelock(*e, mcmsCfg) + require.NoError(t, err) + require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) + + state, err := ccipdeployment.LoadOnchainState(*e) + require.NoError(t, err) + + var endpoint string + err = ccipactions.SetMockServerWithUSDCAttestation(e.MockAdapter, nil) + require.NoError(t, err) + endpoint = e.MockAdapter.InternalEndpoint + + tokenConfig := ccipdeployment.NewTestTokenConfig(state.Chains[feedSel].USDFeeds) + // Apply migration + output, err = changeset.InitialDeploy(*e, ccipdeployment.DeployCCIPContractConfig{ + HomeChainSel: homeChainSel, + FeedChainSel: feedSel, + ChainsToDeploy: e.AllChainSelectors(), + TokenConfig: tokenConfig, + OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), + USDCConfig: ccipdeployment.USDCConfig{ + Enabled: true, + USDCAttestationConfig: ccipdeployment.USDCAttestationConfig{ + API: endpoint, + APITimeout: commonconfig.MustNewDuration(time.Second), + APIInterval: commonconfig.MustNewDuration(500 * time.Millisecond), + }, + }, + }) + require.NoError(t, err) + require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) + + // Ensure capreg logs are up to date. + ccipdeployment.ReplayLogs(t, e.Offchain, replayBlocks) + + // Apply the jobs. + for nodeID, jobs := range output.JobSpecs { + for _, job := range jobs { + // Note these auto-accept + _, err := e.Offchain.ProposeJob(ctx, + &jobv1.ProposeJobRequest{ + NodeId: nodeID, + Spec: job, + }) + require.NoError(t, err) + } + } + return ccipdeployment.DeployedEnv{ Env: *e, HomeChainSel: homeChainSel, @@ -140,28 +210,6 @@ func NewLocalDevEnvironmentWithRMN( numRmnNodes int, ) (ccipdeployment.DeployedEnv, devenv.RMNCluster) { tenv, dockerenv, testCfg := NewLocalDevEnvironmentWithDefaultPrice(t, lggr) - state, err := ccipdeployment.LoadOnchainState(tenv.Env) - require.NoError(t, err) - - output, err := changeset.DeployPrerequisites(tenv.Env, changeset.DeployPrerequisiteConfig{ - ChainSelectors: tenv.Env.AllChainSelectors(), - }) - require.NoError(t, err) - require.NoError(t, tenv.Env.ExistingAddresses.Merge(output.AddressBook)) - - // Deploy CCIP contracts. - newAddresses := deployment.NewMemoryAddressBook() - err = ccipdeployment.DeployCCIPContracts(tenv.Env, newAddresses, ccipdeployment.DeployCCIPContractConfig{ - HomeChainSel: tenv.HomeChainSel, - FeedChainSel: tenv.FeedChainSel, - ChainsToDeploy: tenv.Env.AllChainSelectors(), - TokenConfig: ccipdeployment.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds), - MCMSConfig: ccipdeployment.NewTestMCMSConfig(t, tenv.Env), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, tenv.Env.ExistingAddresses.Merge(newAddresses)) - l := logging.GetTestLogger(t) config := GenerateTestRMNConfig(t, numRmnNodes, tenv, MustNetworksToRPCMap(dockerenv.EVMNetworks)) require.NotNil(t, testCfg.CCIP) diff --git a/integration-tests/go.mod b/integration-tests/go.mod index ddcd3ae65fa..7f59031bbe5 100644 --- a/integration-tests/go.mod +++ b/integration-tests/go.mod @@ -36,7 +36,6 @@ require ( github.com/slack-go/slack v0.15.0 github.com/smartcontractkit/chain-selectors v1.0.29 github.com/smartcontractkit/chainlink-automation v0.8.1 - github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 github.com/smartcontractkit/chainlink-protos/job-distributor v0.6.0 github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2 @@ -414,6 +413,7 @@ require ( github.com/shoenig/go-m1cpu v0.1.6 // indirect github.com/sirupsen/logrus v1.9.3 // indirect github.com/smartcontractkit/ccip-owner-contracts v0.0.0-20240926212305-a6deabdfce86 // indirect + github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec // indirect github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f // indirect github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 // indirect github.com/smartcontractkit/chainlink-feeds v0.1.1 // indirect diff --git a/integration-tests/smoke/ccip_messaging_test.go b/integration-tests/smoke/ccip_messaging_test.go index 4aa9ba34229..6bb34658e22 100644 --- a/integration-tests/smoke/ccip_messaging_test.go +++ b/integration-tests/smoke/ccip_messaging_test.go @@ -15,11 +15,8 @@ import ( "github.com/smartcontractkit/chainlink-common/pkg/hashutil" "github.com/smartcontractkit/chainlink-common/pkg/merklemulti" "github.com/smartcontractkit/chainlink-common/pkg/utils/tests" - jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" - "github.com/smartcontractkit/chainlink/deployment" ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" - "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/integration-tests/ccip-tests/testsetups" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/offramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp" @@ -66,44 +63,6 @@ func Test_CCIPMessaging(t *testing.T) { ", source chain selector:", sourceChain, ", dest chain selector:", destChain, ) - output, err := changeset.DeployPrerequisites(e.Env, changeset.DeployPrerequisiteConfig{ - ChainSelectors: e.Env.AllChainSelectors(), - }) - require.NoError(t, err) - require.NoError(t, e.Env.ExistingAddresses.Merge(output.AddressBook)) - - tokenConfig := ccdeploy.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) - // Apply migration - output, err = changeset.InitialDeploy(e.Env, ccdeploy.DeployCCIPContractConfig{ - HomeChainSel: e.HomeChainSel, - FeedChainSel: e.FeedChainSel, - ChainsToDeploy: allChainSelectors, - TokenConfig: tokenConfig, - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e.Env), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, e.Env.ExistingAddresses.Merge(output.AddressBook)) - // Get new state after migration. - state, err = ccdeploy.LoadOnchainState(e.Env) - require.NoError(t, err) - - // Ensure capreg logs are up to date. - ccdeploy.ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks) - - // Apply the jobs. - for nodeID, jobs := range output.JobSpecs { - for _, job := range jobs { - // Note these auto-accept - _, err := e.Env.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } - // connect a single lane, source to dest require.NoError(t, ccdeploy.AddLaneWithDefaultPrices(e.Env, state, sourceChain, destChain)) diff --git a/integration-tests/smoke/ccip_rmn_test.go b/integration-tests/smoke/ccip_rmn_test.go index e8e81688239..d1cadabc06a 100644 --- a/integration-tests/smoke/ccip_rmn_test.go +++ b/integration-tests/smoke/ccip_rmn_test.go @@ -13,7 +13,6 @@ import ( "github.com/rs/zerolog" "github.com/stretchr/testify/require" - jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/osutil" "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" @@ -327,24 +326,7 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { } } - jobSpecs, err := ccipdeployment.NewCCIPJobSpecs(envWithRMN.Env.NodeIDs, envWithRMN.Env.Offchain) - require.NoError(t, err) - - ctx := ccipdeployment.Context(t) - ccipdeployment.ReplayLogs(t, envWithRMN.Env.Offchain, envWithRMN.ReplayBlocks) - - for nodeID, jobs := range jobSpecs { - for _, job := range jobs { - _, err := envWithRMN.Env.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } - // Add all lanes require.NoError(t, ccipdeployment.AddLanesForAll(envWithRMN.Env, onChainState)) diff --git a/integration-tests/smoke/ccip_test.go b/integration-tests/smoke/ccip_test.go index 007a3c37e52..36aed7d5baa 100644 --- a/integration-tests/smoke/ccip_test.go +++ b/integration-tests/smoke/ccip_test.go @@ -7,12 +7,8 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/stretchr/testify/require" - jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" - - "github.com/smartcontractkit/chainlink/deployment" ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" - "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/integration-tests/ccip-tests/testsetups" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" "github.com/smartcontractkit/chainlink/v2/core/logger" @@ -21,51 +17,11 @@ import ( func TestInitialDeployOnLocal(t *testing.T) { t.Parallel() lggr := logger.TestLogger(t) - ctx := ccdeploy.Context(t) tenv, _, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr) e := tenv.Env - - state, err := ccdeploy.LoadOnchainState(tenv.Env) - require.NoError(t, err) - - feeds := state.Chains[tenv.FeedChainSel].USDFeeds - output, err := changeset.DeployPrerequisites(tenv.Env, changeset.DeployPrerequisiteConfig{ - ChainSelectors: tenv.Env.AllChainSelectors(), - }) - require.NoError(t, err) - require.NoError(t, tenv.Env.ExistingAddresses.Merge(output.AddressBook)) - - // Apply migration - output, err = changeset.InitialDeploy(tenv.Env, ccdeploy.DeployCCIPContractConfig{ - HomeChainSel: tenv.HomeChainSel, - FeedChainSel: tenv.FeedChainSel, - ChainsToDeploy: tenv.Env.AllChainSelectors(), - TokenConfig: ccdeploy.NewTestTokenConfig(feeds), - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, tenv.Env.ExistingAddresses.Merge(output.AddressBook)) - // Get new state after migration. - state, err = ccdeploy.LoadOnchainState(e) + state, err := ccdeploy.LoadOnchainState(e) require.NoError(t, err) - // Ensure capreg logs are up to date. - ccdeploy.ReplayLogs(t, e.Offchain, tenv.ReplayBlocks) - - // Apply the jobs. - for nodeID, jobs := range output.JobSpecs { - for _, job := range jobs { - // Note these auto-accept - _, err := e.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } - // Add all lanes require.NoError(t, ccdeploy.AddLanesForAll(e, state)) // Need to keep track of the block number for each chain so that event subscription can be done from that block. @@ -113,34 +69,11 @@ func TestInitialDeployOnLocal(t *testing.T) { func TestTokenTransfer(t *testing.T) { t.Parallel() lggr := logger.TestLogger(t) - ctx := ccdeploy.Context(t) tenv, _, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr) - e := tenv.Env state, err := ccdeploy.LoadOnchainState(e) require.NoError(t, err) - output, err := changeset.DeployPrerequisites(e, changeset.DeployPrerequisiteConfig{ - ChainSelectors: e.AllChainSelectors(), - }) - require.NoError(t, err) - require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) - - // Apply migration - output, err = changeset.InitialDeploy(e, ccdeploy.DeployCCIPContractConfig{ - HomeChainSel: tenv.HomeChainSel, - FeedChainSel: tenv.FeedChainSel, - ChainsToDeploy: e.AllChainSelectors(), - TokenConfig: ccdeploy.NewTestTokenConfig(state.Chains[tenv.FeedChainSel].USDFeeds), - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) - // Get new state after migration and mock USDC token deployment. - state, err = ccdeploy.LoadOnchainState(e) - require.NoError(t, err) - srcToken, _, dstToken, _, err := ccdeploy.DeployTransferableToken( lggr, tenv.Env.Chains, @@ -152,22 +85,6 @@ func TestTokenTransfer(t *testing.T) { ) require.NoError(t, err) - // Ensure capreg logs are up to date. - ccdeploy.ReplayLogs(t, e.Offchain, tenv.ReplayBlocks) - - // Apply the jobs. - for nodeID, jobs := range output.JobSpecs { - for _, job := range jobs { - // Note these auto-accept - _, err := e.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } - // Add all lanes require.NoError(t, ccdeploy.AddLanesForAll(e, state)) // Need to keep track of the block number for each chain so that event subscription can be done from that block. diff --git a/integration-tests/smoke/ccip_usdc_test.go b/integration-tests/smoke/ccip_usdc_test.go index 091912b26fb..a183808f2f8 100644 --- a/integration-tests/smoke/ccip_usdc_test.go +++ b/integration-tests/smoke/ccip_usdc_test.go @@ -2,8 +2,6 @@ package smoke import ( "math/big" - "net/http" - "net/http/httptest" "testing" "time" @@ -13,16 +11,10 @@ import ( "golang.org/x/exp/maps" - cciptypes "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" - "github.com/smartcontractkit/chainlink-ccip/pluginconfig" - commonconfig "github.com/smartcontractkit/chainlink-common/pkg/config" "github.com/smartcontractkit/chainlink-common/pkg/utils/tests" - jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" "github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext" "github.com/smartcontractkit/chainlink/deployment" ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" - "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" - "github.com/smartcontractkit/chainlink/integration-tests/ccip-tests/actions" "github.com/smartcontractkit/chainlink/integration-tests/ccip-tests/testsetups" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" @@ -33,20 +25,7 @@ import ( func TestUSDCTokenTransfer(t *testing.T) { lggr := logger.TestLogger(t) - ctx := ccdeploy.Context(t) - tenv, cluster, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr) - - var endpoint string - // When inmemory env then spin up in memory mock server - if cluster == nil { - server := mockAttestationResponse() - defer server.Close() - endpoint = server.URL - } else { - err := actions.SetMockServerWithUSDCAttestation(tenv.Env.MockAdapter, nil) - require.NoError(t, err) - endpoint = tenv.Env.MockAdapter.InternalEndpoint - } + tenv, _, _ := testsetups.NewLocalDevEnvironmentWithDefaultPrice(t, lggr) e := tenv.Env state, err := ccdeploy.LoadOnchainState(e) @@ -56,45 +35,6 @@ func TestUSDCTokenTransfer(t *testing.T) { sourceChain := allChainSelectors[0] destChain := allChainSelectors[1] - feeds := state.Chains[tenv.FeedChainSel].USDFeeds - tokenConfig := ccdeploy.NewTokenConfig() - tokenConfig.UpsertTokenInfo(ccdeploy.LinkSymbol, - pluginconfig.TokenInfo{ - AggregatorAddress: cciptypes.UnknownEncodedAddress(feeds[ccdeploy.LinkSymbol].Address().String()), - Decimals: ccdeploy.LinkDecimals, - DeviationPPB: cciptypes.NewBigIntFromInt64(1e9), - }, - ) - - output, err := changeset.DeployPrerequisites(e, changeset.DeployPrerequisiteConfig{ - ChainSelectors: e.AllChainSelectors(), - }) - require.NoError(t, err) - require.NoError(t, tenv.Env.ExistingAddresses.Merge(output.AddressBook)) - - // Apply migration - output, err = changeset.InitialDeploy(e, ccdeploy.DeployCCIPContractConfig{ - HomeChainSel: tenv.HomeChainSel, - FeedChainSel: tenv.FeedChainSel, - ChainsToDeploy: e.AllChainSelectors(), - TokenConfig: tokenConfig, - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - USDCConfig: ccdeploy.USDCConfig{ - Enabled: true, - USDCAttestationConfig: ccdeploy.USDCAttestationConfig{ - API: endpoint, - APITimeout: commonconfig.MustNewDuration(time.Second), - APIInterval: commonconfig.MustNewDuration(500 * time.Millisecond), - }, - }, - }) - require.NoError(t, err) - require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) - - state, err = ccdeploy.LoadOnchainState(e) - require.NoError(t, err) - srcUSDC, dstUSDC, err := ccdeploy.ConfigureUSDCTokenPools(lggr, e.Chains, sourceChain, destChain, state) require.NoError(t, err) @@ -109,22 +49,6 @@ func TestUSDCTokenTransfer(t *testing.T) { ) require.NoError(t, err) - // Ensure capreg logs are up to date. - ccdeploy.ReplayLogs(t, e.Offchain, tenv.ReplayBlocks) - - // Apply the jobs. - for nodeID, jobs := range output.JobSpecs { - for _, job := range jobs { - // Note these auto-accept - _, err := e.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } - // Add all lanes require.NoError(t, ccdeploy.AddLanesForAll(e, state)) @@ -312,25 +236,6 @@ func transferAndWaitForSuccess( ccdeploy.ConfirmExecWithSeqNrForAll(t, env, state, expectedSeqNum, startBlocks) } -// mockAttestationResponse mocks the USDC attestation server, it returns random Attestation. -// We don't need to return exactly the same attestation, because our Mocked USDC contract doesn't rely on any specific -// value, but instead of that it just checks if the attestation is present. Therefore, it makes the test a bit simpler -// and doesn't require very detailed mocks. Please see tests in chainlink-ccip for detailed tests using real attestations -func mockAttestationResponse() *httptest.Server { - server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - response := `{ - "status": "complete", - "attestation": "0x9049623e91719ef2aa63c55f357be2529b0e7122ae552c18aff8db58b4633c4d3920ff03d3a6d1ddf11f06bf64d7fd60d45447ac81f527ba628877dc5ca759651b08ffae25a6d3b1411749765244f0a1c131cbfe04430d687a2e12fd9d2e6dc08e118ad95d94ad832332cf3c4f7a4f3da0baa803b7be024b02db81951c0f0714de1b" - }` - - _, err := w.Write([]byte(response)) - if err != nil { - panic(err) - } - })) - return server -} - func waitForTheTokenBalance( t *testing.T, token common.Address, diff --git a/integration-tests/smoke/fee_boosting_test.go b/integration-tests/smoke/fee_boosting_test.go index 625200360e8..0e0fb094016 100644 --- a/integration-tests/smoke/fee_boosting_test.go +++ b/integration-tests/smoke/fee_boosting_test.go @@ -9,10 +9,8 @@ import ( "github.com/test-go/testify/require" "golang.org/x/exp/maps" - jobv1 "github.com/smartcontractkit/chainlink-protos/job-distributor/v1/job" "github.com/smartcontractkit/chainlink/deployment" ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" - "github.com/smartcontractkit/chainlink/deployment/ccip/changeset" "github.com/smartcontractkit/chainlink/integration-tests/ccip-tests/testsetups" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" "github.com/smartcontractkit/chainlink/v2/core/logger" @@ -35,8 +33,6 @@ type priceFeedPrices struct { // TODO: find a way to reuse the same test setup for all tests func Test_CCIPFeeBoosting(t *testing.T) { - ctx := ccdeploy.Context(t) - setupTestEnv := func(t *testing.T, numChains int) (ccdeploy.DeployedEnv, ccdeploy.CCIPOnChainState, []uint64) { e, _, _ := testsetups.NewLocalDevEnvironment( t, logger.TestLogger(t), @@ -48,44 +44,6 @@ func Test_CCIPFeeBoosting(t *testing.T) { allChainSelectors := maps.Keys(e.Env.Chains) require.Len(t, allChainSelectors, numChains) - - output, err := changeset.DeployPrerequisites(e.Env, changeset.DeployPrerequisiteConfig{ - ChainSelectors: e.Env.AllChainSelectors(), - }) - require.NoError(t, err) - require.NoError(t, e.Env.ExistingAddresses.Merge(output.AddressBook)) - - tokenConfig := ccdeploy.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) - // Apply migration - output, err = changeset.InitialDeploy(e.Env, ccdeploy.DeployCCIPContractConfig{ - HomeChainSel: e.HomeChainSel, - FeedChainSel: e.FeedChainSel, - ChainsToDeploy: allChainSelectors, - TokenConfig: tokenConfig, - MCMSConfig: ccdeploy.NewTestMCMSConfig(t, e.Env), - OCRSecrets: deployment.XXXGenerateTestOCRSecrets(), - }) - require.NoError(t, err) - require.NoError(t, e.Env.ExistingAddresses.Merge(output.AddressBook)) - state, err = ccdeploy.LoadOnchainState(e.Env) - require.NoError(t, err) - - // Ensure capreg logs are up to date. - ccdeploy.ReplayLogs(t, e.Env.Offchain, e.ReplayBlocks) - - // Apply the jobs. - for nodeID, jobs := range output.JobSpecs { - for _, job := range jobs { - // Note these auto-accept - _, err := e.Env.Offchain.ProposeJob(ctx, - &jobv1.ProposeJobRequest{ - NodeId: nodeID, - Spec: job, - }) - require.NoError(t, err) - } - } - return e, state, allChainSelectors } From a3c809282446174c8a13b78e83c3a76a3efca171 Mon Sep 17 00:00:00 2001 From: pavel-raykov <165708424+pavel-raykov@users.noreply.github.com> Date: Wed, 20 Nov 2024 11:47:54 +0100 Subject: [PATCH 2/6] Remove unused ocr1 key files. (#15307) * Remove unused ocr1 key files. * Minor * Minor --- .changeset/forty-foxes-rescue.md | 5 + .../keystore/keys/ocrkey/key_bundle.go | 259 ------------------ .../keystore/keys/ocrkey/key_bundle_test.go | 102 ------- ..._test.go => off_chain_private_key_test.go} | 4 +- 4 files changed, 7 insertions(+), 363 deletions(-) create mode 100644 .changeset/forty-foxes-rescue.md delete mode 100644 core/services/keystore/keys/ocrkey/key_bundle.go delete mode 100644 core/services/keystore/keys/ocrkey/key_bundle_test.go rename core/services/keystore/keys/ocrkey/{off_chan_private_key_test.go => off_chain_private_key_test.go} (77%) diff --git a/.changeset/forty-foxes-rescue.md b/.changeset/forty-foxes-rescue.md new file mode 100644 index 00000000000..9456ebe5e36 --- /dev/null +++ b/.changeset/forty-foxes-rescue.md @@ -0,0 +1,5 @@ +--- +"chainlink": minor +--- + +#removed Remove unused ocr1 key files. diff --git a/core/services/keystore/keys/ocrkey/key_bundle.go b/core/services/keystore/keys/ocrkey/key_bundle.go deleted file mode 100644 index a73d8d5bd1e..00000000000 --- a/core/services/keystore/keys/ocrkey/key_bundle.go +++ /dev/null @@ -1,259 +0,0 @@ -package ocrkey - -import ( - "crypto/ecdsa" - "crypto/ed25519" - cryptorand "crypto/rand" - "crypto/sha256" - "encoding/hex" - "encoding/json" - "fmt" - "io" - "log" - "time" - - "github.com/ethereum/go-ethereum/accounts/keystore" - "github.com/pkg/errors" - ocrtypes "github.com/smartcontractkit/libocr/offchainreporting/types" - "golang.org/x/crypto/curve25519" - - "github.com/smartcontractkit/chainlink/v2/core/store/models" - "github.com/smartcontractkit/chainlink/v2/core/utils" -) - -type ( - // KeyBundle represents the bundle of keys needed for OCR - KeyBundle struct { - ID models.Sha256Hash - onChainSigning *onChainPrivateKey - offChainSigning *offChainPrivateKey - offChainEncryption *[curve25519.ScalarSize]byte - } - - // EncryptedKeyBundle holds an encrypted KeyBundle - EncryptedKeyBundle struct { - ID models.Sha256Hash - OnChainSigningAddress OnChainSigningAddress - OffChainPublicKey OffChainPublicKey - ConfigPublicKey ConfigPublicKey - EncryptedPrivateKeys []byte - CreatedAt time.Time - UpdatedAt time.Time - DeletedAt *time.Time - } -) - -func (ekb EncryptedKeyBundle) GetID() string { - return ekb.ID.String() -} - -func (ekb *EncryptedKeyBundle) SetID(value string) error { - var result models.Sha256Hash - decodedString, err := hex.DecodeString(value) - - if err != nil { - return err - } - - copy(result[:], decodedString[:32]) - ekb.ID = result - return nil -} - -// New makes a new set of OCR key bundles from cryptographically secure entropy -func New() (*KeyBundle, error) { - return NewFrom(cryptorand.Reader, cryptorand.Reader, cryptorand.Reader) -} - -// NewFrom makes a new set of OCR key bundles from cryptographically secure entropy -func NewFrom(onChainSigning io.Reader, offChainSigning io.Reader, offChainEncryption io.Reader) (*KeyBundle, error) { - ecdsaKey, err := ecdsa.GenerateKey(curve, onChainSigning) - if err != nil { - return nil, err - } - onChainPriv := (*onChainPrivateKey)(ecdsaKey) - - _, offChainPriv, err := ed25519.GenerateKey(offChainSigning) - if err != nil { - return nil, err - } - var encryptionPriv [curve25519.ScalarSize]byte - _, err = offChainEncryption.Read(encryptionPriv[:]) - if err != nil { - return nil, err - } - k := &KeyBundle{ - onChainSigning: onChainPriv, - offChainSigning: (*offChainPrivateKey)(&offChainPriv), - offChainEncryption: &encryptionPriv, - } - marshalledPrivK, err := json.Marshal(k) - if err != nil { - return nil, err - } - k.ID = sha256.Sum256(marshalledPrivK) - return k, nil -} - -// SignOnChain returns an ethereum-style ECDSA secp256k1 signature on msg. -func (pk *KeyBundle) SignOnChain(msg []byte) (signature []byte, err error) { - return pk.onChainSigning.Sign(msg) -} - -// SignOffChain returns an EdDSA-Ed25519 signature on msg. -func (pk *KeyBundle) SignOffChain(msg []byte) (signature []byte, err error) { - return pk.offChainSigning.Sign(msg) -} - -// ConfigDiffieHellman returns the shared point obtained by multiplying someone's -// public key by a secret scalar ( in this case, the offChainEncryption key.) -func (pk *KeyBundle) ConfigDiffieHellman(base *[curve25519.PointSize]byte) ( - sharedPoint *[curve25519.PointSize]byte, err error, -) { - p, err := curve25519.X25519(pk.offChainEncryption[:], base[:]) - if err != nil { - return nil, err - } - sharedPoint = new([ed25519.PublicKeySize]byte) - copy(sharedPoint[:], p) - return sharedPoint, nil -} - -// PublicKeyAddressOnChain returns public component of the keypair used in -// SignOnChain -func (pk *KeyBundle) PublicKeyAddressOnChain() ocrtypes.OnChainSigningAddress { - return ocrtypes.OnChainSigningAddress(pk.onChainSigning.Address()) -} - -// PublicKeyOffChain returns the public component of the keypair used in SignOffChain -func (pk *KeyBundle) PublicKeyOffChain() ocrtypes.OffchainPublicKey { - return ocrtypes.OffchainPublicKey(pk.offChainSigning.PublicKey()) -} - -// PublicKeyConfig returns the public component of the keypair used in ConfigKeyShare -func (pk *KeyBundle) PublicKeyConfig() [curve25519.PointSize]byte { - rv, err := curve25519.X25519(pk.offChainEncryption[:], curve25519.Basepoint) - if err != nil { - log.Println("failure while computing public key: " + err.Error()) - } - var rvFixed [curve25519.PointSize]byte - copy(rvFixed[:], rv) - return rvFixed -} - -// Encrypt combines the KeyBundle into a single json-serialized -// bytes array and then encrypts -func (pk *KeyBundle) Encrypt(auth string, scryptParams utils.ScryptParams) (*EncryptedKeyBundle, error) { - return pk.encrypt(auth, scryptParams) -} - -// encrypt combines the KeyBundle into a single json-serialized -// bytes array and then encrypts, using the provided scrypt params -// separated into a different function so that scryptParams can be -// weakened in tests -func (pk *KeyBundle) encrypt(auth string, scryptParams utils.ScryptParams) (*EncryptedKeyBundle, error) { - marshalledPrivK, err := json.Marshal(&pk) - if err != nil { - return nil, err - } - cryptoJSON, err := keystore.EncryptDataV3( - marshalledPrivK, - []byte(adulteratedPassword(auth)), - scryptParams.N, - scryptParams.P, - ) - if err != nil { - return nil, errors.Wrapf(err, "could not encrypt ocr key") - } - encryptedPrivKeys, err := json.Marshal(&cryptoJSON) - if err != nil { - return nil, errors.Wrapf(err, "could not encode cryptoJSON") - } - return &EncryptedKeyBundle{ - ID: pk.ID, - OnChainSigningAddress: pk.onChainSigning.Address(), - OffChainPublicKey: pk.offChainSigning.PublicKey(), - ConfigPublicKey: pk.PublicKeyConfig(), - EncryptedPrivateKeys: encryptedPrivKeys, - }, nil -} - -// Decrypt returns the PrivateKeys in e, decrypted via auth, or an error -func (ekb *EncryptedKeyBundle) Decrypt(auth string) (*KeyBundle, error) { - var cryptoJSON keystore.CryptoJSON - err := json.Unmarshal(ekb.EncryptedPrivateKeys, &cryptoJSON) - if err != nil { - return nil, errors.Wrapf(err, "invalid cryptoJSON for OCR key bundle") - } - marshalledPrivK, err := keystore.DecryptDataV3(cryptoJSON, adulteratedPassword(auth)) - if err != nil { - return nil, errors.Wrapf(err, "could not decrypt OCR key bundle") - } - var pk KeyBundle - err = json.Unmarshal(marshalledPrivK, &pk) - if err != nil { - return nil, errors.Wrapf(err, "could not unmarshal OCR key bundle") - } - return &pk, nil -} - -// MarshalJSON marshals the private keys into json -func (pk *KeyBundle) MarshalJSON() ([]byte, error) { - rawKeyData := keyBundleRawData{ - EcdsaD: *pk.onChainSigning.D, - Ed25519PrivKey: []byte(*pk.offChainSigning), - OffChainEncryption: *pk.offChainEncryption, - } - return json.Marshal(&rawKeyData) -} - -// UnmarshalJSON constructs KeyBundle from raw json -func (pk *KeyBundle) UnmarshalJSON(b []byte) (err error) { - var rawKeyData keyBundleRawData - err = json.Unmarshal(b, &rawKeyData) - if err != nil { - return err - } - ecdsaDSize := len(rawKeyData.EcdsaD.Bytes()) - if ecdsaDSize > curve25519.PointSize { - return errors.Wrapf(ErrScalarTooBig, "got %d byte ecdsa scalar", ecdsaDSize) - } - - publicKey := ecdsa.PublicKey{Curve: curve} - publicKey.X, publicKey.Y = curve.ScalarBaseMult(rawKeyData.EcdsaD.Bytes()) - privateKey := ecdsa.PrivateKey{ - PublicKey: publicKey, - D: &rawKeyData.EcdsaD, - } - onChainSigning := onChainPrivateKey(privateKey) - offChainSigning := offChainPrivateKey(rawKeyData.Ed25519PrivKey) - pk.onChainSigning = &onChainSigning - pk.offChainSigning = &offChainSigning - pk.offChainEncryption = &rawKeyData.OffChainEncryption - pk.ID = sha256.Sum256(b) - return nil -} - -// String reduces the risk of accidentally logging the private key -func (pk KeyBundle) String() string { - addressOnChain := pk.PublicKeyAddressOnChain() - return fmt.Sprintf( - "KeyBundle{PublicKeyAddressOnChain: %s, PublicKeyOffChain: %s}", - hex.EncodeToString(addressOnChain[:]), - hex.EncodeToString(pk.PublicKeyOffChain()), - ) -} - -// GoString reduces the risk of accidentally logging the private key -func (pk KeyBundle) GoString() string { - return pk.String() -} - -// GoString reduces the risk of accidentally logging the private key -func (pk KeyBundle) ToV2() KeyV2 { - return KeyV2{ - OnChainSigning: pk.onChainSigning, - OffChainSigning: pk.offChainSigning, - OffChainEncryption: pk.offChainEncryption, - } -} diff --git a/core/services/keystore/keys/ocrkey/key_bundle_test.go b/core/services/keystore/keys/ocrkey/key_bundle_test.go deleted file mode 100644 index fe9391735a1..00000000000 --- a/core/services/keystore/keys/ocrkey/key_bundle_test.go +++ /dev/null @@ -1,102 +0,0 @@ -package ocrkey_test - -import ( - "math/big" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - - "github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ocrkey" - "github.com/smartcontractkit/chainlink/v2/core/utils" -) - -func assertKeyBundlesNotEqual(t *testing.T, pk1 ocrkey.KeyV2, pk2 ocrkey.KeyV2) { - assert.NotEqual(t, pk1.ID(), pk2.ID()) - assert.NotEqual(t, pk1.ExportedOnChainSigning().X, pk2.ExportedOnChainSigning().X) - assert.NotEqual(t, pk1.ExportedOnChainSigning().Y, pk2.ExportedOnChainSigning().Y) - assert.NotEqual(t, pk1.ExportedOnChainSigning().D, pk2.ExportedOnChainSigning().D) - assert.NotEqual(t, pk1.ExportedOffChainSigning().PublicKey(), pk2.ExportedOffChainSigning().PublicKey()) - assert.NotEqual(t, pk1.ExportedOffChainEncryption(), pk2.ExportedOffChainEncryption()) -} - -func TestOCRKeys_New(t *testing.T) { - t.Parallel() - pk1, err := ocrkey.NewV2() - require.NoError(t, err) - pk2, err := ocrkey.NewV2() - require.NoError(t, err) - pk3, err := ocrkey.NewV2() - require.NoError(t, err) - assertKeyBundlesNotEqual(t, pk1, pk2) - assertKeyBundlesNotEqual(t, pk1, pk3) - assertKeyBundlesNotEqual(t, pk2, pk3) -} - -func TestOCRKeys_NewBundleIDMatchesOld(t *testing.T) { - t.Parallel() - oldKey, err := ocrkey.New() - require.NoError(t, err) - newKey := oldKey.ToV2() - require.Equal(t, oldKey.ID.String(), newKey.ID()) -} - -func TestOCRKeys_Raw_Key(t *testing.T) { - t.Parallel() - key := ocrkey.MustNewV2XXXTestingOnly(big.NewInt(1)) - require.Equal(t, key.ID(), key.Raw().Key().ID()) -} - -func TestOCRKeys_BundleSetID(t *testing.T) { - t.Parallel() - - k, err := ocrkey.New() - require.NoError(t, err) - ek, err := k.Encrypt("test", utils.FastScryptParams) - require.NoError(t, err) - - oldId := ek.GetID() - err = ek.SetID("48656c6c6f20476f7068657221") - require.NoError(t, err) - - assert.NotEqual(t, oldId, ek.GetID()) - - err = ek.SetID("invalid id") - assert.Error(t, err) -} - -func TestOCRKeys_BundleDecrypt(t *testing.T) { - t.Parallel() - - k, err := ocrkey.New() - require.NoError(t, err) - ek, err := k.Encrypt("test", utils.FastScryptParams) - require.NoError(t, err) - - _, err = ek.Decrypt("wrongpass") - assert.Error(t, err) - - dk, err := ek.Decrypt("test") - require.NoError(t, err) - - dk.GoString() - assert.Equal(t, k.GoString(), dk.GoString()) - assert.Equal(t, k.ID.String(), dk.ID.String()) -} - -func TestOCRKeys_BundleMarshalling(t *testing.T) { - t.Parallel() - - k, err := ocrkey.New() - require.NoError(t, err) - k2, err := ocrkey.New() - require.NoError(t, err) - - mk, err := k.MarshalJSON() - require.NoError(t, err) - - err = k2.UnmarshalJSON(mk) - require.NoError(t, err) - - assert.Equal(t, k.String(), k2.String()) -} diff --git a/core/services/keystore/keys/ocrkey/off_chan_private_key_test.go b/core/services/keystore/keys/ocrkey/off_chain_private_key_test.go similarity index 77% rename from core/services/keystore/keys/ocrkey/off_chan_private_key_test.go rename to core/services/keystore/keys/ocrkey/off_chain_private_key_test.go index 0c0f6a96957..a7eadc72860 100644 --- a/core/services/keystore/keys/ocrkey/off_chan_private_key_test.go +++ b/core/services/keystore/keys/ocrkey/off_chain_private_key_test.go @@ -10,10 +10,10 @@ import ( func TestOCRKeys_OffChainPrivateKey(t *testing.T) { t.Parallel() - k, err := New() + k, err := NewV2() require.NoError(t, err) - sig, err := k.offChainSigning.Sign([]byte("hello world")) + sig, err := k.OffChainSigning.Sign([]byte("hello world")) assert.NoError(t, err) assert.NotEmpty(t, sig) From 43f0ff1334b2e0c12b5073125dc524874839b70f Mon Sep 17 00:00:00 2001 From: Jordan Krage Date: Wed, 20 Nov 2024 05:07:34 -0600 Subject: [PATCH 3/6] bump go 1.23; implement one iter.Seq (#14353) * bump go 1.23; implement one iter.Seq * fix linter issues --- .github/actions/setup-go/action.yml | 1 + .github/workflows/find-new-flaky-tests.yml | 1 - .github/workflows/integration-tests.yml | 2 +- .tool-versions | 2 +- core/chainlink.Dockerfile | 4 +- core/cmd/admin_commands.go | 1 + core/cmd/shell_remote_test.go | 30 ----- core/platform/monitoring.go | 16 ++- core/scripts/go.mod | 2 +- .../keystore/keys/ocrkey/key_v2_test.go | 38 +++++++ core/services/workflows/engine.go | 2 +- deployment/go.mod | 2 +- go.mod | 2 +- integration-tests/.tool-versions | 2 +- integration-tests/actions/actions.go | 32 +++--- .../actions/automationv2/actions.go | 8 +- integration-tests/actions/keeper_helpers.go | 15 ++- integration-tests/actions/refund.go | 4 + .../actions/vrf/vrfv2plus/setup_steps.go | 2 +- .../ccip-tests/actions/ccip_helpers.go | 16 ++- .../ccip-tests/actions/reorg_helpers.go | 6 +- .../ccip-tests/contracts/contract_models.go | 6 +- .../ccip-tests/smoke/ccip_test.go | 25 +++-- .../ccip-tests/testconfig/global.go | 2 +- .../ccip-tests/testsetups/ccip.go | 9 +- .../ccip-tests/testsetups/test_helpers.go | 12 ++ .../ccip-tests/types/config/node/core.go | 4 + .../ethereum_contracts_automation.go | 12 +- .../docker/test_env/test_env_builder.go | 9 +- integration-tests/go.mod | 2 +- integration-tests/load/functions/gateway.go | 4 + .../load/functions/gateway_gun.go | 32 ++++-- integration-tests/load/functions/setup.go | 12 +- integration-tests/load/go.mod | 105 +++++++++--------- integration-tests/load/vrfv2/gun.go | 10 +- integration-tests/load/vrfv2plus/gun.go | 9 +- integration-tests/smoke/ccip_rmn_test.go | 9 ++ .../smoke/forwarders_ocr2_test.go | 5 +- integration-tests/smoke/log_poller_test.go | 15 ++- integration-tests/smoke/ocr2_test.go | 7 +- integration-tests/smoke/vrfv2_test.go | 25 +++-- integration-tests/smoke/vrfv2plus_test.go | 36 +++--- integration-tests/testconfig/ccip/config.go | 7 +- .../testconfig/testconfig_utils.go | 13 +-- integration-tests/testreporters/keeper.go | 13 +-- .../testreporters/keeper_benchmark.go | 12 +- .../testsetups/automation_benchmark.go | 9 +- .../universal/log_poller/helpers.go | 20 +++- plugins/chainlink.Dockerfile | 4 +- 49 files changed, 402 insertions(+), 214 deletions(-) create mode 100644 core/services/keystore/keys/ocrkey/key_v2_test.go diff --git a/.github/actions/setup-go/action.yml b/.github/actions/setup-go/action.yml index b5519fbad0e..ddd4e28e461 100644 --- a/.github/actions/setup-go/action.yml +++ b/.github/actions/setup-go/action.yml @@ -34,6 +34,7 @@ runs: with: go-version-file: ${{ inputs.go-version-file }} cache: false + check-latest: true - name: Get branch name if: ${{ inputs.only-modules == 'false' }} diff --git a/.github/workflows/find-new-flaky-tests.yml b/.github/workflows/find-new-flaky-tests.yml index 0cdfb2b3091..a685f4f5e70 100644 --- a/.github/workflows/find-new-flaky-tests.yml +++ b/.github/workflows/find-new-flaky-tests.yml @@ -95,7 +95,6 @@ jobs: - name: Set up Go 1.21.9 uses: actions/setup-go@v5.0.2 with: - go-version: '1.21.9' cache: false - name: Install flakeguard diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml index 1034a8fe834..ea0016014a7 100644 --- a/.github/workflows/integration-tests.yml +++ b/.github/workflows/integration-tests.yml @@ -148,7 +148,7 @@ jobs: - name: Lint Go uses: golangci/golangci-lint-action@3cfe3a4abbb849e10058ce4af15d205b6da42804 # v4.0.0 with: - version: v1.59.1 + version: v1.62.0 # We already cache these directories in setup-go skip-pkg-cache: true skip-build-cache: true diff --git a/.tool-versions b/.tool-versions index 70b6d01ce14..49f7ef749d1 100644 --- a/.tool-versions +++ b/.tool-versions @@ -1,4 +1,4 @@ -golang 1.22.8 +golang 1.23.3 mockery 2.46.3 nodejs 20.13.1 pnpm 9.4.0 diff --git a/core/chainlink.Dockerfile b/core/chainlink.Dockerfile index 753172a1a9f..82858f3437c 100644 --- a/core/chainlink.Dockerfile +++ b/core/chainlink.Dockerfile @@ -1,5 +1,5 @@ # Build image: Chainlink binary -FROM golang:1.22-bullseye as buildgo +FROM golang:1.23-bullseye as buildgo RUN go version WORKDIR /chainlink @@ -31,7 +31,7 @@ RUN go list -m -f "{{.Dir}}" github.com/smartcontractkit/chainlink-feeds | xargs RUN go list -m -f "{{.Dir}}" github.com/smartcontractkit/chainlink-solana | xargs -I % ln -s % /chainlink-solana # Build image: Plugins -FROM golang:1.22-bullseye as buildplugins +FROM golang:1.23-bullseye as buildplugins RUN go version WORKDIR /chainlink-feeds diff --git a/core/cmd/admin_commands.go b/core/cmd/admin_commands.go index 7bde0ec23fb..0af851d2c06 100644 --- a/core/cmd/admin_commands.go +++ b/core/cmd/admin_commands.go @@ -374,6 +374,7 @@ func (s *Shell) Profile(c *cli.Context) error { } respContent := string(b) // taken from pprof.Profile https://github.com/golang/go/blob/release-branch.go1.20/src/net/http/pprof/pprof.go#L133 + // note: no longer triggers as of 1.23 if strings.Contains(respContent, "profile duration exceeds server's WriteTimeout") { errs <- fmt.Errorf("%w: %s", ErrProfileTooLong, respContent) } else { diff --git a/core/cmd/shell_remote_test.go b/core/cmd/shell_remote_test.go index f4661a58e82..0bf5067d364 100644 --- a/core/cmd/shell_remote_test.go +++ b/core/cmd/shell_remote_test.go @@ -463,36 +463,6 @@ func TestShell_ChangePassword(t *testing.T) { require.Contains(t, err.Error(), "Unauthorized") } -func TestShell_Profile_InvalidSecondsParam(t *testing.T) { - t.Parallel() - - app := startNewApplicationV2(t, nil) - u := cltest.NewUserWithSession(t, app.AuthenticationProvider()) - enteredStrings := []string{u.Email, cltest.Password} - prompter := &cltest.MockCountingPrompter{T: t, EnteredStrings: enteredStrings} - - client := app.NewAuthenticatingShell(prompter) - - set := flag.NewFlagSet("test", 0) - flagSetApplyFromAction(client.RemoteLogin, set, "") - - require.NoError(t, set.Set("file", "../internal/fixtures/apicredentials")) - require.NoError(t, set.Set("bypass-version-check", "true")) - - c := cli.NewContext(nil, set, nil) - err := client.RemoteLogin(c) - require.NoError(t, err) - - // pick a value larger than the default http service write timeout - d := app.Config.WebServer().HTTPWriteTimeout() + 2*time.Second - set.Uint("seconds", uint(d.Seconds()), "") - tDir := t.TempDir() - set.String("output_dir", tDir, "") - err = client.Profile(cli.NewContext(nil, set, nil)) - wantErr := cmd.ErrProfileTooLong - require.ErrorAs(t, err, &wantErr) -} - func TestShell_Profile(t *testing.T) { t.Parallel() diff --git a/core/platform/monitoring.go b/core/platform/monitoring.go index 30221db240c..b5e12ace80c 100644 --- a/core/platform/monitoring.go +++ b/core/platform/monitoring.go @@ -1,5 +1,10 @@ package platform +import ( + "iter" + "slices" +) + // Observability keys const ( KeyCapabilityID = "capabilityID" @@ -12,4 +17,13 @@ const ( KeyStepRef = "stepRef" ) -var OrderedLabelKeys = []string{KeyStepRef, KeyStepID, KeyTriggerID, KeyCapabilityID, KeyWorkflowExecutionID, KeyWorkflowID} +func LabelKeysSorted() iter.Seq[string] { + return slices.Values([]string{ + KeyStepRef, + KeyStepID, + KeyTriggerID, + KeyCapabilityID, + KeyWorkflowExecutionID, + KeyWorkflowID, + }) +} diff --git a/core/scripts/go.mod b/core/scripts/go.mod index 8d0bd34b6c3..b8439a14f46 100644 --- a/core/scripts/go.mod +++ b/core/scripts/go.mod @@ -1,6 +1,6 @@ module github.com/smartcontractkit/chainlink/core/scripts -go 1.22.8 +go 1.23 // Make sure we're working with the latest chainlink libs replace github.com/smartcontractkit/chainlink/v2 => ../../ diff --git a/core/services/keystore/keys/ocrkey/key_v2_test.go b/core/services/keystore/keys/ocrkey/key_v2_test.go new file mode 100644 index 00000000000..3fd2417b704 --- /dev/null +++ b/core/services/keystore/keys/ocrkey/key_v2_test.go @@ -0,0 +1,38 @@ +package ocrkey_test + +import ( + "math/big" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ocrkey" +) + +func assertKeyBundlesNotEqual(t *testing.T, pk1 ocrkey.KeyV2, pk2 ocrkey.KeyV2) { + assert.NotEqual(t, pk1.ID(), pk2.ID()) + assert.NotEqual(t, pk1.ExportedOnChainSigning().X, pk2.ExportedOnChainSigning().X) + assert.NotEqual(t, pk1.ExportedOnChainSigning().Y, pk2.ExportedOnChainSigning().Y) + assert.NotEqual(t, pk1.ExportedOnChainSigning().D, pk2.ExportedOnChainSigning().D) + assert.NotEqual(t, pk1.ExportedOffChainSigning().PublicKey(), pk2.ExportedOffChainSigning().PublicKey()) + assert.NotEqual(t, pk1.ExportedOffChainEncryption(), pk2.ExportedOffChainEncryption()) +} + +func TestOCRKeys_New(t *testing.T) { + t.Parallel() + pk1, err := ocrkey.NewV2() + require.NoError(t, err) + pk2, err := ocrkey.NewV2() + require.NoError(t, err) + pk3, err := ocrkey.NewV2() + require.NoError(t, err) + assertKeyBundlesNotEqual(t, pk1, pk2) + assertKeyBundlesNotEqual(t, pk1, pk3) + assertKeyBundlesNotEqual(t, pk2, pk3) +} +func TestOCRKeys_Raw_Key(t *testing.T) { + t.Parallel() + key := ocrkey.MustNewV2XXXTestingOnly(big.NewInt(1)) + require.Equal(t, key.ID(), key.Raw().Key().ID()) +} diff --git a/core/services/workflows/engine.go b/core/services/workflows/engine.go index b958e171c0c..23af3ed3d28 100644 --- a/core/services/workflows/engine.go +++ b/core/services/workflows/engine.go @@ -1294,7 +1294,7 @@ func (e *workflowError) Error() string { } // prefix the error with the labels - for _, label := range platform.OrderedLabelKeys { + for label := range platform.LabelKeysSorted() { // This will silently ignore any labels that are not present in the map // are we ok with this? if value, ok := e.labels[label]; ok { diff --git a/deployment/go.mod b/deployment/go.mod index 6320167168b..d67615f736f 100644 --- a/deployment/go.mod +++ b/deployment/go.mod @@ -1,6 +1,6 @@ module github.com/smartcontractkit/chainlink/deployment -go 1.22.8 +go 1.23 // Make sure we're working with the latest chainlink libs replace github.com/smartcontractkit/chainlink/v2 => ../ diff --git a/go.mod b/go.mod index 23db187326b..e7c1468bfbc 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/smartcontractkit/chainlink/v2 -go 1.22.8 +go 1.23 require ( github.com/Depado/ginprom v1.8.0 diff --git a/integration-tests/.tool-versions b/integration-tests/.tool-versions index e85f4cdc4e5..5d980451979 100644 --- a/integration-tests/.tool-versions +++ b/integration-tests/.tool-versions @@ -1,4 +1,4 @@ -golang 1.22.8 +golang 1.23.3 k3d 5.4.6 kubectl 1.25.5 nodejs 20.13.1 diff --git a/integration-tests/actions/actions.go b/integration-tests/actions/actions.go index 76e6cbd4185..53283967976 100644 --- a/integration-tests/actions/actions.go +++ b/integration-tests/actions/actions.go @@ -350,12 +350,13 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa return nil, err } - var gasLimit int64 - gasLimitRaw, err := client.EstimateGasLimitForFundTransfer(fromAddress, payload.ToAddress, payload.Amount) + gasLimit, err := client.EstimateGasLimitForFundTransfer(fromAddress, payload.ToAddress, payload.Amount) if err != nil { - gasLimit = client.Cfg.Network.TransferGasFee - } else { - gasLimit = int64(gasLimitRaw) + transferGasFee := client.Cfg.Network.TransferGasFee + if transferGasFee < 0 { + return nil, fmt.Errorf("negative transfer gas fee: %d", transferGasFee) + } + gasLimit = uint64(transferGasFee) } gasPrice := big.NewInt(0) @@ -363,14 +364,17 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa gasTipCap := big.NewInt(0) if payload.GasLimit != nil { - gasLimit = *payload.GasLimit + if *payload.GasLimit < 0 { + return nil, fmt.Errorf("negative gas limit: %d", *payload.GasLimit) + } + gasLimit = uint64(*payload.GasLimit) } if client.Cfg.Network.EIP1559DynamicFees { // if any of the dynamic fees are not set, we need to either estimate them or read them from config if payload.GasFeeCap == nil || payload.GasTipCap == nil { // estimation or config reading happens here - txOptions := client.NewTXOpts(seth.WithGasLimit(uint64(gasLimit))) + txOptions := client.NewTXOpts(seth.WithGasLimit(gasLimit)) gasFeeCap = txOptions.GasFeeCap gasTipCap = txOptions.GasTipCap } @@ -385,7 +389,7 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa } } else { if payload.GasPrice == nil { - txOptions := client.NewTXOpts(seth.WithGasLimit(uint64(gasLimit))) + txOptions := client.NewTXOpts(seth.WithGasLimit(gasLimit)) gasPrice = txOptions.GasPrice } else { gasPrice = payload.GasPrice @@ -399,7 +403,7 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa Nonce: nonce, To: &payload.ToAddress, Value: payload.Amount, - Gas: uint64(gasLimit), + Gas: gasLimit, GasFeeCap: gasFeeCap, GasTipCap: gasTipCap, } @@ -408,7 +412,7 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa Nonce: nonce, To: &payload.ToAddress, Value: payload.Amount, - Gas: uint64(gasLimit), + Gas: gasLimit, GasPrice: gasPrice, } } @@ -429,7 +433,7 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa Str("To", payload.ToAddress.Hex()). Str("Amount (wei/ether)", fmt.Sprintf("%s/%s", payload.Amount, conversions.WeiToEther(payload.Amount).Text('f', -1))). Uint64("Nonce", nonce). - Int64("Gas Limit", gasLimit). + Uint64("Gas Limit", gasLimit). Str("Gas Price", gasPrice.String()). Str("Gas Fee Cap", gasFeeCap.String()). Str("Gas Tip Cap", gasTipCap.String()). @@ -449,7 +453,7 @@ func SendFunds(logger zerolog.Logger, client *seth.Client, payload FundsToSendPa Str("TxHash", signedTx.Hash().String()). Str("Amount (wei/ether)", fmt.Sprintf("%s/%s", payload.Amount, conversions.WeiToEther(payload.Amount).Text('f', -1))). Uint64("Nonce", nonce). - Int64("Gas Limit", gasLimit). + Uint64("Gas Limit", gasLimit). Str("Gas Price", gasPrice.String()). Str("Gas Fee Cap", gasFeeCap.String()). Str("Gas Tip Cap", gasTipCap.String()). @@ -1038,7 +1042,7 @@ func GetLatestFinalizedBlockHeader(ctx context.Context, client *seth.Client, net } latestBlockNumber := header.Number.Uint64() finalizedBlockNumber := latestBlockNumber - network.FinalityDepth - return client.Client.HeaderByNumber(ctx, big.NewInt(int64(finalizedBlockNumber))) + return client.Client.HeaderByNumber(ctx, new(big.Int).SetUint64(finalizedBlockNumber)) } // SendLinkFundsToDeploymentAddresses sends LINK token to all addresses, but the root one, from the root address. It uses @@ -1241,7 +1245,7 @@ func GetStalenessReportCleanupFn(t *testing.T, logger zerolog.Logger, chainClien endBlock, err := chainClient.Client.BlockNumber(context.Background()) require.NoError(t, err, "Failed to get end block") - total, ok, reverted, stale, err := GenerateUpkeepReport(t, chainClient, big.NewInt(int64(startBlock)), big.NewInt(int64(endBlock)), registry, registryVersion) + total, ok, reverted, stale, err := GenerateUpkeepReport(t, chainClient, new(big.Int).SetUint64(startBlock), new(big.Int).SetUint64(endBlock), registry, registryVersion) require.NoError(t, err, "Failed to get staleness data") if stale > 0 || reverted > 0 { logger.Warn().Int("Total upkeeps", total).Int("Successful upkeeps", ok).Int("Reverted Upkeeps", reverted).Int("Stale Upkeeps", stale).Msg("Staleness data") diff --git a/integration-tests/actions/automationv2/actions.go b/integration-tests/actions/automationv2/actions.go index 1f17634e58d..25033201dd1 100644 --- a/integration-tests/actions/automationv2/actions.go +++ b/integration-tests/actions/automationv2/actions.go @@ -7,6 +7,7 @@ import ( "encoding/json" "errors" "fmt" + "math" "math/big" "strings" "testing" @@ -642,10 +643,15 @@ func calculateOCR2ConfigArgs(a *AutomationTest, S []int, oracleIdentities []conf MaxUpkeepBatchSize: a.PluginConfig.MaxUpkeepBatchSize, }) + rMax := a.PublicConfig.RMax + if rMax > math.MaxUint8 { + panic(fmt.Errorf("rmax overflows uint8: %d", rMax)) + } + return ocr2.ContractSetConfigArgsForTests( a.PublicConfig.DeltaProgress, a.PublicConfig.DeltaResend, a.PublicConfig.DeltaRound, a.PublicConfig.DeltaGrace, - a.PublicConfig.DeltaStage, uint8(a.PublicConfig.RMax), + a.PublicConfig.DeltaStage, uint8(rMax), S, oracleIdentities, offC, nil, a.PublicConfig.MaxDurationQuery, a.PublicConfig.MaxDurationObservation, diff --git a/integration-tests/actions/keeper_helpers.go b/integration-tests/actions/keeper_helpers.go index 0966e0b486e..1562e363f8c 100644 --- a/integration-tests/actions/keeper_helpers.go +++ b/integration-tests/actions/keeper_helpers.go @@ -670,15 +670,14 @@ Distribute your funds across multiple private keys and update your configuration func GetAndAssertCorrectConcurrency(client *seth.Client, minConcurrency int) (int, error) { concurrency := client.Cfg.GetMaxConcurrency() - var msg string - if client.Cfg.IsSimulatedNetwork() { - msg = fmt.Sprintf(INSUFFICIENT_EPHEMERAL_KEYS, concurrency) - } else { - msg = fmt.Sprintf(INSUFFICIENT_STATIC_KEYS, concurrency) - } - if concurrency < minConcurrency { - return 0, fmt.Errorf(msg) + var err error + if client.Cfg.IsSimulatedNetwork() { + err = fmt.Errorf(INSUFFICIENT_EPHEMERAL_KEYS, concurrency) + } else { + err = fmt.Errorf(INSUFFICIENT_STATIC_KEYS, concurrency) + } + return 0, err } return concurrency, nil diff --git a/integration-tests/actions/refund.go b/integration-tests/actions/refund.go index 0eb83e736e5..e9910928c6c 100644 --- a/integration-tests/actions/refund.go +++ b/integration-tests/actions/refund.go @@ -5,6 +5,7 @@ import ( "crypto/ecdsa" "encoding/json" "fmt" + "math" "math/big" "regexp" "strconv" @@ -343,6 +344,9 @@ func returnAllFundsIfPossible(log zerolog.Logger, sethClient *seth.Client, fromP if err != nil { gasLimit = sethClient.Cfg.Network.TransferGasFee } else { + if gasLimitRaw > math.MaxInt64 { + return fmt.Errorf("gas limit overflows int64: %d", gasLimitRaw) + } gasLimit = int64(gasLimitRaw) } diff --git a/integration-tests/actions/vrf/vrfv2plus/setup_steps.go b/integration-tests/actions/vrf/vrfv2plus/setup_steps.go index 3d3a549458a..c997bb837c7 100644 --- a/integration-tests/actions/vrf/vrfv2plus/setup_steps.go +++ b/integration-tests/actions/vrf/vrfv2plus/setup_steps.go @@ -105,7 +105,7 @@ func SetupVRFV2_5Environment( return nil, nil, nil, err } l.Info().Str("Coordinator", vrfContracts.CoordinatorV2Plus.Address()).Msg("Registering Proving Key") - provingKey, err := VRFV2_5RegisterProvingKey(vrfKey, vrfContracts.CoordinatorV2Plus, uint64(assets.GWei(*configGeneral.CLNodeMaxGasPriceGWei).Int64())) + provingKey, err := VRFV2_5RegisterProvingKey(vrfKey, vrfContracts.CoordinatorV2Plus, assets.GWei(*configGeneral.CLNodeMaxGasPriceGWei).ToInt().Uint64()) if err != nil { return nil, nil, nil, fmt.Errorf(vrfcommon.ErrGenericFormat, vrfcommon.ErrRegisteringProvingKey, err) } diff --git a/integration-tests/ccip-tests/actions/ccip_helpers.go b/integration-tests/ccip-tests/actions/ccip_helpers.go index c24ae2ecd54..d0587dad789 100644 --- a/integration-tests/ccip-tests/actions/ccip_helpers.go +++ b/integration-tests/ccip-tests/actions/ccip_helpers.go @@ -631,7 +631,11 @@ func (ccipModule *CCIPCommon) UpdateTokenPricesAtRegularInterval(ctx context.Con aggregators = append(aggregators, contract) } go func(aggregators []*contracts.MockAggregator) { - rand.NewSource(uint64(time.Now().UnixNano())) + now := time.Now().UnixNano() + if now < 0 { + panic(fmt.Errorf("negative timestamp: %d", now)) + } + rand.NewSource(uint64(now)) ticker := time.NewTicker(interval) for { select { @@ -1661,7 +1665,11 @@ func (sourceCCIP *SourceCCIPModule) IsPastRequestTriggeredWithinTimeframe(ctx co if err != nil { return nil, fmt.Errorf("error while getting average source block time. Error: %w", err) } - filterFromBlock := latestBlock - uint64(timeframe.Duration()/avgBlockTime) + blocks := timeframe.Duration() / avgBlockTime + if blocks < 0 { + return nil, fmt.Errorf("negative blocks: %d", blocks) + } + filterFromBlock := latestBlock - uint64(blocks) //nolint:gosec // G115 false positive onRampContract, err := evm_2_evm_onramp.NewEVM2EVMOnRamp(common.HexToAddress(sourceCCIP.OnRamp.EthAddress.Hex()), sourceCCIP.Common.ChainClient.Backend()) @@ -1678,7 +1686,7 @@ func (sourceCCIP *SourceCCIPModule) IsPastRequestTriggeredWithinTimeframe(ctx co _ = iterator.Close() }() if iterator.Next() { - hdr, err := sourceCCIP.Common.ChainClient.HeaderByNumber(context.Background(), big.NewInt(int64(iterator.Event.Raw.BlockNumber))) + hdr, err := sourceCCIP.Common.ChainClient.HeaderByNumber(context.Background(), new(big.Int).SetUint64(iterator.Event.Raw.BlockNumber)) if err != nil { return nil, fmt.Errorf("error getting header for block: %d, Error: %w", iterator.Event.Raw.BlockNumber, err) } @@ -4157,7 +4165,7 @@ func (c *CCIPTestEnv) SetUpNodeKeysAndFund( nodeFund *big.Float, chains []blockchain.EVMClient, ) error { - if c.CLNodes == nil || len(c.CLNodes) == 0 { + if len(c.CLNodes) == 0 { return fmt.Errorf("no chainlink nodes to setup") } var chainlinkNodes []*nodeclient.ChainlinkClient diff --git a/integration-tests/ccip-tests/actions/reorg_helpers.go b/integration-tests/ccip-tests/actions/reorg_helpers.go index 017b8ffab69..2ce9639613b 100644 --- a/integration-tests/ccip-tests/actions/reorg_helpers.go +++ b/integration-tests/ccip-tests/actions/reorg_helpers.go @@ -27,16 +27,16 @@ type ReorgConfig struct { // DstGethHTTPURL dest chain Geth HTTP URL DstGethHTTPURL string // SrcFinalityDepth source chain finality depth - SrcFinalityDepth uint64 + SrcFinalityDepth int // DstGethHTTPURL dest chain finality depth - DstFinalityDepth uint64 + DstFinalityDepth int // FinalityDelta blocks to rewind below or above finality FinalityDelta int } // Validate validates ReorgConfig params func (rc *ReorgConfig) Validate() error { - if rc.FinalityDelta >= int(rc.SrcFinalityDepth) || rc.FinalityDelta >= int(rc.DstFinalityDepth) { + if rc.FinalityDelta >= rc.SrcFinalityDepth || rc.FinalityDelta >= rc.DstFinalityDepth { return fmt.Errorf( "finality delta can't be higher than source or dest chain finality, delta: %d, src: %d, dst: %d", rc.FinalityDelta, rc.SrcFinalityDepth, rc.DstFinalityDepth, diff --git a/integration-tests/ccip-tests/contracts/contract_models.go b/integration-tests/ccip-tests/contracts/contract_models.go index 83fe12a60a6..15b5ed8cd0d 100644 --- a/integration-tests/ccip-tests/contracts/contract_models.go +++ b/integration-tests/ccip-tests/contracts/contract_models.go @@ -2241,7 +2241,11 @@ func (a *MockAggregator) UpdateRoundData(answer *big.Int, minP, maxP *int) error // if answer is nil, we calculate the answer with random percentage (within the provided range) of latest answer if answer == nil { - rand.Seed(uint64(time.Now().UnixNano())) + now := time.Now().UnixNano() + if now < 0 { + return fmt.Errorf("negative timestamp: %d", now) + } + rand.Seed(uint64(now)) randomNumber := rand.Intn(pointer.GetInt(maxP)-pointer.GetInt(minP)+1) + pointer.GetInt(minP) // answer = previous round answer + (previous round answer * random percentage) answer = new(big.Int).Add(a.Answer, new(big.Int).Div(new(big.Int).Mul(a.Answer, big.NewInt(int64(randomNumber))), big.NewInt(100))) diff --git a/integration-tests/ccip-tests/smoke/ccip_test.go b/integration-tests/ccip-tests/smoke/ccip_test.go index 08054459481..a729bd5daec 100644 --- a/integration-tests/ccip-tests/smoke/ccip_test.go +++ b/integration-tests/ccip-tests/smoke/ccip_test.go @@ -2,6 +2,7 @@ package smoke import ( "fmt" + "math" "math/big" "testing" "time" @@ -874,8 +875,8 @@ func TestSmokeCCIPReorgBelowFinality(t *testing.T) { require.NoError(t, err, "Send requests failed") rs := SetupReorgSuite(t, &log, setUpOutput) // run below finality reorg in both source and destination chain - blocksBackSrc := int(rs.Cfg.SrcFinalityDepth) - rs.Cfg.FinalityDelta - blocksBackDst := int(rs.Cfg.DstFinalityDepth) - rs.Cfg.FinalityDelta + blocksBackSrc := rs.Cfg.SrcFinalityDepth - rs.Cfg.FinalityDelta + blocksBackDst := rs.Cfg.DstFinalityDepth - rs.Cfg.FinalityDelta rs.RunReorg(rs.DstClient, blocksBackSrc, "Source", 2*time.Second) rs.RunReorg(rs.DstClient, blocksBackDst, "Destination", 2*time.Second) time.Sleep(1 * time.Minute) @@ -930,10 +931,10 @@ func performAboveFinalityReorgAndValidate(t *testing.T, network string) { logPollerName := "" if network == "Destination" { logPollerName = fmt.Sprintf("EVM.%d.LogPoller", lane.DestChain.GetChainID()) - rs.RunReorg(rs.DstClient, int(rs.Cfg.DstFinalityDepth)+rs.Cfg.FinalityDelta, network, 2*time.Second) + rs.RunReorg(rs.DstClient, rs.Cfg.DstFinalityDepth+rs.Cfg.FinalityDelta, network, 2*time.Second) } else { logPollerName = fmt.Sprintf("EVM.%d.LogPoller", lane.SourceChain.GetChainID()) - rs.RunReorg(rs.SrcClient, int(rs.Cfg.SrcFinalityDepth)+rs.Cfg.FinalityDelta, network, 2*time.Second) + rs.RunReorg(rs.SrcClient, rs.Cfg.SrcFinalityDepth+rs.Cfg.FinalityDelta, network, 2*time.Second) } clNodes := setUpOutput.Env.CLNodes // assert every node is detecting the reorg (LogPollInterval is set as 1s for faster detection) @@ -1123,17 +1124,25 @@ func testOffRampRateLimits(t *testing.T, rateLimiterConfig contracts.RateLimiter // SetupReorgSuite defines the setup required to perform re-org step func SetupReorgSuite(t *testing.T, lggr *zerolog.Logger, setupOutput *testsetups.CCIPTestSetUpOutputs) *actions.ReorgSuite { - var finalitySrc uint64 - var finalityDst uint64 + var finalitySrc int + var finalityDst int if setupOutput.Cfg.SelectedNetworks[0].FinalityTag { finalitySrc = 10 } else { - finalitySrc = setupOutput.Cfg.SelectedNetworks[0].FinalityDepth + finalityDepth := setupOutput.Cfg.SelectedNetworks[0].FinalityDepth + if finalityDepth > math.MaxInt { + t.Fatalf("source finality depth overflows int: %d", finalityDepth) + } + finalitySrc = int(finalityDepth) } if setupOutput.Cfg.SelectedNetworks[1].FinalityTag { finalityDst = 10 } else { - finalityDst = setupOutput.Cfg.SelectedNetworks[1].FinalityDepth + finalityDepth := setupOutput.Cfg.SelectedNetworks[1].FinalityDepth + if finalityDepth > math.MaxInt { + t.Fatalf("destination finality depth overflows int: %d", finalityDepth) + } + finalityDst = int(finalityDepth) } var srcGethHTTPURL, dstGethHTTPURL string if setupOutput.Env.LocalCluster != nil { diff --git a/integration-tests/ccip-tests/testconfig/global.go b/integration-tests/ccip-tests/testconfig/global.go index 725b1e90a4f..4caa8a9ac00 100644 --- a/integration-tests/ccip-tests/testconfig/global.go +++ b/integration-tests/ccip-tests/testconfig/global.go @@ -584,7 +584,7 @@ func (c *ChainlinkDeployment) Validate() error { if c.NoOfNodes == nil { return errors.New("chainlink config is invalid, NoOfNodes should be specified") } - if c.Nodes != nil && len(c.Nodes) > 0 { + if len(c.Nodes) > 0 { noOfNodes := pointer.GetInt(c.NoOfNodes) if noOfNodes != len(c.Nodes) { return errors.New("chainlink config is invalid, NoOfNodes and Nodes length mismatch") diff --git a/integration-tests/ccip-tests/testsetups/ccip.go b/integration-tests/ccip-tests/testsetups/ccip.go index eee424d50d1..52901c4161a 100644 --- a/integration-tests/ccip-tests/testsetups/ccip.go +++ b/integration-tests/ccip-tests/testsetups/ccip.go @@ -3,6 +3,7 @@ package testsetups import ( "context" "fmt" + "math" "math/big" "math/rand" "os" @@ -234,6 +235,9 @@ func (c *CCIPTestConfig) SetNetworkPairs(lggr zerolog.Logger) error { var chainIDs []int64 existingChainIDs := make(map[uint64]struct{}) for _, net := range c.SelectedNetworks { + if net.ChainID < 0 { + return fmt.Errorf("negative chain ID: %d", net.ChainID) + } existingChainIDs[uint64(net.ChainID)] = struct{}{} } for _, id := range chainselectors.TestChainIds() { @@ -241,6 +245,9 @@ func (c *CCIPTestConfig) SetNetworkPairs(lggr zerolog.Logger) error { if _, exists := existingChainIDs[id]; exists { continue } + if id > math.MaxInt64 { + return fmt.Errorf("chain ID overflows int64: %d", id) + } chainIDs = append(chainIDs, int64(id)) } for i := 0; i < c.TestGroupInput.NoOfNetworks-actualNoOfNetworks; i++ { @@ -300,7 +307,7 @@ func (c *CCIPTestConfig) SetNetworkPairs(lggr zerolog.Logger) error { var newNetworkPairs []NetworkPair denselyConnectedNetworks := make(map[string]struct{}) // if densely connected networks are provided, choose all the network pairs containing the networks mentioned in the list for DenselyConnectedNetworkChainIds - if c.TestGroupInput.DenselyConnectedNetworkChainIds != nil && len(c.TestGroupInput.DenselyConnectedNetworkChainIds) > 0 { + if len(c.TestGroupInput.DenselyConnectedNetworkChainIds) > 0 { for _, n := range c.TestGroupInput.DenselyConnectedNetworkChainIds { denselyConnectedNetworks[n] = struct{}{} } diff --git a/integration-tests/ccip-tests/testsetups/test_helpers.go b/integration-tests/ccip-tests/testsetups/test_helpers.go index ea57f056945..c65ea5ede9b 100644 --- a/integration-tests/ccip-tests/testsetups/test_helpers.go +++ b/integration-tests/ccip-tests/testsetups/test_helpers.go @@ -230,6 +230,9 @@ func NewLocalDevEnvironmentWithRMN( func MustNetworksToRPCMap(evmNetworks []*blockchain.EVMNetwork) map[uint64]string { rpcs := make(map[uint64]string) for _, network := range evmNetworks { + if network.ChainID < 0 { + panic(fmt.Errorf("negative chain ID: %d", network.ChainID)) + } sel, err := chainsel.SelectorFromChainId(uint64(network.ChainID)) if err != nil { panic(err) @@ -543,6 +546,9 @@ func FundNodes(t *testing.T, lggr zerolog.Logger, env *test_env.CLClusterTestEnv require.NoError(t, err, "Error getting seth client for network %s", evmNetwork.Name) require.Greater(t, len(sethClient.PrivateKeys), 0, seth.ErrNoKeyLoaded) privateKey := sethClient.PrivateKeys[0] + if evmNetwork.ChainID < 0 { + t.Fatalf("negative chain ID: %d", evmNetwork.ChainID) + } for _, node := range nodes { nodeAddr, ok := node.AccountAddr[uint64(evmNetwork.ChainID)] require.True(t, ok, "Account address not found for chain %d", evmNetwork.ChainID) @@ -592,6 +598,9 @@ func CreateChainConfigFromNetworks( if len(privateEthereumNetworks) == 0 { for _, net := range evmNetworks { chainId := net.ChainID + if chainId < 0 { + t.Fatalf("negative chain ID: %d", chainId) + } chainName, err := chainsel.NameFromChainId(uint64(chainId)) require.NoError(t, err, "Error getting chain name") pvtKeyStr, exists := networkPvtKeys[chainId] @@ -624,6 +633,9 @@ func CreateChainConfigFromNetworks( require.NoError(t, err) deployer, err := bind.NewKeyedTransactorWithChainID(pvtKey, big.NewInt(int64(chainId))) require.NoError(t, err) + if chainId < 0 { + t.Fatalf("negative chain ID: %d", chainId) + } chains = append(chains, devenv.ChainConfig{ ChainID: uint64(chainId), ChainName: chainName, diff --git a/integration-tests/ccip-tests/types/config/node/core.go b/integration-tests/ccip-tests/types/config/node/core.go index 5c9defbbb51..404719e31e1 100644 --- a/integration-tests/ccip-tests/types/config/node/core.go +++ b/integration-tests/ccip-tests/types/config/node/core.go @@ -3,6 +3,7 @@ package node import ( "bytes" "fmt" + "math" "math/big" "github.com/smartcontractkit/chainlink-testing-framework/lib/blockchain" @@ -54,6 +55,9 @@ func WithPrivateEVMs(networks []blockchain.EVMNetwork, commonChainConfig *evmcfg } } if evmConfig.Chain.FinalityDepth == nil && network.FinalityDepth > 0 { + if network.FinalityDepth > math.MaxUint32 { + panic(fmt.Errorf("finality depth overflows uint32: %d", network.FinalityDepth)) + } evmConfig.Chain.FinalityDepth = ptr.Ptr(uint32(network.FinalityDepth)) } if evmConfig.Chain.FinalityTagEnabled == nil && network.FinalityTag { diff --git a/integration-tests/contracts/ethereum_contracts_automation.go b/integration-tests/contracts/ethereum_contracts_automation.go index 3e18fe177f0..1a4624c2dd3 100644 --- a/integration-tests/contracts/ethereum_contracts_automation.go +++ b/integration-tests/contracts/ethereum_contracts_automation.go @@ -2809,14 +2809,14 @@ type AutomationConsumerBenchmarkUpkeepObserver struct { firstBlockNum uint64 // Records the number of the first block that came in lastBlockNum uint64 // Records the number of the last block that came in - blockRange int64 // How many blocks to watch upkeeps for + blockRange uint64 // How many blocks to watch upkeeps for upkeepSLA int64 // SLA after which an upkeep is counted as 'missed' metricsReporter *testreporters.KeeperBenchmarkTestReporter // Testreporter to track results upkeepIndex int64 firstEligibleBuffer int64 // State variables, changes as we get blocks - blocksSinceSubscription int64 // How many blocks have passed since subscribing + blocksSinceSubscription uint64 // How many blocks have passed since subscribing blocksSinceEligible int64 // How many blocks have come in since upkeep has been eligible for check countEligible int64 // Number of times the upkeep became eligible countMissed int64 // Number of times we missed SLA for performing upkeep @@ -2832,7 +2832,7 @@ func NewAutomationConsumerBenchmarkUpkeepObserver( contract AutomationConsumerBenchmark, registry KeeperRegistry, upkeepID *big.Int, - blockRange int64, + blockRange uint64, upkeepSLA int64, metricsReporter *testreporters.KeeperBenchmarkTestReporter, upkeepIndex int64, @@ -2906,7 +2906,7 @@ func (o *AutomationConsumerBenchmarkUpkeepObserver) ReceiveHeader(receivedHeader o.blocksSinceEligible = 0 } - isEligible, err := o.instance.CheckEligible(context.Background(), big.NewInt(o.upkeepIndex), big.NewInt(o.blockRange), big.NewInt(o.firstEligibleBuffer)) + isEligible, err := o.instance.CheckEligible(context.Background(), big.NewInt(o.upkeepIndex), new(big.Int).SetUint64(o.blockRange), big.NewInt(o.firstEligibleBuffer)) if err != nil { return false, err } @@ -2924,7 +2924,7 @@ func (o *AutomationConsumerBenchmarkUpkeepObserver) ReceiveHeader(receivedHeader o.blocksSinceEligible++ } - if o.blocksSinceSubscription >= o.blockRange || int64(o.lastBlockNum-o.firstBlockNum) >= o.blockRange { + if o.blocksSinceSubscription >= o.blockRange || o.lastBlockNum-o.firstBlockNum >= o.blockRange { if o.blocksSinceEligible > 0 { if o.blocksSinceEligible > o.upkeepSLA { o.l.Warn(). @@ -2953,7 +2953,7 @@ func (o *AutomationConsumerBenchmarkUpkeepObserver) ReceiveHeader(receivedHeader Str("Upkeep_ID", o.upkeepID.String()). Str("Contract_Address", o.instance.Address()). Int64("Upkeeps_Performed", upkeepCount.Int64()). - Int64("Total_Blocks_Watched", o.blocksSinceSubscription). + Uint64("Total_Blocks_Watched", o.blocksSinceSubscription). Str("Registry_Address", o.registry.Address()). Msg("Finished Watching for Upkeeps") diff --git a/integration-tests/docker/test_env/test_env_builder.go b/integration-tests/docker/test_env/test_env_builder.go index 610c3e29e1e..cdce826f2c2 100644 --- a/integration-tests/docker/test_env/test_env_builder.go +++ b/integration-tests/docker/test_env/test_env_builder.go @@ -2,6 +2,7 @@ package test_env import ( "fmt" + "math" "os" "path/filepath" "slices" @@ -279,10 +280,16 @@ func (b *CLTestEnvBuilder) Build() (*CLClusterTestEnv, error) { processFn := func(log logstream.LogContent, count *int) error { countSoFar := count + if *countSoFar < 0 { + return fmt.Errorf("negative count: %d", *countSoFar) + } newCount, err := testreporters.ScanLogLine(b.l, string(log.Content), b.chainlinkNodeLogScannerSettings.FailingLogLevel, uint(*countSoFar), b.chainlinkNodeLogScannerSettings.Threshold, b.chainlinkNodeLogScannerSettings.AllowedMessages) if err != nil { return err } + if newCount > math.MaxInt { + return fmt.Errorf("new count overflows int: %d", newCount) + } *count = int(newCount) return nil } @@ -494,7 +501,7 @@ func (b *CLTestEnvBuilder) Build() (*CLClusterTestEnv, error) { b.te.EVMNetworks = append(b.te.EVMNetworks, &networkConfig) if b.isEVM { - if b.evmNetworkOption != nil && len(b.evmNetworkOption) > 0 { + if len(b.evmNetworkOption) > 0 { for _, fn := range b.evmNetworkOption { fn(&networkConfig) } diff --git a/integration-tests/go.mod b/integration-tests/go.mod index 7f59031bbe5..bb601a61444 100644 --- a/integration-tests/go.mod +++ b/integration-tests/go.mod @@ -1,6 +1,6 @@ module github.com/smartcontractkit/chainlink/integration-tests -go 1.22.8 +go 1.23 // Make sure we're working with the latest chainlink libs replace github.com/smartcontractkit/chainlink/v2 => ../ diff --git a/integration-tests/load/functions/gateway.go b/integration-tests/load/functions/gateway.go index ac5f895ac18..59443ac6e30 100644 --- a/integration-tests/load/functions/gateway.go +++ b/integration-tests/load/functions/gateway.go @@ -8,6 +8,7 @@ import ( "encoding/hex" "encoding/json" "fmt" + "math" "time" "github.com/ethereum/go-ethereum/crypto" @@ -119,6 +120,9 @@ func UploadS4Secrets(rc *resty.Client, s4Cfg *S4SecretsCfg) (uint8, uint64, erro return 0, 0, fmt.Errorf("node response was not successful") } } + if envelope.SlotID > math.MaxUint8 { + return 0, 0, fmt.Errorf("slot ID overflows uint8: %d", envelope.SlotID) + } return uint8(envelope.SlotID), envelope.Version, nil } diff --git a/integration-tests/load/functions/gateway_gun.go b/integration-tests/load/functions/gateway_gun.go index 38eddd3163e..5dd2aee4f06 100644 --- a/integration-tests/load/functions/gateway_gun.go +++ b/integration-tests/load/functions/gateway_gun.go @@ -41,14 +41,20 @@ func NewGatewaySecretsSetGun(cfg types.FunctionsTestConfig, method string, pKey func callSecretsSet(m *GatewaySecretsSetGun) *wasp.Response { randNum := strconv.Itoa(rand.Intn(100000)) - randSlot := uint(rand.Intn(5)) - version := uint64(time.Now().UnixNano()) + randSlot := rand.Intn(5) + if randSlot < 0 { + panic(fmt.Errorf("negative rand slot: %d", randSlot)) + } + version := time.Now().UnixNano() + if version < 0 { + panic(fmt.Errorf("negative timestamp: %d", version)) + } expiration := int64(60 * 60 * 1000) secret := fmt.Sprintf("{\"ltsecret\": \"%s\"}", randNum) log.Debug(). - Uint("SlotID", randSlot). + Int("SlotID", randSlot). Str("MessageID", randNum). - Uint64("Version", version). + Int64("Version", version). Int64("Expiration", expiration). Str("Secret", secret). Msg("Sending S4 envelope") @@ -73,8 +79,8 @@ func callSecretsSet(m *GatewaySecretsSetGun) *wasp.Response { MessageID: randNum, Method: "secrets_set", DonID: *cfg.Common.DONID, - S4SetSlotID: randSlot, - S4SetVersion: version, + S4SetSlotID: uint(randSlot), + S4SetVersion: uint64(version), S4SetExpirationPeriod: expiration, S4SetPayload: secrets, }) @@ -86,8 +92,14 @@ func callSecretsSet(m *GatewaySecretsSetGun) *wasp.Response { func callSecretsList(m *GatewaySecretsSetGun) *wasp.Response { randNum := strconv.Itoa(rand.Intn(100000)) - randSlot := uint(rand.Intn(5)) - version := uint64(time.Now().UnixNano()) + randSlot := rand.Intn(5) + if randSlot < 0 { + panic(fmt.Errorf("negative rand slot: %d", randSlot)) + } + version := time.Now().UnixNano() + if version < 0 { + panic(fmt.Errorf("negative timestamp: %d", version)) + } expiration := int64(60 * 60 * 1000) network := m.Cfg.GetNetworkConfig().SelectedNetworks[0] if len(m.Cfg.GetNetworkConfig().WalletKeys[network]) < 1 { @@ -101,8 +113,8 @@ func callSecretsList(m *GatewaySecretsSetGun) *wasp.Response { MessageID: randNum, Method: m.Method, DonID: *cfg.Common.DONID, - S4SetSlotID: randSlot, - S4SetVersion: version, + S4SetSlotID: uint(randSlot), + S4SetVersion: uint64(version), S4SetExpirationPeriod: expiration, }); err != nil { return &wasp.Response{Error: err.Error(), Failed: true} diff --git a/integration-tests/load/functions/setup.go b/integration-tests/load/functions/setup.go index 46c2c12921a..f018655a54e 100644 --- a/integration-tests/load/functions/setup.go +++ b/integration-tests/load/functions/setup.go @@ -123,14 +123,22 @@ func SetupLocalLoadTestEnv(globalConfig ctf_config.GlobalTestConfig, functionsCo if err != nil { return nil, fmt.Errorf("failed to generate tdh2 secrets: %w", err) } + randInt := mrand.Intn(5) + if randInt < 0 { + return nil, fmt.Errorf("negative random int: %d", randInt) + } + now := time.Now().UnixNano() + if now < 0 { + return nil, fmt.Errorf("negative timestamp: %d", now) + } slotID, slotVersion, err := UploadS4Secrets(resty.New(), &S4SecretsCfg{ GatewayURL: *cfg.Common.GatewayURL, PrivateKey: selectedNetwork.PrivateKeys[0], MessageID: strconv.Itoa(mrand.Intn(100000-1) + 1), Method: "secrets_set", DonID: *cfg.Common.DONID, - S4SetSlotID: uint(mrand.Intn(5)), - S4SetVersion: uint64(time.Now().UnixNano()), + S4SetSlotID: uint(randInt), + S4SetVersion: uint64(now), S4SetExpirationPeriod: 60 * 60 * 1000, S4SetPayload: encryptedSecrets, }) diff --git a/integration-tests/load/go.mod b/integration-tests/load/go.mod index c548b6d9159..a6cfd5bddb9 100644 --- a/integration-tests/load/go.mod +++ b/integration-tests/load/go.mod @@ -1,6 +1,6 @@ module github.com/smartcontractkit/chainlink/load-tests -go 1.22.8 +go 1.23 // Make sure we're working with the latest chainlink libs replace github.com/smartcontractkit/chainlink/v2 => ../../ @@ -28,6 +28,7 @@ require ( github.com/stretchr/testify v1.9.0 github.com/wiremock/go-wiremock v1.9.0 go.uber.org/ratelimit v0.3.1 + golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c ) require ( @@ -38,57 +39,6 @@ require ( cosmossdk.io/errors v1.0.1 // indirect cosmossdk.io/math v1.3.0 // indirect dario.cat/mergo v1.0.1 // indirect - github.com/awalterschulze/gographviz v2.0.3+incompatible // indirect - github.com/aws/aws-sdk-go-v2 v1.32.2 // indirect - github.com/aws/aws-sdk-go-v2/config v1.28.0 // indirect - github.com/aws/aws-sdk-go-v2/credentials v1.17.41 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.17 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21 // indirect - github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2 // indirect - github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.34.2 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.24.2 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.2 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.32.2 // indirect - github.com/aws/smithy-go v1.22.0 // indirect - github.com/blang/semver/v4 v4.0.0 // indirect - github.com/bytedance/sonic/loader v0.1.1 // indirect - github.com/cloudwego/base64x v0.1.4 // indirect - github.com/cloudwego/iasm v0.2.0 // indirect - github.com/coder/websocket v1.8.12 // indirect - github.com/go-viper/mapstructure/v2 v2.1.0 // indirect - github.com/golang-jwt/jwt/v4 v4.5.0 // indirect - github.com/google/gnostic-models v0.6.9-0.20230804172637-c7be7c783f49 // indirect - github.com/linxGnu/grocksdb v1.7.16 // indirect - github.com/russross/blackfriday/v2 v2.1.0 // indirect - github.com/sagikazarmark/locafero v0.4.0 // indirect - github.com/sagikazarmark/slog-shim v0.1.0 // indirect - github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec // indirect - github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f // indirect - github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2 // indirect - github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 // indirect - github.com/sourcegraph/conc v0.3.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.0.0-20240823153156-2a54df7bffb9 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.6.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.30.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.30.0 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.4.0 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.28.0 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.28.0 // indirect - go.opentelemetry.io/otel/log v0.6.0 // indirect - go.opentelemetry.io/otel/sdk/log v0.6.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.31.0 // indirect - gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect - k8s.io/apimachinery v0.31.2 // indirect -) - -// avoids ambigious imports of indirect dependencies -exclude github.com/hashicorp/consul v1.2.1 - -require ( filippo.io/edwards25519 v1.1.0 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect github.com/99designs/keyring v1.2.1 // indirect @@ -121,9 +71,24 @@ require ( github.com/atombender/go-jsonschema v0.16.1-0.20240916205339-a74cd4e2851c // indirect github.com/avast/retry-go v3.0.0+incompatible // indirect github.com/avast/retry-go/v4 v4.6.0 // indirect + github.com/awalterschulze/gographviz v2.0.3+incompatible // indirect github.com/aws/aws-sdk-go v1.54.19 // indirect + github.com/aws/aws-sdk-go-v2 v1.32.2 // indirect + github.com/aws/aws-sdk-go-v2/config v1.28.0 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.17.41 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.17 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.21 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.21 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.2 // indirect + github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.34.2 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.24.2 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.2 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.32.2 // indirect github.com/aws/constructs-go/constructs/v10 v10.4.2 // indirect github.com/aws/jsii-runtime-go v1.104.0 // indirect + github.com/aws/smithy-go v1.22.0 // indirect github.com/bahlo/generic-list-go v0.2.0 // indirect github.com/barkimedes/go-deepcopy v0.0.0-20220514131651-17c30cfc62df // indirect github.com/bboreham/go-loser v0.0.0-20230920113527-fcc2c21820a3 // indirect @@ -131,11 +96,13 @@ require ( github.com/beorn7/perks v1.0.1 // indirect github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816 // indirect github.com/bits-and-blooms/bitset v1.13.0 // indirect + github.com/blang/semver/v4 v4.0.0 // indirect github.com/blendle/zapdriver v1.3.1 // indirect github.com/btcsuite/btcd/btcec/v2 v2.3.4 // indirect github.com/buger/jsonparser v1.1.1 // indirect github.com/bytecodealliance/wasmtime-go/v23 v23.0.0 // indirect github.com/bytedance/sonic v1.11.6 // indirect + github.com/bytedance/sonic/loader v0.1.1 // indirect github.com/c2h5oh/datasize v0.0.0-20220606134207-859f65c6625b // indirect github.com/c9s/goprocinfo v0.0.0-20210130143923-c95fcf8c64a8 // indirect github.com/cdk8s-team/cdk8s-core-go/cdk8s/v2 v2.7.5 // indirect @@ -145,12 +112,15 @@ require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/chai2010/gettext-go v1.0.2 // indirect github.com/chaos-mesh/chaos-mesh/api v0.0.0-20240821051457-da69c6d9617a // indirect + github.com/cloudwego/base64x v0.1.4 // indirect + github.com/cloudwego/iasm v0.2.0 // indirect github.com/cockroachdb/errors v1.11.3 // indirect github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect github.com/cockroachdb/pebble v1.1.2 // indirect github.com/cockroachdb/redact v1.1.5 // indirect github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect + github.com/coder/websocket v1.8.12 // indirect github.com/cometbft/cometbft v0.37.5 // indirect github.com/cometbft/cometbft-db v0.8.0 // indirect github.com/confio/ics23/go v0.9.0 // indirect @@ -236,6 +206,7 @@ require ( github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/validator/v10 v10.22.0 // indirect github.com/go-redis/redis/v8 v8.11.5 // indirect + github.com/go-viper/mapstructure/v2 v2.1.0 // indirect github.com/go-webauthn/webauthn v0.9.4 // indirect github.com/go-webauthn/x v0.1.5 // indirect github.com/goccy/go-json v0.10.2 // indirect @@ -245,12 +216,14 @@ require ( github.com/gogo/googleapis v1.4.1 // indirect github.com/gogo/protobuf v1.3.3 // indirect github.com/gogo/status v1.1.1 // indirect + github.com/golang-jwt/jwt/v4 v4.5.0 // indirect github.com/golang-jwt/jwt/v5 v5.2.1 // indirect github.com/golang/glog v1.2.2 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect github.com/google/btree v1.1.2 // indirect + github.com/google/gnostic-models v0.6.9-0.20230804172637-c7be7c783f49 // indirect github.com/google/go-cmp v0.6.0 // indirect github.com/google/go-github/v41 v41.0.0 // indirect github.com/google/go-querystring v1.1.0 // indirect @@ -342,6 +315,7 @@ require ( github.com/lib/pq v1.10.9 // indirect github.com/libp2p/go-buffer-pool v0.1.0 // indirect github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect + github.com/linxGnu/grocksdb v1.7.16 // indirect github.com/logrusorgru/aurora v2.0.3+incompatible // indirect github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect github.com/magiconair/properties v1.8.7 // indirect @@ -407,6 +381,9 @@ require ( github.com/robfig/cron/v3 v3.0.1 // indirect github.com/rogpeppe/go-internal v1.12.0 // indirect github.com/rs/cors v1.10.1 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/sagikazarmark/locafero v0.4.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect github.com/sanity-io/litter v1.5.5 // indirect github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect github.com/sasha-s/go-deadlock v0.3.1 // indirect @@ -422,17 +399,22 @@ require ( github.com/sirupsen/logrus v1.9.3 // indirect github.com/smartcontractkit/chain-selectors v1.0.29 // indirect github.com/smartcontractkit/chainlink-automation v0.8.1 // indirect + github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec // indirect + github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f // indirect github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 // indirect github.com/smartcontractkit/chainlink-feeds v0.1.1 // indirect github.com/smartcontractkit/chainlink-protos/orchestrator v0.3.0 // indirect github.com/smartcontractkit/chainlink-solana v1.1.1-0.20241115191142-8b8369c1f44e // indirect github.com/smartcontractkit/chainlink-starknet/relayer v0.1.1-0.20241017135645-176a23722fd8 // indirect + github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2 // indirect github.com/smartcontractkit/chainlink-testing-framework/lib/grafana v1.50.0 // indirect + github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 // indirect github.com/smartcontractkit/libocr v0.0.0-20241007185508-adbe57025f12 // indirect github.com/smartcontractkit/tdh2/go/ocr2/decryptionplugin v0.0.0-20241009055228-33d0c0bf38de // indirect github.com/smartcontractkit/wsrpc v0.8.2 // indirect github.com/soheilhy/cmux v0.1.5 // indirect github.com/sony/gobreaker v0.5.0 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect github.com/spf13/afero v1.11.0 // indirect github.com/spf13/cast v1.6.0 // indirect github.com/spf13/cobra v1.8.1 // indirect @@ -485,10 +467,21 @@ require ( go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.56.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.56.0 // indirect go.opentelemetry.io/otel v1.31.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.0.0-20240823153156-2a54df7bffb9 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.6.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.30.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.30.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.30.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdoutlog v0.4.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.28.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.28.0 // indirect + go.opentelemetry.io/otel/log v0.6.0 // indirect go.opentelemetry.io/otel/metric v1.31.0 // indirect go.opentelemetry.io/otel/sdk v1.31.0 // indirect + go.opentelemetry.io/otel/sdk/log v0.6.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.31.0 // indirect go.opentelemetry.io/otel/trace v1.31.0 // indirect go.opentelemetry.io/proto/otlp v1.3.1 // indirect go.starlark.net v0.0.0-20230525235612-a134d8f9ddca // indirect @@ -499,7 +492,6 @@ require ( go4.org/netipx v0.0.0-20230125063823-8449b0a6169f // indirect golang.org/x/arch v0.11.0 // indirect golang.org/x/crypto v0.28.0 // indirect - golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c // indirect golang.org/x/mod v0.21.0 // indirect golang.org/x/net v0.30.0 // indirect golang.org/x/oauth2 v0.23.0 // indirect @@ -517,6 +509,7 @@ require ( google.golang.org/genproto/googleapis/rpc v0.0.0-20241021214115-324edc3d5d38 // indirect google.golang.org/grpc v1.67.1 // indirect google.golang.org/protobuf v1.35.1 // indirect + gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect gopkg.in/guregu/null.v4 v4.0.0 // indirect gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/ini.v1 v1.67.0 // indirect @@ -525,6 +518,7 @@ require ( gopkg.in/yaml.v3 v3.0.1 // indirect k8s.io/api v0.31.2 // indirect k8s.io/apiextensions-apiserver v0.31.0 // indirect + k8s.io/apimachinery v0.31.2 // indirect k8s.io/cli-runtime v0.31.2 // indirect k8s.io/client-go v0.31.2 // indirect k8s.io/component-base v0.31.2 // indirect @@ -539,9 +533,12 @@ require ( sigs.k8s.io/kustomize/api v0.17.2 // indirect sigs.k8s.io/kustomize/kyaml v0.17.1 // indirect sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect - sigs.k8s.io/yaml v1.4.0 // indirect; indirect nhooyr.io/websocket v1.8.7 // indirect + sigs.k8s.io/yaml v1.4.0 // indirect ) +// avoids ambigious imports of indirect dependencies +exclude github.com/hashicorp/consul v1.2.1 + replace ( // geth wants v2.3.4 but that is incompatible with github.com/cometbft/cometbft v0.37.5 which when bumped is incompatible with github.com/cosmos/cosmos-sdk // This line can be removed after these imports are bumped or removed. diff --git a/integration-tests/load/vrfv2/gun.go b/integration-tests/load/vrfv2/gun.go index 20a20b40834..9a680e5bd99 100644 --- a/integration-tests/load/vrfv2/gun.go +++ b/integration-tests/load/vrfv2/gun.go @@ -4,6 +4,7 @@ import ( "math/rand" "github.com/rs/zerolog" + "golang.org/x/exp/constraints" "github.com/smartcontractkit/chainlink-testing-framework/wasp" @@ -123,9 +124,9 @@ func (m *SingleHashGun) Call(_ *wasp.Generator) *wasp.Response { func deviateValue(requestCountPerTX uint16, deviation uint16) uint16 { if randBool() && requestCountPerTX > deviation { - requestCountPerTX -= uint16(randInRange(0, int(deviation))) + requestCountPerTX -= randInRange(0, deviation) } else { - requestCountPerTX += uint16(randInRange(0, int(deviation))) + requestCountPerTX += randInRange(0, deviation) } return requestCountPerTX } @@ -133,6 +134,7 @@ func deviateValue(requestCountPerTX uint16, deviation uint16) uint16 { func randBool() bool { return rand.Intn(2) == 1 } -func randInRange(min int, max int) int { - return rand.Intn(max-min+1) + min + +func randInRange[I constraints.Integer](lower, upper I) I { + return I(rand.Intn(int(upper-lower)+1)) + lower } diff --git a/integration-tests/load/vrfv2plus/gun.go b/integration-tests/load/vrfv2plus/gun.go index 4aac3927518..f6a194ab6ce 100644 --- a/integration-tests/load/vrfv2plus/gun.go +++ b/integration-tests/load/vrfv2plus/gun.go @@ -5,6 +5,7 @@ import ( "math/rand" "github.com/rs/zerolog" + "golang.org/x/exp/constraints" "github.com/smartcontractkit/chainlink-testing-framework/wasp" @@ -131,13 +132,13 @@ func (m *SingleHashGun) Call(_ *wasp.Generator) *wasp.Response { func deviateValue(requestCountPerTX uint16, deviation uint16) uint16 { if actions.RandBool() && requestCountPerTX > deviation { - requestCountPerTX -= uint16(randInRange(0, int(deviation))) + requestCountPerTX -= randInRange(0, deviation) } else { - requestCountPerTX += uint16(randInRange(0, int(deviation))) + requestCountPerTX += randInRange(0, deviation) } return requestCountPerTX } -func randInRange(min int, max int) int { - return rand.Intn(max-min+1) + min +func randInRange[I constraints.Integer](lower, upper I) I { + return I(rand.Intn(int(upper-lower)+1)) + lower } diff --git a/integration-tests/smoke/ccip_rmn_test.go b/integration-tests/smoke/ccip_rmn_test.go index d1cadabc06a..4f44caccb52 100644 --- a/integration-tests/smoke/ccip_rmn_test.go +++ b/integration-tests/smoke/ccip_rmn_test.go @@ -208,6 +208,9 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { }) if rmnNodeInfo.isSigner { + if rmnNodeInfo.id < 0 { + t.Fatalf("node id is negative: %d", rmnNodeInfo.id) + } rmnRemoteSigners = append(rmnRemoteSigners, rmn_remote.RMNRemoteSigner{ OnchainPublicKey: rmn.RMN.EVMOnchainPublicKey, NodeIndex: uint64(rmnNodeInfo.id), @@ -217,6 +220,9 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { var rmnHomeSourceChains []rmn_home.RMNHomeSourceChain for remoteChainIdx, remoteF := range tc.homeChainConfig.f { + if remoteF < 0 { + t.Fatalf("negative remote F: %d", remoteF) + } // configure remote chain details on the home contract rmnHomeSourceChains = append(rmnHomeSourceChains, rmn_home.RMNHomeSourceChain{ ChainSelector: chainSelectors[remoteChainIdx], @@ -288,6 +294,9 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { remoteSel := chainSelectors[remoteCfg.chainIdx] chState, ok := onChainState.Chains[remoteSel] require.True(t, ok) + if remoteCfg.f < 0 { + t.Fatalf("negative F: %d", remoteCfg.f) + } rmnRemoteConfig := rmn_remote.RMNRemoteConfig{ RmnHomeContractConfigDigest: activeDigest, Signers: rmnRemoteSigners, diff --git a/integration-tests/smoke/forwarders_ocr2_test.go b/integration-tests/smoke/forwarders_ocr2_test.go index 0cc7d9fafe4..3f2f4dadae8 100644 --- a/integration-tests/smoke/forwarders_ocr2_test.go +++ b/integration-tests/smoke/forwarders_ocr2_test.go @@ -100,7 +100,10 @@ func TestForwarderOCR2Basic(t *testing.T) { err = actions.ConfigureOCRv2AggregatorContracts(ocrv2Config, ocrInstances) require.NoError(t, err, "Error configuring OCRv2 aggregator contracts") - err = actions.CreateOCRv2JobsLocal(ocrInstances, bootstrapNode, workerNodes, env.MockAdapter, "ocr2", 5, uint64(sethClient.ChainID), true, false) + if sethClient.ChainID < 0 { + t.Errorf("negative chain ID: %d", sethClient.ChainID) + } + err = actions.CreateOCRv2JobsLocal(ocrInstances, bootstrapNode, workerNodes, env.MockAdapter, "ocr2", 5, uint64(sethClient.ChainID), true, false) //nolint:gosec // G115 false positive require.NoError(t, err, "Error creating OCRv2 jobs with forwarders") err = actions.WatchNewOCRRound(l, sethClient, 1, contracts.V2OffChainAgrregatorToOffChainAggregatorWithRounds(ocrInstances), time.Duration(10*time.Minute)) diff --git a/integration-tests/smoke/log_poller_test.go b/integration-tests/smoke/log_poller_test.go index b5891e7a3e8..edf8c228a07 100644 --- a/integration-tests/smoke/log_poller_test.go +++ b/integration-tests/smoke/log_poller_test.go @@ -3,6 +3,7 @@ package smoke import ( "context" "fmt" + "math" "math/big" "testing" "time" @@ -130,6 +131,9 @@ func executeBasicLogPollerTest(t *testing.T, logScannerSettings test_env.Chainli // Save block number before starting to emit events, so that we can later use it when querying logs sb, err := sethClient.Client.BlockNumber(testcontext.Get(t)) require.NoError(t, err, "Error getting latest block number") + if sb > math.MaxInt64 { + t.Fatalf("start block overflows int64: %d", sb) + } startBlock := int64(sb) l.Info().Int64("Starting Block", startBlock).Msg("STARTING EVENT EMISSION") @@ -163,6 +167,9 @@ func executeBasicLogPollerTest(t *testing.T, logScannerSettings test_env.Chainli chaosError := <-chaosDoneCh require.NoError(t, chaosError, "Error encountered during chaos experiment") + if eb > math.MaxInt64 { + t.Fatalf("end block overflows int64: %d", eb) + } // use ridciuously high end block so that we don't have to find out the block number of the last block in which logs were emitted // as that's not trivial to do (i.e. just because chain was at block X when log emission ended it doesn't mean all events made it to that block) endBlock := int64(eb) + 10000 @@ -205,6 +212,9 @@ func executeLogPollerReplay(t *testing.T, consistencyTimeout string) { // Save block number before starting to emit events, so that we can later use it when querying logs sb, err := sethClient.Client.BlockNumber(testcontext.Get(t)) require.NoError(t, err, "Error getting latest block number") + if sb > math.MaxInt64 { + t.Fatalf("start block overflows int64: %d", sb) + } startBlock := int64(sb) l.Info().Int64("Starting Block", startBlock).Msg("STARTING EVENT EMISSION") @@ -219,6 +229,9 @@ func executeLogPollerReplay(t *testing.T, consistencyTimeout string) { eb, err := sethClient.Client.BlockNumber(testcontext.Get(t)) require.NoError(t, err, "Error getting latest block number") + if eb > math.MaxInt64 { + t.Fatalf("end block overflows int64: %d", eb) + } endBlock, err := logpoller.GetEndBlockToWaitFor(int64(eb), *evmNetwork, cfg) require.NoError(t, err, "Error getting end block to wait for") @@ -282,7 +295,7 @@ type logPollerEnvironment struct { // deploying registry and log emitter contracts and registering log triggered upkeeps func prepareEnvironment(l zerolog.Logger, t *testing.T, testConfig *tc.TestConfig, logScannerSettings test_env.ChainlinkNodeLogScannerSettings) logPollerEnvironment { cfg := testConfig.LogPoller - if cfg.General.EventsToEmit == nil || len(cfg.General.EventsToEmit) == 0 { + if len(cfg.General.EventsToEmit) == 0 { l.Warn().Msg("No events to emit specified, using all events from log emitter contract") for _, event := range logpoller.EmitterABI.Events { cfg.General.EventsToEmit = append(cfg.General.EventsToEmit, event) diff --git a/integration-tests/smoke/ocr2_test.go b/integration-tests/smoke/ocr2_test.go index 325c88f979a..a011dfdffc6 100644 --- a/integration-tests/smoke/ocr2_test.go +++ b/integration-tests/smoke/ocr2_test.go @@ -125,7 +125,7 @@ func TestOCRv2JobReplacement(t *testing.T) { err = actions.DeleteBridges(nodeClients) require.NoError(t, err) - err = actions.CreateOCRv2JobsLocal(aggregatorContracts, bootstrapNode, workerNodes, testEnv.MockAdapter, "ocr2", 15, uint64(sethClient.ChainID), false, false) + err = actions.CreateOCRv2JobsLocal(aggregatorContracts, bootstrapNode, workerNodes, testEnv.MockAdapter, "ocr2", 15, uint64(sethClient.ChainID), false, false) //nolint:gosec // G115 false positive require.NoError(t, err, "Error creating OCRv2 jobs") err = actions.WatchNewOCRRound(l, sethClient, 3, contracts.V2OffChainAgrregatorToOffChainAggregatorWithRounds(aggregatorContracts), time.Minute*3) @@ -195,7 +195,10 @@ func prepareORCv2SmokeTestEnv(t *testing.T, testData ocr2test, l zerolog.Logger, aggregatorContracts, err := actions.SetupOCRv2Contracts(l, sethClient, config.OCR2, common.HexToAddress(linkContract.Address()), transmitters, ocrOffChainOptions) require.NoError(t, err, "Error deploying OCRv2 aggregator contracts") - err = actions.CreateOCRv2JobsLocal(aggregatorContracts, bootstrapNode, workerNodes, testEnv.MockAdapter, "ocr2", 5, uint64(sethClient.ChainID), false, testData.chainReaderAndCodec) + if sethClient.ChainID < 0 { + t.Errorf("negative chain ID: %d", sethClient.ChainID) + } + err = actions.CreateOCRv2JobsLocal(aggregatorContracts, bootstrapNode, workerNodes, testEnv.MockAdapter, "ocr2", 5, uint64(sethClient.ChainID), false, testData.chainReaderAndCodec) //nolint:gosec // G115 false positive require.NoError(t, err, "Error creating OCRv2 jobs") if !config.OCR2.UseExistingOffChainAggregatorsContracts() || (config.OCR2.UseExistingOffChainAggregatorsContracts() && config.OCR2.ConfigureExistingOffChainAggregatorsContracts()) { diff --git a/integration-tests/smoke/vrfv2_test.go b/integration-tests/smoke/vrfv2_test.go index 3c9beec5ddb..1e2c4711527 100644 --- a/integration-tests/smoke/vrfv2_test.go +++ b/integration-tests/smoke/vrfv2_test.go @@ -2,6 +2,7 @@ package smoke import ( "fmt" + "math" "math/big" "os" "strconv" @@ -167,7 +168,7 @@ func TestVRFv2Basic(t *testing.T) { require.True(t, status.Fulfilled) l.Info().Bool("Fulfilment Status", status.Fulfilled).Msg("Random Words Request Fulfilment Status") - require.Equal(t, *configCopy.VRFv2.General.NumberOfWords, uint32(len(status.RandomWords))) + require.Equal(t, int(*configCopy.VRFv2.General.NumberOfWords), len(status.RandomWords)) for _, w := range status.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -322,7 +323,7 @@ func TestVRFv2Basic(t *testing.T) { require.Equal(t, expectedWrapperConsumerJuelsBalance, wrapperConsumerJuelsBalanceAfterRequest) // Check random word count - require.Equal(t, *configCopy.VRFv2.General.NumberOfWords, uint32(len(consumerStatus.RandomWords))) + require.Equal(t, int(*configCopy.VRFv2.General.NumberOfWords), len(consumerStatus.RandomWords)) for _, w := range consumerStatus.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -773,7 +774,7 @@ func TestVRFOwner(t *testing.T) { require.True(t, status.Fulfilled) l.Info().Bool("Fulfilment Status", status.Fulfilled).Msg("Random Words Request Fulfilment Status") - require.Equal(t, *configCopy.VRFv2.General.NumberOfWords, uint32(len(status.RandomWords))) + require.Equal(t, int(*configCopy.VRFv2.General.NumberOfWords), len(status.RandomWords)) for _, w := range status.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -943,14 +944,18 @@ func TestVRFV2WithBHS(t *testing.T) { ) require.NoError(t, err, "error requesting randomness") randRequestBlockNumber := randomWordsRequestedEvent.Raw.BlockNumber - _, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), big.NewInt(int64(randRequestBlockNumber))) + _, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), new(big.Int).SetUint64(randRequestBlockNumber)) require.Error(t, err, "error not occurred when getting blockhash for a blocknumber which was not stored in BHS contract") + blocks := *configCopy.VRFv2.General.BHSJobWaitBlocks + if blocks < 0 { + t.Fatalf("negative blocks: %d", blocks) + } var wg sync.WaitGroup wg.Add(1) _, err = actions.WaitForBlockNumberToBe( testcontext.Get(t), - randRequestBlockNumber+uint64(*configCopy.VRFv2.General.BHSJobWaitBlocks), + randRequestBlockNumber+uint64(blocks), sethClient, &wg, nil, @@ -996,7 +1001,7 @@ func TestVRFV2WithBHS(t *testing.T) { } var randRequestBlockHash [32]byte gom.Eventually(func(g gomega.Gomega) { - randRequestBlockHash, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), big.NewInt(int64(randRequestBlockNumber))) + randRequestBlockHash, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), new(big.Int).SetUint64(randRequestBlockNumber)) g.Expect(err).ShouldNot(gomega.HaveOccurred(), "error getting blockhash for a blocknumber which was stored in BHS contract") }, "2m", "1s").Should(gomega.Succeed()) l.Info(). @@ -1268,6 +1273,9 @@ func TestVRFv2BatchFulfillmentEnabledDisabled(t *testing.T) { vrfcommon.LogSubDetails(l, subscription, strconv.FormatUint(subID, 10), vrfContracts.CoordinatorV2) subIDsForCancellingAfterTest = append(subIDsForCancellingAfterTest, subIDs...) + if randRequestCount > math.MaxUint16 { + t.Fatalf("rand request count overflows uint16: %d", randRequestCount) + } configCopy.VRFv2.General.RandomnessRequestCountPerRequest = ptr.Ptr(uint16(randRequestCount)) // test and assert @@ -1389,7 +1397,10 @@ func TestVRFv2BatchFulfillmentEnabledDisabled(t *testing.T) { vrfcommon.LogSubDetails(l, subscription, strconv.FormatUint(subID, 10), vrfContracts.CoordinatorV2) subIDsForCancellingAfterTest = append(subIDsForCancellingAfterTest, subIDs...) - configCopy.VRFv2.General.RandomnessRequestCountPerRequest = ptr.Ptr(uint16(randRequestCount)) + if randRequestCount > math.MaxUint16 { + t.Fatalf("rand request count overflows uint16: %d", randRequestCount) + } + configCopy.VRFv2.General.RandomnessRequestCountPerRequest = ptr.Ptr(uint16(randRequestCount)) //nolint:gosec // G115 false positive // test and assert _, randomWordsFulfilledEvent, err := vrfv2.RequestRandomnessAndWaitForFulfillment( diff --git a/integration-tests/smoke/vrfv2plus_test.go b/integration-tests/smoke/vrfv2plus_test.go index df0917fd4fb..a57230f1a0c 100644 --- a/integration-tests/smoke/vrfv2plus_test.go +++ b/integration-tests/smoke/vrfv2plus_test.go @@ -2,6 +2,7 @@ package smoke import ( "fmt" + "math" "math/big" "os" "strings" @@ -156,7 +157,7 @@ func TestVRFv2Plus(t *testing.T) { require.True(t, status.Fulfilled) l.Info().Bool("Fulfilment Status", status.Fulfilled).Msg("Random Words Request Fulfilment Status") - require.Equal(t, *configCopy.VRFv2Plus.General.NumberOfWords, uint32(len(status.RandomWords))) + require.Equal(t, int(*configCopy.VRFv2Plus.General.NumberOfWords), len(status.RandomWords)) for _, w := range status.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -219,7 +220,7 @@ func TestVRFv2Plus(t *testing.T) { require.True(t, status.Fulfilled) l.Info().Bool("Fulfilment Status", status.Fulfilled).Msg("Random Words Request Fulfilment Status") - require.Equal(t, *testConfig.NumberOfWords, uint32(len(status.RandomWords))) + require.Equal(t, int(*testConfig.NumberOfWords), len(status.RandomWords)) for _, w := range status.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -327,7 +328,7 @@ func TestVRFv2Plus(t *testing.T) { //require.Equal(t, 1, consumerStatus.Paid.Cmp(randomWordsFulfilledEvent.Payment), "Expected Consumer contract pay more than the Coordinator Sub") vrfcommon.LogFulfillmentDetailsLinkBilling(l, wrapperConsumerJuelsBalanceBeforeRequest, wrapperConsumerJuelsBalanceAfterRequest, consumerStatus, randomWordsFulfilledEvent) - require.Equal(t, *testConfig.NumberOfWords, uint32(len(consumerStatus.RandomWords))) + require.Equal(t, int(*testConfig.NumberOfWords), len(consumerStatus.RandomWords)) for _, w := range consumerStatus.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -376,7 +377,7 @@ func TestVRFv2Plus(t *testing.T) { //require.Equal(t, 1, consumerStatus.Paid.Cmp(randomWordsFulfilledEvent.Payment), "Expected Consumer contract pay more than the Coordinator Sub") vrfcommon.LogFulfillmentDetailsNativeBilling(l, wrapperConsumerBalanceBeforeRequestWei, wrapperConsumerBalanceAfterRequestWei, consumerStatus, randomWordsFulfilledEvent) - require.Equal(t, *testConfig.NumberOfWords, uint32(len(consumerStatus.RandomWords))) + require.Equal(t, int(*testConfig.NumberOfWords), len(consumerStatus.RandomWords)) for _, w := range consumerStatus.RandomWords { l.Info().Str("Output", w.String()).Msg("Randomness fulfilled") require.Equal(t, 1, w.Cmp(big.NewInt(0)), "Expected the VRF job give an answer bigger than 0") @@ -958,7 +959,7 @@ func TestVRFv2PlusMigration(t *testing.T) { newCoordinator, err := contracts.DeployVRFCoordinatorV2PlusUpgradedVersion(sethClient, vrfContracts.BHS.Address()) require.NoError(t, err, "error deploying VRF CoordinatorV2PlusUpgradedVersion") - _, err = vrfv2plus.VRFV2PlusUpgradedVersionRegisterProvingKey(vrfKey.VRFKey, newCoordinator, uint64(assets.GWei(*configCopy.VRFv2Plus.General.CLNodeMaxGasPriceGWei).Int64())) + _, err = vrfv2plus.VRFV2PlusUpgradedVersionRegisterProvingKey(vrfKey.VRFKey, newCoordinator, assets.GWei(*configCopy.VRFv2Plus.General.CLNodeMaxGasPriceGWei).ToInt().Uint64()) require.NoError(t, err, fmt.Errorf("%s, err: %w", vrfcommon.ErrRegisteringProvingKey, err)) err = newCoordinator.SetConfig( @@ -1127,7 +1128,7 @@ func TestVRFv2PlusMigration(t *testing.T) { newCoordinator, err := contracts.DeployVRFCoordinatorV2PlusUpgradedVersion(sethClient, vrfContracts.BHS.Address()) require.NoError(t, err, "error deploying VRF CoordinatorV2PlusUpgradedVersion") - _, err = vrfv2plus.VRFV2PlusUpgradedVersionRegisterProvingKey(vrfKey.VRFKey, newCoordinator, uint64(assets.GWei(*configCopy.VRFv2Plus.General.CLNodeMaxGasPriceGWei).Int64())) + _, err = vrfv2plus.VRFV2PlusUpgradedVersionRegisterProvingKey(vrfKey.VRFKey, newCoordinator, assets.GWei(*configCopy.VRFv2Plus.General.CLNodeMaxGasPriceGWei).ToInt().Uint64()) require.NoError(t, err, fmt.Errorf("%s, err: %w", vrfcommon.ErrRegisteringProvingKey, err)) err = newCoordinator.SetConfig( @@ -1345,13 +1346,13 @@ func TestVRFV2PlusWithBHS(t *testing.T) { var wg sync.WaitGroup wg.Add(1) - waitForNumberOfBlocks := 257 + const waitForNumberOfBlocks = 257 desiredBlockNumberReached := make(chan bool) go func() { //Wait at least 256 blocks _, err = actions.WaitForBlockNumberToBe( testcontext.Get(t), - randRequestBlockNumber+uint64(waitForNumberOfBlocks), + randRequestBlockNumber+waitForNumberOfBlocks, sethClient, &wg, desiredBlockNumberReached, @@ -1396,7 +1397,7 @@ func TestVRFV2PlusWithBHS(t *testing.T) { require.True(t, status.Fulfilled) l.Info().Bool("Fulfilment Status", status.Fulfilled).Msg("Random Words Request Fulfilment Status") - randRequestBlockHash, err := vrfContracts.BHS.GetBlockHash(testcontext.Get(t), big.NewInt(int64(randRequestBlockNumber))) + randRequestBlockHash, err := vrfContracts.BHS.GetBlockHash(testcontext.Get(t), new(big.Int).SetUint64(randRequestBlockNumber)) require.NoError(t, err, "error getting blockhash for a blocknumber which was stored in BHS contract") l.Info(). @@ -1443,14 +1444,17 @@ func TestVRFV2PlusWithBHS(t *testing.T) { ) require.NoError(t, err, "error requesting randomness") randRequestBlockNumber := randomWordsRequestedEvent.Raw.BlockNumber - _, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), big.NewInt(int64(randRequestBlockNumber))) + _, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), new(big.Int).SetUint64(randRequestBlockNumber)) require.Error(t, err, "error not occurred when getting blockhash for a blocknumber which was not stored in BHS contract") + if *configCopy.VRFv2Plus.General.BHSJobWaitBlocks < 0 { + t.Fatalf("negative job wait blocks: %d", *configCopy.VRFv2Plus.General.BHSJobWaitBlocks) + } var wg sync.WaitGroup wg.Add(1) _, err = actions.WaitForBlockNumberToBe( testcontext.Get(t), - randRequestBlockNumber+uint64(*configCopy.VRFv2Plus.General.BHSJobWaitBlocks+10), + randRequestBlockNumber+uint64(*configCopy.VRFv2Plus.General.BHSJobWaitBlocks)+10, //nolint:gosec // G115 false positive sethClient, &wg, nil, @@ -1497,7 +1501,7 @@ func TestVRFV2PlusWithBHS(t *testing.T) { var randRequestBlockHash [32]byte gom.Eventually(func(g gomega.Gomega) { - randRequestBlockHash, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), big.NewInt(int64(randRequestBlockNumber))) + randRequestBlockHash, err = vrfContracts.BHS.GetBlockHash(testcontext.Get(t), new(big.Int).SetUint64(randRequestBlockNumber)) g.Expect(err).ShouldNot(gomega.HaveOccurred(), "error getting blockhash for a blocknumber which was stored in BHS contract") }, "2m", "1s").Should(gomega.Succeed()) l.Info(). @@ -1642,7 +1646,7 @@ func TestVRFV2PlusWithBHF(t *testing.T) { } require.True(t, batchBHSTxFound) - randRequestBlockHash, err := vrfContracts.BHS.GetBlockHash(testcontext.Get(t), big.NewInt(int64(randRequestBlockNumber))) + randRequestBlockHash, err := vrfContracts.BHS.GetBlockHash(testcontext.Get(t), new(big.Int).SetUint64(randRequestBlockNumber)) require.NoError(t, err, "error getting blockhash for a blocknumber which was stored in BHS contract") l.Info(). @@ -2148,6 +2152,9 @@ func TestVRFv2PlusBatchFulfillmentEnabledDisabled(t *testing.T) { vrfcommon.LogSubDetails(l, subscription, subID.String(), vrfContracts.CoordinatorV2Plus) subIDsForCancellingAfterTest = append(subIDsForCancellingAfterTest, subIDs...) + if randRequestCount > math.MaxUint16 { + t.Fatalf("rand request count overflows uint16: %d", randRequestCount) + } configCopy.VRFv2Plus.General.RandomnessRequestCountPerRequest = ptr.Ptr(uint16(randRequestCount)) // test and assert @@ -2262,6 +2269,9 @@ func TestVRFv2PlusBatchFulfillmentEnabledDisabled(t *testing.T) { vrfcommon.LogSubDetails(l, subscription, subID.String(), vrfContracts.CoordinatorV2Plus) subIDsForCancellingAfterTest = append(subIDsForCancellingAfterTest, subIDs...) + if randRequestCount > math.MaxUint16 { + t.Fatalf("rand request count overflows uint16: %d", randRequestCount) + } configCopy.VRFv2Plus.General.RandomnessRequestCountPerRequest = ptr.Ptr(uint16(randRequestCount)) // test and assert diff --git a/integration-tests/testconfig/ccip/config.go b/integration-tests/testconfig/ccip/config.go index 3ef746e29e3..6c1bfcbe560 100644 --- a/integration-tests/testconfig/ccip/config.go +++ b/integration-tests/testconfig/ccip/config.go @@ -2,6 +2,7 @@ package ccip import ( "fmt" + "math" "strconv" "github.com/AlekSi/pointer" @@ -184,8 +185,12 @@ func IsSelectorValid(selector uint64, evmNetworks []blockchain.EVMNetwork) (bool if err != nil { return false, err } + if chainId >= math.MaxInt64 { + return false, fmt.Errorf("chain id overflows int64: %d", chainId) + } + id := int64(chainId) for _, net := range evmNetworks { - if net.ChainID == int64(chainId) { + if net.ChainID == id { return true, nil } } diff --git a/integration-tests/testconfig/testconfig_utils.go b/integration-tests/testconfig/testconfig_utils.go index e7b38ea3e4e..8d41ed55be9 100644 --- a/integration-tests/testconfig/testconfig_utils.go +++ b/integration-tests/testconfig/testconfig_utils.go @@ -1,6 +1,7 @@ package testconfig import ( + "errors" "fmt" "os" "strings" @@ -18,12 +19,12 @@ Chainlink version must be set in toml config. ` if os.Getenv("E2E_TEST_CHAINLINK_IMAGE") == "" || os.Getenv("E2E_TEST_CHAINLINK_UPGRADE_IMAGE") == "" { - return fmt.Errorf(fmt.Sprintf("%s\n%s", errStr, missingImage)) + return fmt.Errorf("%s\n%s", errStr, missingImage) } if os.Getenv("CHAINLINK_VERSION") == "" || os.Getenv("CHAINLINK_UPGRADE_VERSION") == "" { - return fmt.Errorf(fmt.Sprintf("%s\n%s", errStr, missingVersion)) + return fmt.Errorf("%s\n%s", errStr, missingVersion) } - return fmt.Errorf(errStr) + return errors.New(errStr) } // NoSelectedNetworkInfoAsError return a helfpul error message when the no selected network info is found in TOML config. @@ -34,8 +35,6 @@ You might have used old configuration approach. If so, use TOML instead of env v Please refer to integration-tests/testconfig/README.md for more information. ` - finalErrStr := fmt.Sprintf("%s\n%s", errStr, intro) - if net := os.Getenv("SELECTED_NETWORKS"); net != "" { parts := strings.Split(net, ",") selectedNetworkStr := "[" @@ -52,10 +51,10 @@ Please refer to integration-tests/testconfig/README.md for more information. Or if you want to run your tests right now add following content to integration-tests/testconfig/overrides.toml: [Network] selected_networks=` - finalErrStr = fmt.Sprintf("%s\n%s%s%s", errStr, intro, extraInfo, selectedNetworkStr) + return fmt.Errorf("%s\n%s%s%s", errStr, intro, extraInfo, selectedNetworkStr) } - return fmt.Errorf(finalErrStr) + return fmt.Errorf("%s\n%s", errStr, intro) } func GetChainAndTestTypeSpecificConfig(testType string, product Product) (TestConfig, error) { diff --git a/integration-tests/testreporters/keeper.go b/integration-tests/testreporters/keeper.go index dfafda06e86..bfa9585b8bc 100644 --- a/integration-tests/testreporters/keeper.go +++ b/integration-tests/testreporters/keeper.go @@ -4,7 +4,6 @@ import ( "encoding/csv" "encoding/json" "fmt" - "math" "os" "path/filepath" "sync" @@ -65,7 +64,7 @@ func (k *KeeperBlockTimeTestReporter) WriteReport(folderLocation string) error { } var totalExpected, totalSuccessful, totalMissed, worstMiss int64 for contractIndex, report := range k.Reports { - avg, max := int64AvgMax(report.AllMissedUpkeeps) + avg, maxVal := int64AvgMax(report.AllMissedUpkeeps) err = keeperReportWriter.Write([]string{ fmt.Sprint(contractIndex), report.ContractAddress, @@ -73,13 +72,13 @@ func (k *KeeperBlockTimeTestReporter) WriteReport(folderLocation string) error { fmt.Sprint(report.TotalSuccessfulUpkeeps), fmt.Sprint(len(report.AllMissedUpkeeps)), fmt.Sprint(avg), - fmt.Sprint(max), + fmt.Sprint(maxVal), fmt.Sprintf("%.2f%%", (float64(report.TotalSuccessfulUpkeeps)/float64(report.TotalExpectedUpkeeps))*100), }) totalExpected += report.TotalExpectedUpkeeps totalSuccessful += report.TotalSuccessfulUpkeeps totalMissed += int64(len(report.AllMissedUpkeeps)) - worstMiss = int64(math.Max(float64(max), float64(worstMiss))) + worstMiss = max(maxVal, worstMiss) if err != nil { return err } @@ -160,13 +159,13 @@ func (k *KeeperBlockTimeTestReporter) SendSlackNotification(t *testing.T, slackC // int64AvgMax helper calculates the avg and the max values in a list func int64AvgMax(in []int64) (float64, int64) { var sum int64 - var max int64 + var val int64 // max if len(in) == 0 { return 0, 0 } for _, num := range in { sum += num - max = int64(math.Max(float64(max), float64(num))) + val = max(val, num) } - return float64(sum) / float64(len(in)), max + return float64(sum) / float64(len(in)), val } diff --git a/integration-tests/testreporters/keeper_benchmark.go b/integration-tests/testreporters/keeper_benchmark.go index 00a31a12411..81a792002d9 100644 --- a/integration-tests/testreporters/keeper_benchmark.go +++ b/integration-tests/testreporters/keeper_benchmark.go @@ -129,7 +129,7 @@ func (k *KeeperBenchmarkTestReporter) WriteReport(folderLocation string) error { if err != nil { return err } - avg, median, ninetyPct, ninetyNinePct, max := IntListStats(allDelays) + avg, median, ninetyPct, ninetyNinePct, maxVal := IntListStats(allDelays) err = keeperReportWriter.Write([]string{ fmt.Sprint(totalEligibleCount), fmt.Sprint(totalPerformed), @@ -139,7 +139,7 @@ func (k *KeeperBenchmarkTestReporter) WriteReport(folderLocation string) error { fmt.Sprint(median), fmt.Sprint(ninetyPct), fmt.Sprint(ninetyNinePct), - fmt.Sprint(max), + fmt.Sprint(maxVal), fmt.Sprintf("%.2f%%", pctWithinSLA), fmt.Sprintf("%.2f%%", pctReverted), fmt.Sprintf("%.2f%%", pctStale), @@ -156,7 +156,7 @@ func (k *KeeperBenchmarkTestReporter) WriteReport(folderLocation string) error { Int64("Median Perform Delay", median). Int64("90th pct Perform Delay", ninetyPct). Int64("99th pct Perform Delay", ninetyNinePct). - Int64("Max Perform Delay", max). + Int64("Max Perform Delay", maxVal). Float64("Percent Within SLA", pctWithinSLA). Float64("Percent Reverted", pctReverted). Msg("Calculated Aggregate Results") @@ -179,7 +179,7 @@ func (k *KeeperBenchmarkTestReporter) WriteReport(folderLocation string) error { } for contractIndex, report := range k.Reports { - avg, median, ninetyPct, ninetyNinePct, max = IntListStats(report.AllCheckDelays) + avg, median, ninetyPct, ninetyNinePct, maxVal = IntListStats(report.AllCheckDelays) err = keeperReportWriter.Write([]string{ fmt.Sprint(contractIndex), report.RegistryAddress, @@ -190,7 +190,7 @@ func (k *KeeperBenchmarkTestReporter) WriteReport(folderLocation string) error { fmt.Sprint(median), fmt.Sprint(ninetyPct), fmt.Sprint(ninetyNinePct), - fmt.Sprint(max), + fmt.Sprint(maxVal), fmt.Sprintf("%.2f%%", (1.0-float64(report.TotalSLAMissedUpkeeps)/float64(report.TotalEligibleCount))*100), }) if err != nil { @@ -215,7 +215,7 @@ func (k *KeeperBenchmarkTestReporter) WriteReport(folderLocation string) error { "median": median, "90p": ninetyPct, "99p": ninetyNinePct, - "max": max, + "max": maxVal, } k.Summary.Metrics.PercentWithinSLA = pctWithinSLA k.Summary.Metrics.PercentRevert = pctReverted diff --git a/integration-tests/testsetups/automation_benchmark.go b/integration-tests/testsetups/automation_benchmark.go index 18e13816f5a..d6f5615965c 100644 --- a/integration-tests/testsetups/automation_benchmark.go +++ b/integration-tests/testsetups/automation_benchmark.go @@ -303,11 +303,15 @@ func (k *KeeperBenchmarkTest) Run() { startedObservations.Add(1) k.log.Info().Int("Channel index", chIndex).Str("UpkeepID", upkeepIDCopy.String()).Msg("Starting upkeep observation") + upKeepSLA := inputs.Upkeeps.BlockRange + inputs.UpkeepSLA + if upKeepSLA < 0 { + k.t.Fatalf("negative upkeep SLA: %d", upKeepSLA) + } confirmer := contracts.NewAutomationConsumerBenchmarkUpkeepObserver( k.keeperConsumerContracts[registryIndex], k.keeperRegistries[registryIndex], upkeepIDCopy, - inputs.Upkeeps.BlockRange+inputs.UpkeepSLA, + uint64(upKeepSLA), inputs.UpkeepSLA, &k.TestReporter, upkeepIndex, @@ -723,6 +727,9 @@ func (k *KeeperBenchmarkTest) SetupBenchmarkKeeperContracts(index int, a *automa err = actions.SetupMultiCallAndFundDeploymentAddresses(k.chainClient, k.linkToken, upkeep.NumberOfUpkeeps, linkFunds, a.TestConfig) require.NoError(k.t, err, "Sending link funds to deployment addresses shouldn't fail") + if upkeep.UpkeepGasLimit < 0 || upkeep.UpkeepGasLimit > math.MaxUint32 { + k.t.Fatalf("upkeep gas limit overflows uint32: %d", upkeep.UpkeepGasLimit) + } upkeepIds := actions.RegisterUpkeepContractsWithCheckData(k.t, k.chainClient, k.linkToken, linkFunds, uint32(upkeep.UpkeepGasLimit), a.Registry, a.Registrar, upkeep.NumberOfUpkeeps, upkeepAddresses, checkData, false, false, false, nil) k.automationTests[index] = *a diff --git a/integration-tests/universal/log_poller/helpers.go b/integration-tests/universal/log_poller/helpers.go index 52a5594564b..0c127d576c0 100644 --- a/integration-tests/universal/log_poller/helpers.go +++ b/integration-tests/universal/log_poller/helpers.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "fmt" + "math" "math/big" "math/rand" "sort" @@ -441,7 +442,15 @@ func (m *MissingLogs) IsEmpty() bool { } // GetMissingLogs returns a map of CL node name to missing logs in that node compared to EVM node to which the provided evm client is connected -func GetMissingLogs(startBlock, endBlock int64, logEmitters []*contracts.LogEmitter, client *seth.Client, clnodeCluster *test_env.ClCluster, l zerolog.Logger, coreLogger core_logger.SugaredLogger, cfg *lp_config.Config) (MissingLogs, error) { +func GetMissingLogs( + startBlock, endBlock int64, + logEmitters []*contracts.LogEmitter, + client *seth.Client, + clnodeCluster *test_env.ClCluster, + l zerolog.Logger, + coreLogger core_logger.SugaredLogger, + cfg *lp_config.Config, +) (MissingLogs, error) { wg := &sync.WaitGroup{} type dbQueryResult struct { @@ -564,6 +573,12 @@ func GetMissingLogs(startBlock, endBlock int64, logEmitters []*contracts.LogEmit missingLogs := make([]geth_types.Log, 0) for i, evmLog := range allLogsInEVMNode { logFound := false + if evmLog.BlockNumber > math.MaxInt64 { + panic(fmt.Errorf("block number overflows int64: %d", evmLog.BlockNumber)) + } + if evmLog.Index > math.MaxInt64 { + panic(fmt.Errorf("index overflows int64: %d", evmLog.Index)) + } for _, logPollerLog := range allLogPollerLogs[nodeName] { if logPollerLog.BlockNumber == int64(evmLog.BlockNumber) && logPollerLog.TxHash == evmLog.TxHash && bytes.Equal(logPollerLog.Data, evmLog.Data) && logPollerLog.LogIndex == int64(evmLog.Index) && logPollerLog.Address == evmLog.Address && logPollerLog.BlockHash == evmLog.BlockHash && bytes.Equal(logPollerLog.Topics[0][:], evmLog.Topics[0].Bytes()) { @@ -982,6 +997,9 @@ func GetEndBlockToWaitFor(endBlock int64, network blockchain.EVMNetwork, cfg *lp return endBlock + 1, nil } + if network.FinalityDepth > math.MaxInt64 { + return -1, fmt.Errorf("finality depth overflows int64: %d", network.FinalityDepth) + } return endBlock + int64(network.FinalityDepth), nil } diff --git a/plugins/chainlink.Dockerfile b/plugins/chainlink.Dockerfile index 6d42567c745..a17f5df3898 100644 --- a/plugins/chainlink.Dockerfile +++ b/plugins/chainlink.Dockerfile @@ -1,5 +1,5 @@ # Build image: Chainlink binary -FROM golang:1.22-bullseye as buildgo +FROM golang:1.23-bullseye as buildgo RUN go version WORKDIR /chainlink @@ -33,7 +33,7 @@ RUN mkdir /chainlink-starknet RUN go list -m -f "{{.Dir}}" github.com/smartcontractkit/chainlink-starknet/relayer | xargs -I % ln -s % /chainlink-starknet/relayer # Build image: Plugins -FROM golang:1.22-bullseye as buildplugins +FROM golang:1.23-bullseye as buildplugins RUN go version WORKDIR /chainlink-feeds From e943945b1f5dfc1d6bc44909ee251b0a30f11757 Mon Sep 17 00:00:00 2001 From: Cedric Date: Wed, 20 Nov 2024 12:25:53 +0000 Subject: [PATCH 4/6] [CAPPL-305] typo custom compute (#15326) * [CAPPL-305] Fix typo in custom compute * [chore] Don't return when exposing an action server receiver * Update common --- core/capabilities/compute/compute.go | 2 +- core/capabilities/launcher.go | 3 ++- core/scripts/go.mod | 2 +- core/scripts/go.sum | 4 ++-- core/services/workflows/engine_test.go | 12 ++++++------ deployment/go.mod | 2 +- deployment/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- integration-tests/go.mod | 2 +- integration-tests/go.sum | 4 ++-- integration-tests/load/go.mod | 2 +- integration-tests/load/go.sum | 4 ++-- 13 files changed, 24 insertions(+), 23 deletions(-) diff --git a/core/capabilities/compute/compute.go b/core/capabilities/compute/compute.go index 7b11072b161..32e43e8d62e 100644 --- a/core/capabilities/compute/compute.go +++ b/core/capabilities/compute/compute.go @@ -34,7 +34,7 @@ import ( ) const ( - CapabilityIDCompute = "custom_compute@1.0.0" + CapabilityIDCompute = "custom-compute@1.0.0" binaryKey = "binary" configKey = "config" diff --git a/core/capabilities/launcher.go b/core/capabilities/launcher.go index e75f2ebbc8f..be06dcf60c1 100644 --- a/core/capabilities/launcher.go +++ b/core/capabilities/launcher.go @@ -459,7 +459,8 @@ func (w *launcher) exposeCapabilities(ctx context.Context, myPeerID p2ptypes.Pee err = w.addReceiver(ctx, capability, don, newActionServer) if err != nil { - return fmt.Errorf("failed to add action server-side receiver: %w", err) + w.lggr.Errorw("failed to add action server-side receiver - it won't be exposed remotely", "id", cid, "error", err) + // continue attempting other capabilities } case capabilities.CapabilityTypeConsensus: w.lggr.Warn("no remote client configured for capability type consensus, skipping configuration") diff --git a/core/scripts/go.mod b/core/scripts/go.mod index b8439a14f46..bae07fbd255 100644 --- a/core/scripts/go.mod +++ b/core/scripts/go.mod @@ -24,7 +24,7 @@ require ( github.com/prometheus/client_golang v1.20.5 github.com/shopspring/decimal v1.4.0 github.com/smartcontractkit/chainlink-automation v0.8.1 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b github.com/smartcontractkit/chainlink/deployment v0.0.0-00010101000000-000000000000 github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a github.com/smartcontractkit/libocr v0.0.0-20241007185508-adbe57025f12 diff --git a/core/scripts/go.sum b/core/scripts/go.sum index 02fb1e63a90..ef3edca64a7 100644 --- a/core/scripts/go.sum +++ b/core/scripts/go.sum @@ -1409,8 +1409,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec h1:5vS1k8Qn09p8SQ3JzvS8iy4Pve7s3aVq+UPIdl74smY= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 h1:2llRW4Tn9W/EZp2XvXclQ9IjeTBwwxVPrrqaerX+vCE= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b h1:mm46AlaafEhvGjJvuAb0VoLLM3NKAVnwKZ+iUCNL/sg= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 h1:1BMTG66HnCIz+KMBWGvyzELNM6VHGwv2WKFhN7H49Sg= diff --git a/core/services/workflows/engine_test.go b/core/services/workflows/engine_test.go index 3a2bc17bc36..9ae4c21ebe2 100644 --- a/core/services/workflows/engine_test.go +++ b/core/services/workflows/engine_test.go @@ -1127,8 +1127,8 @@ triggers: - "0x3333333333333333333300000000000000000000000000000000000000000000" # BTCUSD actions: - - id: custom_compute@1.0.0 - ref: custom_compute + - id: custom-compute@1.0.0 + ref: custom-compute config: maxMemoryMBs: 128 tickInterval: 100ms @@ -1173,7 +1173,7 @@ targets: func TestEngine_MergesWorkflowConfigAndCRConfig_CRConfigPrecedence(t *testing.T) { var ( ctx = testutils.Context(t) - actionID = "custom_compute@1.0.0" + actionID = "custom-compute@1.0.0" giveTimeout = 300 * time.Millisecond giveTickInterval = 100 * time.Millisecond registryConfig = map[string]any{ @@ -1562,8 +1562,8 @@ triggers: - "0x3333333333333333333300000000000000000000000000000000000000000000" # BTCUSD actions: - - id: custom_compute@1.0.0 - ref: custom_compute + - id: custom-compute@1.0.0 + ref: custom-compute config: fidelityToken: $(ENV.secrets.fidelity) inputs: @@ -1625,7 +1625,7 @@ func TestEngine_FetchesSecrets(t *testing.T) { action := newMockCapability( // Create a remote capability so we don't use the local transmission protocol. capabilities.MustNewRemoteCapabilityInfo( - "custom_compute@1.0.0", + "custom-compute@1.0.0", capabilities.CapabilityTypeAction, "a custom compute action with custom config", &capabilities.DON{ID: 1}, diff --git a/deployment/go.mod b/deployment/go.mod index d67615f736f..e9b8cf95882 100644 --- a/deployment/go.mod +++ b/deployment/go.mod @@ -23,7 +23,7 @@ require ( github.com/smartcontractkit/ccip-owner-contracts v0.0.0-20240926212305-a6deabdfce86 github.com/smartcontractkit/chain-selectors v1.0.29 github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b github.com/smartcontractkit/chainlink-protos/job-distributor v0.6.0 github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.13 github.com/smartcontractkit/chainlink/v2 v2.0.0-00010101000000-000000000000 diff --git a/deployment/go.sum b/deployment/go.sum index 65db9f77800..e9b8e394afa 100644 --- a/deployment/go.sum +++ b/deployment/go.sum @@ -1384,8 +1384,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec h1:5vS1k8Qn09p8SQ3JzvS8iy4Pve7s3aVq+UPIdl74smY= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 h1:2llRW4Tn9W/EZp2XvXclQ9IjeTBwwxVPrrqaerX+vCE= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b h1:mm46AlaafEhvGjJvuAb0VoLLM3NKAVnwKZ+iUCNL/sg= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 h1:1BMTG66HnCIz+KMBWGvyzELNM6VHGwv2WKFhN7H49Sg= diff --git a/go.mod b/go.mod index e7c1468bfbc..41b9c62e813 100644 --- a/go.mod +++ b/go.mod @@ -77,7 +77,7 @@ require ( github.com/smartcontractkit/chain-selectors v1.0.29 github.com/smartcontractkit/chainlink-automation v0.8.1 github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 github.com/smartcontractkit/chainlink-feeds v0.1.1 diff --git a/go.sum b/go.sum index 386ab51a211..a5a1f935e81 100644 --- a/go.sum +++ b/go.sum @@ -1078,8 +1078,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec h1:5vS1k8Qn09p8SQ3JzvS8iy4Pve7s3aVq+UPIdl74smY= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 h1:2llRW4Tn9W/EZp2XvXclQ9IjeTBwwxVPrrqaerX+vCE= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b h1:mm46AlaafEhvGjJvuAb0VoLLM3NKAVnwKZ+iUCNL/sg= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 h1:1BMTG66HnCIz+KMBWGvyzELNM6VHGwv2WKFhN7H49Sg= diff --git a/integration-tests/go.mod b/integration-tests/go.mod index bb601a61444..80aa69c3a52 100644 --- a/integration-tests/go.mod +++ b/integration-tests/go.mod @@ -36,7 +36,7 @@ require ( github.com/slack-go/slack v0.15.0 github.com/smartcontractkit/chain-selectors v1.0.29 github.com/smartcontractkit/chainlink-automation v0.8.1 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b github.com/smartcontractkit/chainlink-protos/job-distributor v0.6.0 github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2 github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.14 diff --git a/integration-tests/go.sum b/integration-tests/go.sum index 8e3869244d8..e1b43d8cc70 100644 --- a/integration-tests/go.sum +++ b/integration-tests/go.sum @@ -1405,8 +1405,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec h1:5vS1k8Qn09p8SQ3JzvS8iy4Pve7s3aVq+UPIdl74smY= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 h1:2llRW4Tn9W/EZp2XvXclQ9IjeTBwwxVPrrqaerX+vCE= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b h1:mm46AlaafEhvGjJvuAb0VoLLM3NKAVnwKZ+iUCNL/sg= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 h1:1BMTG66HnCIz+KMBWGvyzELNM6VHGwv2WKFhN7H49Sg= diff --git a/integration-tests/load/go.mod b/integration-tests/load/go.mod index a6cfd5bddb9..bca8be0f886 100644 --- a/integration-tests/load/go.mod +++ b/integration-tests/load/go.mod @@ -17,7 +17,7 @@ require ( github.com/pkg/errors v0.9.1 github.com/rs/zerolog v1.33.0 github.com/slack-go/slack v0.15.0 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.14 github.com/smartcontractkit/chainlink-testing-framework/seth v1.50.9 github.com/smartcontractkit/chainlink-testing-framework/wasp v1.50.2 diff --git a/integration-tests/load/go.sum b/integration-tests/load/go.sum index ed0224adc21..8670dd1c6a6 100644 --- a/integration-tests/load/go.sum +++ b/integration-tests/load/go.sum @@ -1394,8 +1394,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec h1:5vS1k8Qn09p8SQ3JzvS8iy4Pve7s3aVq+UPIdl74smY= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241118091009-43c2b4804cec/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068 h1:2llRW4Tn9W/EZp2XvXclQ9IjeTBwwxVPrrqaerX+vCE= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241114134822-aadff98ef068/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b h1:mm46AlaafEhvGjJvuAb0VoLLM3NKAVnwKZ+iUCNL/sg= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241120111740-a6a70ec7692b/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241114154055-8d29ea018b57 h1:1BMTG66HnCIz+KMBWGvyzELNM6VHGwv2WKFhN7H49Sg= From 73e82d298c0be7cbcddea68cdff4d46a030d0662 Mon Sep 17 00:00:00 2001 From: Balamurali Gopalswami <167726375+b-gopalswami@users.noreply.github.com> Date: Wed, 20 Nov 2024 07:52:56 -0500 Subject: [PATCH 5/6] Fix flake in detecting reorg by nodes (#15289) * Fix flake in detecting reorg by nodes * represent as f+1 nodes --- integration-tests/ccip-tests/smoke/ccip_test.go | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/integration-tests/ccip-tests/smoke/ccip_test.go b/integration-tests/ccip-tests/smoke/ccip_test.go index a729bd5daec..0dab46c5a25 100644 --- a/integration-tests/ccip-tests/smoke/ccip_test.go +++ b/integration-tests/ccip-tests/smoke/ccip_test.go @@ -886,7 +886,7 @@ func TestSmokeCCIPReorgBelowFinality(t *testing.T) { // Test creates above finality reorg at destination and // expects ccip transactions in-flight and the one initiated after reorg -// doesn't go through and verifies every node is able to detect reorg. +// doesn't go through and verifies f+1 nodes is able to detect reorg. // Note: LogPollInterval interval is set as 1s to detect the reorg immediately func TestSmokeCCIPReorgAboveFinalityAtDestination(t *testing.T) { t.Parallel() @@ -897,7 +897,7 @@ func TestSmokeCCIPReorgAboveFinalityAtDestination(t *testing.T) { // Test creates above finality reorg at destination and // expects ccip transactions in-flight doesn't go through, the transaction initiated after reorg -// shouldn't even get initiated and verifies every node is able to detect reorg. +// shouldn't even get initiated and verifies f+1 nodes is able to detect reorg. // Note: LogPollInterval interval is set as 1s to detect the reorg immediately func TestSmokeCCIPReorgAboveFinalityAtSource(t *testing.T) { t.Parallel() @@ -936,11 +936,13 @@ func performAboveFinalityReorgAndValidate(t *testing.T, network string) { logPollerName = fmt.Sprintf("EVM.%d.LogPoller", lane.SourceChain.GetChainID()) rs.RunReorg(rs.SrcClient, rs.Cfg.SrcFinalityDepth+rs.Cfg.FinalityDelta, network, 2*time.Second) } - clNodes := setUpOutput.Env.CLNodes - // assert every node is detecting the reorg (LogPollInterval is set as 1s for faster detection) + // DON is 3F+1, finding f+1 from the given number of nodes in the environment + fPlus1Nodes := int(math.Ceil(float64(len(setUpOutput.Env.CLNodes)-1)/3)) + 1 + // assert at least f+1 nodes is detecting the reorg (LogPollInterval is set as 1s for faster detection) + // additional context: Commit requires 2f+1 observations, so f+1 nodes need to detect it in order to force the entire DON to stop processing messages. nodesDetectedViolation := make(map[string]bool) assert.Eventually(t, func() bool { - for _, node := range clNodes { + for _, node := range setUpOutput.Env.CLNodes { if _, ok := nodesDetectedViolation[node.ChainlinkClient.URL()]; ok { continue } @@ -953,8 +955,8 @@ func performAboveFinalityReorgAndValidate(t *testing.T, network string) { } } } - return len(nodesDetectedViolation) == len(clNodes) - }, 3*time.Minute, 20*time.Second, "Reorg above finality depth is not detected by every node") + return len(nodesDetectedViolation) >= fPlus1Nodes + }, 3*time.Minute, 20*time.Second, "Reorg above finality depth is not detected by f+1 nodes") log.Debug().Interface("Nodes", nodesDetectedViolation).Msg("Violation detection details") // send another request and verify it fails err = lane.SendRequests(1, gasLimit) From 2ea3aef763ab5d4ce5d0bc24f0f97c37733e53f0 Mon Sep 17 00:00:00 2001 From: Cedric Date: Wed, 20 Nov 2024 13:04:58 +0000 Subject: [PATCH 6/6] Add WorkflowRegistry to config (#15280) --- core/cmd/shell_local.go | 2 +- core/config/capabilities_config.go | 8 ++++++ core/config/docs/core.toml | 8 ++++++ core/config/toml/types.go | 22 +++++++++++++++ .../services/chainlink/config_capabilities.go | 26 ++++++++++++++++++ core/services/chainlink/config_test.go | 5 ++++ .../testdata/config-empty-effective.toml | 5 ++++ .../chainlink/testdata/config-full.toml | 5 ++++ .../config-multi-chain-effective.toml | 5 ++++ .../testdata/config-empty-effective.toml | 5 ++++ core/web/resolver/testdata/config-full.toml | 5 ++++ .../config-multi-chain-effective.toml | 5 ++++ docs/CONFIG.md | 27 +++++++++++++++++++ .../scripts/config/merge_raw_configs.txtar | 5 ++++ testdata/scripts/node/validate/default.txtar | 5 ++++ .../node/validate/defaults-override.txtar | 5 ++++ .../disk-based-logging-disabled.txtar | 5 ++++ .../validate/disk-based-logging-no-dir.txtar | 5 ++++ .../node/validate/disk-based-logging.txtar | 5 ++++ .../node/validate/invalid-ocr-p2p.txtar | 5 ++++ testdata/scripts/node/validate/invalid.txtar | 5 ++++ testdata/scripts/node/validate/valid.txtar | 5 ++++ testdata/scripts/node/validate/warnings.txtar | 5 ++++ 23 files changed, 177 insertions(+), 1 deletion(-) diff --git a/core/cmd/shell_local.go b/core/cmd/shell_local.go index f6b8db43123..6261d23ef82 100644 --- a/core/cmd/shell_local.go +++ b/core/cmd/shell_local.go @@ -469,7 +469,7 @@ func (s *Shell) runNode(c *cli.Context) error { } } - if s.Config.Capabilities().Peering().Enabled() { + if s.Config.Capabilities().WorkflowRegistry().Address() != "" { err2 := app.GetKeyStore().Workflow().EnsureKey(rootCtx) if err2 != nil { return errors.Wrap(err2, "failed to ensure workflow key") diff --git a/core/config/capabilities_config.go b/core/config/capabilities_config.go index b7e5a3b86a7..74e06bf8bbb 100644 --- a/core/config/capabilities_config.go +++ b/core/config/capabilities_config.go @@ -11,6 +11,13 @@ type CapabilitiesExternalRegistry interface { RelayID() types.RelayID } +type CapabilitiesWorkflowRegistry interface { + Address() string + NetworkID() string + ChainID() string + RelayID() types.RelayID +} + type GatewayConnector interface { ChainIDForNodeKey() string NodeAddress() string @@ -30,5 +37,6 @@ type Capabilities interface { Peering() P2P Dispatcher() Dispatcher ExternalRegistry() CapabilitiesExternalRegistry + WorkflowRegistry() CapabilitiesWorkflowRegistry GatewayConnector() GatewayConnector } diff --git a/core/config/docs/core.toml b/core/config/docs/core.toml index edd1494e4f0..20c519e81a1 100644 --- a/core/config/docs/core.toml +++ b/core/config/docs/core.toml @@ -444,6 +444,14 @@ DeltaReconcile = '1m' # Default # but the host and port must be fully specified and cannot be empty. You can specify `0.0.0.0` (IPv4) or `::` (IPv6) to listen on all interfaces, but that is not recommended. ListenAddresses = ['1.2.3.4:9999', '[a52d:0:a88:1274::abcd]:1337'] # Example +[Capabilities.WorkflowRegistry] +# Address is the address for the workflow registry contract. +Address = '0x0' # Example +# NetworkID identifies the target network where the remote registry is located. +NetworkID = 'evm' # Default +# ChainID identifies the target chain id where the remote registry is located. +ChainID = '1' # Default + [Capabilities.ExternalRegistry] # Address is the address for the capabilities registry contract. Address = '0x0' # Example diff --git a/core/config/toml/types.go b/core/config/toml/types.go index 610d18b6b4d..475e95d53df 100644 --- a/core/config/toml/types.go +++ b/core/config/toml/types.go @@ -1452,6 +1452,26 @@ func (r *ExternalRegistry) setFrom(f *ExternalRegistry) { } } +type WorkflowRegistry struct { + Address *string + NetworkID *string + ChainID *string +} + +func (r *WorkflowRegistry) setFrom(f *WorkflowRegistry) { + if f.Address != nil { + r.Address = f.Address + } + + if f.NetworkID != nil { + r.NetworkID = f.NetworkID + } + + if f.ChainID != nil { + r.ChainID = f.ChainID + } +} + type Dispatcher struct { SupportedVersion *int ReceiverBufferSize *int @@ -1541,12 +1561,14 @@ type Capabilities struct { Peering P2P `toml:",omitempty"` Dispatcher Dispatcher `toml:",omitempty"` ExternalRegistry ExternalRegistry `toml:",omitempty"` + WorkflowRegistry WorkflowRegistry `toml:",omitempty"` GatewayConnector GatewayConnector `toml:",omitempty"` } func (c *Capabilities) setFrom(f *Capabilities) { c.Peering.setFrom(&f.Peering) c.ExternalRegistry.setFrom(&f.ExternalRegistry) + c.WorkflowRegistry.setFrom(&f.WorkflowRegistry) c.Dispatcher.setFrom(&f.Dispatcher) c.GatewayConnector.setFrom(&f.GatewayConnector) } diff --git a/core/services/chainlink/config_capabilities.go b/core/services/chainlink/config_capabilities.go index 032eec58bea..37ab1fce72f 100644 --- a/core/services/chainlink/config_capabilities.go +++ b/core/services/chainlink/config_capabilities.go @@ -22,6 +22,12 @@ func (c *capabilitiesConfig) ExternalRegistry() config.CapabilitiesExternalRegis } } +func (c *capabilitiesConfig) WorkflowRegistry() config.CapabilitiesWorkflowRegistry { + return &capabilitiesWorkflowRegistry{ + c: c.c.WorkflowRegistry, + } +} + func (c *capabilitiesConfig) Dispatcher() config.Dispatcher { return &dispatcher{d: c.c.Dispatcher} } @@ -88,6 +94,26 @@ func (c *capabilitiesExternalRegistry) Address() string { return *c.c.Address } +type capabilitiesWorkflowRegistry struct { + c toml.WorkflowRegistry +} + +func (c *capabilitiesWorkflowRegistry) RelayID() types.RelayID { + return types.NewRelayID(c.NetworkID(), c.ChainID()) +} + +func (c *capabilitiesWorkflowRegistry) NetworkID() string { + return *c.c.NetworkID +} + +func (c *capabilitiesWorkflowRegistry) ChainID() string { + return *c.c.ChainID +} + +func (c *capabilitiesWorkflowRegistry) Address() string { + return *c.c.Address +} + type gatewayConnector struct { c toml.GatewayConnector } diff --git a/core/services/chainlink/config_test.go b/core/services/chainlink/config_test.go index e04d6d7e25b..769005feb72 100644 --- a/core/services/chainlink/config_test.go +++ b/core/services/chainlink/config_test.go @@ -494,6 +494,11 @@ func TestConfig_Marshal(t *testing.T) { ChainID: ptr("1"), NetworkID: ptr("evm"), }, + WorkflowRegistry: toml.WorkflowRegistry{ + Address: ptr(""), + ChainID: ptr("1"), + NetworkID: ptr("evm"), + }, Dispatcher: toml.Dispatcher{ SupportedVersion: ptr(1), ReceiverBufferSize: ptr(10000), diff --git a/core/services/chainlink/testdata/config-empty-effective.toml b/core/services/chainlink/testdata/config-empty-effective.toml index 0f26b02ab6f..a2052c04a8e 100644 --- a/core/services/chainlink/testdata/config-empty-effective.toml +++ b/core/services/chainlink/testdata/config-empty-effective.toml @@ -269,6 +269,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/core/services/chainlink/testdata/config-full.toml b/core/services/chainlink/testdata/config-full.toml index 3191ce576ed..47193f80184 100644 --- a/core/services/chainlink/testdata/config-full.toml +++ b/core/services/chainlink/testdata/config-full.toml @@ -279,6 +279,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '11155111' NodeAddress = '0x68902d681c28119f9b2531473a417088bf008e59' diff --git a/core/services/chainlink/testdata/config-multi-chain-effective.toml b/core/services/chainlink/testdata/config-multi-chain-effective.toml index 5f52c06ca1f..7e658b170db 100644 --- a/core/services/chainlink/testdata/config-multi-chain-effective.toml +++ b/core/services/chainlink/testdata/config-multi-chain-effective.toml @@ -269,6 +269,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/core/web/resolver/testdata/config-empty-effective.toml b/core/web/resolver/testdata/config-empty-effective.toml index 0f26b02ab6f..a2052c04a8e 100644 --- a/core/web/resolver/testdata/config-empty-effective.toml +++ b/core/web/resolver/testdata/config-empty-effective.toml @@ -269,6 +269,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/core/web/resolver/testdata/config-full.toml b/core/web/resolver/testdata/config-full.toml index 113d319e3c5..ef26bfea75a 100644 --- a/core/web/resolver/testdata/config-full.toml +++ b/core/web/resolver/testdata/config-full.toml @@ -279,6 +279,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '11155111' NodeAddress = '0x68902d681c28119f9b2531473a417088bf008e59' diff --git a/core/web/resolver/testdata/config-multi-chain-effective.toml b/core/web/resolver/testdata/config-multi-chain-effective.toml index cb2884fde8f..7bdf50b9080 100644 --- a/core/web/resolver/testdata/config-multi-chain-effective.toml +++ b/core/web/resolver/testdata/config-multi-chain-effective.toml @@ -269,6 +269,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/docs/CONFIG.md b/docs/CONFIG.md index 20965d816ec..8911aff141f 100644 --- a/docs/CONFIG.md +++ b/docs/CONFIG.md @@ -1213,6 +1213,33 @@ ListenAddresses = ['1.2.3.4:9999', '[a52d:0:a88:1274::abcd]:1337'] # Example ListenAddresses is the addresses the peer will listen to on the network in `host:port` form as accepted by `net.Listen()`, but the host and port must be fully specified and cannot be empty. You can specify `0.0.0.0` (IPv4) or `::` (IPv6) to listen on all interfaces, but that is not recommended. +## Capabilities.WorkflowRegistry +```toml +[Capabilities.WorkflowRegistry] +Address = '0x0' # Example +NetworkID = 'evm' # Default +ChainID = '1' # Default +``` + + +### Address +```toml +Address = '0x0' # Example +``` +Address is the address for the workflow registry contract. + +### NetworkID +```toml +NetworkID = 'evm' # Default +``` +NetworkID identifies the target network where the remote registry is located. + +### ChainID +```toml +ChainID = '1' # Default +``` +ChainID identifies the target chain id where the remote registry is located. + ## Capabilities.ExternalRegistry ```toml [Capabilities.ExternalRegistry] diff --git a/testdata/scripts/config/merge_raw_configs.txtar b/testdata/scripts/config/merge_raw_configs.txtar index bf0da942eea..efac49f8ef8 100644 --- a/testdata/scripts/config/merge_raw_configs.txtar +++ b/testdata/scripts/config/merge_raw_configs.txtar @@ -416,6 +416,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/default.txtar b/testdata/scripts/node/validate/default.txtar index 51edf69d599..d4e4a188d2a 100644 --- a/testdata/scripts/node/validate/default.txtar +++ b/testdata/scripts/node/validate/default.txtar @@ -281,6 +281,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/defaults-override.txtar b/testdata/scripts/node/validate/defaults-override.txtar index 19bae4bec1a..336f170bd1b 100644 --- a/testdata/scripts/node/validate/defaults-override.txtar +++ b/testdata/scripts/node/validate/defaults-override.txtar @@ -342,6 +342,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/disk-based-logging-disabled.txtar b/testdata/scripts/node/validate/disk-based-logging-disabled.txtar index ddd01a4c1e4..677058e1c08 100644 --- a/testdata/scripts/node/validate/disk-based-logging-disabled.txtar +++ b/testdata/scripts/node/validate/disk-based-logging-disabled.txtar @@ -325,6 +325,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/disk-based-logging-no-dir.txtar b/testdata/scripts/node/validate/disk-based-logging-no-dir.txtar index 0f40ad6a208..0e5a78f4a39 100644 --- a/testdata/scripts/node/validate/disk-based-logging-no-dir.txtar +++ b/testdata/scripts/node/validate/disk-based-logging-no-dir.txtar @@ -325,6 +325,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/disk-based-logging.txtar b/testdata/scripts/node/validate/disk-based-logging.txtar index dd7455ca3a8..7fc05533a47 100644 --- a/testdata/scripts/node/validate/disk-based-logging.txtar +++ b/testdata/scripts/node/validate/disk-based-logging.txtar @@ -325,6 +325,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/invalid-ocr-p2p.txtar b/testdata/scripts/node/validate/invalid-ocr-p2p.txtar index 1ffe2ab718c..2cc7b7afe0e 100644 --- a/testdata/scripts/node/validate/invalid-ocr-p2p.txtar +++ b/testdata/scripts/node/validate/invalid-ocr-p2p.txtar @@ -310,6 +310,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/invalid.txtar b/testdata/scripts/node/validate/invalid.txtar index 52edd2b8065..b048af38a3b 100644 --- a/testdata/scripts/node/validate/invalid.txtar +++ b/testdata/scripts/node/validate/invalid.txtar @@ -315,6 +315,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/valid.txtar b/testdata/scripts/node/validate/valid.txtar index 623459ce253..bc84a9b2a37 100644 --- a/testdata/scripts/node/validate/valid.txtar +++ b/testdata/scripts/node/validate/valid.txtar @@ -322,6 +322,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = '' diff --git a/testdata/scripts/node/validate/warnings.txtar b/testdata/scripts/node/validate/warnings.txtar index 5452c49f122..85b7bc6a253 100644 --- a/testdata/scripts/node/validate/warnings.txtar +++ b/testdata/scripts/node/validate/warnings.txtar @@ -304,6 +304,11 @@ Address = '' NetworkID = 'evm' ChainID = '1' +[Capabilities.WorkflowRegistry] +Address = '' +NetworkID = 'evm' +ChainID = '1' + [Capabilities.GatewayConnector] ChainIDForNodeKey = '' NodeAddress = ''