From dda65c454df28c8db330e66b10b9781b0cba713e Mon Sep 17 00:00:00 2001 From: Makram Date: Sat, 16 Nov 2024 02:36:08 +0400 Subject: [PATCH] integration-tests/smoke: add manual exec test (#15242) * integration-tests/smoke: add manual exec test Manually execute the message that failed to execute due to low callback gas. This is the first manual exec scenario, others will be covered in future PRs. * fix lint * updates after PR feedback * use ctx, fill out filteropts --- deployment/ccip/add_lane_test.go | 14 +- .../ccip/changeset/active_candidate_test.go | 4 +- deployment/ccip/changeset/add_chain_test.go | 6 +- .../ccip/changeset/initial_deploy_test.go | 4 +- deployment/ccip/test_helpers.go | 33 +-- .../smoke/ccip_messaging_test.go | 210 ++++++++++++++++-- integration-tests/smoke/ccip_rmn_test.go | 6 +- integration-tests/smoke/ccip_test.go | 12 +- 8 files changed, 228 insertions(+), 61 deletions(-) diff --git a/deployment/ccip/add_lane_test.go b/deployment/ccip/add_lane_test.go index eb0d805a926..1d7ab18bf34 100644 --- a/deployment/ccip/add_lane_test.go +++ b/deployment/ccip/add_lane_test.go @@ -100,14 +100,14 @@ func TestAddLane(t *testing.T) { startBlock := latesthdr.Number.Uint64() // Send traffic on the first lane and it should not be processed by the plugin as onRamp is disabled // we will check this by confirming that the message is not executed by the end of the test - seqNum1 := TestSendRequest(t, e.Env, state, chain1, chain2, false, router.ClientEVM2AnyMessage{ + msgSentEvent1 := TestSendRequest(t, e.Env, state, chain1, chain2, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[chain2].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - require.Equal(t, uint64(1), seqNum1) + require.Equal(t, uint64(1), msgSentEvent1.SequenceNumber) // Add another lane require.NoError(t, AddLane(e.Env, state, chain2, chain1)) @@ -116,18 +116,18 @@ func TestAddLane(t *testing.T) { latesthdr, err = e.Env.Chains[chain1].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) startBlock2 := latesthdr.Number.Uint64() - seqNum2 := TestSendRequest(t, e.Env, state, chain2, chain1, false, router.ClientEVM2AnyMessage{ + msgSentEvent2 := TestSendRequest(t, e.Env, state, chain2, chain1, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[chain2].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - require.Equal(t, uint64(1), seqNum2) - require.NoError(t, commonutils.JustError(ConfirmExecWithSeqNr(t, e.Env.Chains[chain2], e.Env.Chains[chain1], state.Chains[chain1].OffRamp, &startBlock2, seqNum2))) + require.Equal(t, uint64(1), msgSentEvent2.SequenceNumber) + require.NoError(t, commonutils.JustError(ConfirmExecWithSeqNr(t, e.Env.Chains[chain2], e.Env.Chains[chain1], state.Chains[chain1].OffRamp, &startBlock2, msgSentEvent2.SequenceNumber))) // now check for the previous message from chain 1 to chain 2 that it has not been executed till now as the onRamp was disabled - ConfirmNoExecConsistentlyWithSeqNr(t, e.Env.Chains[chain1], e.Env.Chains[chain2], state.Chains[chain2].OffRamp, seqNum1, 30*time.Second) + ConfirmNoExecConsistentlyWithSeqNr(t, e.Env.Chains[chain1], e.Env.Chains[chain2], state.Chains[chain2].OffRamp, msgSentEvent1.SequenceNumber, 30*time.Second) // enable the onRamp on OffRamp enableRampTx, err := state.Chains[chain2].OffRamp.ApplySourceChainConfigUpdates(e.Env.Chains[chain2].DeployerKey, []offramp.OffRampSourceChainConfigArgs{ @@ -150,5 +150,5 @@ func TestAddLane(t *testing.T) { ReplayLogs(t, e.Env.Offchain, replayBlocks) time.Sleep(30 * time.Second) // Now that the onRamp is enabled, the request should be processed - require.NoError(t, commonutils.JustError(ConfirmExecWithSeqNr(t, e.Env.Chains[chain1], e.Env.Chains[chain2], state.Chains[chain2].OffRamp, &startBlock, seqNum1))) + require.NoError(t, commonutils.JustError(ConfirmExecWithSeqNr(t, e.Env.Chains[chain1], e.Env.Chains[chain2], state.Chains[chain2].OffRamp, &startBlock, msgSentEvent1.SequenceNumber))) } diff --git a/deployment/ccip/changeset/active_candidate_test.go b/deployment/ccip/changeset/active_candidate_test.go index 9daf383c971..c64f7bf8c9f 100644 --- a/deployment/ccip/changeset/active_candidate_test.go +++ b/deployment/ccip/changeset/active_candidate_test.go @@ -84,14 +84,14 @@ func TestActiveCandidate(t *testing.T) { require.NoError(t, err) block := latesthdr.Number.Uint64() startBlocks[dest] = &block - seqNum := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - expectedSeqNum[dest] = seqNum + expectedSeqNum[dest] = msgSentEvent.SequenceNumber } } diff --git a/deployment/ccip/changeset/add_chain_test.go b/deployment/ccip/changeset/add_chain_test.go index 8bbbdf3d340..51972c6dd2e 100644 --- a/deployment/ccip/changeset/add_chain_test.go +++ b/deployment/ccip/changeset/add_chain_test.go @@ -217,7 +217,7 @@ func TestAddChainInbound(t *testing.T) { latesthdr, err := e.Env.Chains[newChain].Client.HeaderByNumber(testcontext.Get(t), nil) require.NoError(t, err) startBlock := latesthdr.Number.Uint64() - seqNr := ccipdeployment.TestSendRequest(t, e.Env, state, initialDeploy[0], newChain, true, router.ClientEVM2AnyMessage{ + msgSentEvent := ccipdeployment.TestSendRequest(t, e.Env, state, initialDeploy[0], newChain, true, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[newChain].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, @@ -227,10 +227,10 @@ func TestAddChainInbound(t *testing.T) { require.NoError(t, ccipdeployment.ConfirmCommitWithExpectedSeqNumRange(t, e.Env.Chains[initialDeploy[0]], e.Env.Chains[newChain], state.Chains[newChain].OffRamp, &startBlock, cciptypes.SeqNumRange{ cciptypes.SeqNum(1), - cciptypes.SeqNum(seqNr), + cciptypes.SeqNum(msgSentEvent.SequenceNumber), })) require.NoError(t, - commonutils.JustError(ccipdeployment.ConfirmExecWithSeqNr(t, e.Env.Chains[initialDeploy[0]], e.Env.Chains[newChain], state.Chains[newChain].OffRamp, &startBlock, seqNr))) + commonutils.JustError(ccipdeployment.ConfirmExecWithSeqNr(t, e.Env.Chains[initialDeploy[0]], e.Env.Chains[newChain], state.Chains[newChain].OffRamp, &startBlock, msgSentEvent.SequenceNumber))) linkAddress := state.Chains[newChain].LinkToken.Address() feeQuoter := state.Chains[newChain].FeeQuoter diff --git a/deployment/ccip/changeset/initial_deploy_test.go b/deployment/ccip/changeset/initial_deploy_test.go index e62092608ae..0d43a78b878 100644 --- a/deployment/ccip/changeset/initial_deploy_test.go +++ b/deployment/ccip/changeset/initial_deploy_test.go @@ -78,14 +78,14 @@ func TestInitialDeploy(t *testing.T) { require.NoError(t, err) block := latesthdr.Number.Uint64() startBlocks[dest] = &block - seqNum := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - expectedSeqNum[dest] = seqNum + expectedSeqNum[dest] = msgSentEvent.SequenceNumber } } diff --git a/deployment/ccip/test_helpers.go b/deployment/ccip/test_helpers.go index bdf8ab35e78..9d6ac0ab35d 100644 --- a/deployment/ccip/test_helpers.go +++ b/deployment/ccip/test_helpers.go @@ -43,6 +43,7 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/burn_mint_token_pool" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/mock_v3_aggregator_contract" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/aggregator_v3_interface" ) @@ -261,7 +262,7 @@ func TestSendRequest( src, dest uint64, testRouter bool, evm2AnyMessage router.ClientEVM2AnyMessage, -) (seqNum uint64) { +) (msgSentEvent *onramp.OnRampCCIPMessageSent) { t.Logf("Sending CCIP request from chain selector %d to chain selector %d", src, dest) tx, blockNum, err := CCIPSendRequest( @@ -279,12 +280,16 @@ func TestSendRequest( }, []uint64{dest}, []uint64{}) require.NoError(t, err) require.True(t, it.Next()) - seqNum = it.Event.Message.Header.SequenceNumber - nonce := it.Event.Message.Header.Nonce - sender := it.Event.Message.Sender - t.Logf("CCIP message sent from chain selector %d to chain selector %d tx %s seqNum %d nonce %d sender %s", - src, dest, tx.Hash().String(), seqNum, nonce, sender.String()) - return seqNum + t.Logf("CCIP message (id %x) sent from chain selector %d to chain selector %d tx %s seqNum %d nonce %d sender %s", + it.Event.Message.Header.MessageId[:], + src, + dest, + tx.Hash().String(), + it.Event.SequenceNumber, + it.Event.Message.Header.Nonce, + it.Event.Message.Sender.String(), + ) + return it.Event } // MakeEVMExtraArgsV2 creates the extra args for the EVM2Any message that is destined @@ -439,23 +444,23 @@ func ConfirmRequestOnSourceAndDest(t *testing.T, env deployment.Environment, sta require.NoError(t, err) startBlock := latesthdr.Number.Uint64() fmt.Printf("startblock %d", startBlock) - seqNum := TestSendRequest(t, env, state, sourceCS, destCS, false, router.ClientEVM2AnyMessage{ + msgSentEvent := TestSendRequest(t, env, state, sourceCS, destCS, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[destCS].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - require.Equal(t, expectedSeqNr, seqNum) + require.Equal(t, expectedSeqNr, msgSentEvent.SequenceNumber) - fmt.Printf("Request sent for seqnr %d", seqNum) + fmt.Printf("Request sent for seqnr %d", msgSentEvent.SequenceNumber) require.NoError(t, ConfirmCommitWithExpectedSeqNumRange(t, env.Chains[sourceCS], env.Chains[destCS], state.Chains[destCS].OffRamp, &startBlock, cciptypes.SeqNumRange{ - cciptypes.SeqNum(seqNum), - cciptypes.SeqNum(seqNum), + cciptypes.SeqNum(msgSentEvent.SequenceNumber), + cciptypes.SeqNum(msgSentEvent.SequenceNumber), })) - fmt.Printf("Commit confirmed for seqnr %d", seqNum) + fmt.Printf("Commit confirmed for seqnr %d", msgSentEvent.SequenceNumber) require.NoError( t, commonutils.JustError( @@ -465,7 +470,7 @@ func ConfirmRequestOnSourceAndDest(t *testing.T, env deployment.Environment, sta env.Chains[destCS], state.Chains[destCS].OffRamp, &startBlock, - seqNum, + msgSentEvent.SequenceNumber, ), ), ) diff --git a/integration-tests/smoke/ccip_messaging_test.go b/integration-tests/smoke/ccip_messaging_test.go index 8a193249303..a070d7b0061 100644 --- a/integration-tests/smoke/ccip_messaging_test.go +++ b/integration-tests/smoke/ccip_messaging_test.go @@ -1,6 +1,9 @@ package smoke import ( + "context" + "fmt" + "math/big" "testing" "time" @@ -9,14 +12,17 @@ import ( "github.com/stretchr/testify/require" "golang.org/x/exp/maps" + "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" - ccipdeployment "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" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router" "github.com/smartcontractkit/chainlink/v2/core/logger" ) @@ -24,8 +30,8 @@ import ( type testCaseSetup struct { t *testing.T sender []byte - deployedEnv ccipdeployment.DeployedEnv - onchainState ccipdeployment.CCIPOnChainState + deployedEnv ccdeploy.DeployedEnv + onchainState ccdeploy.CCIPOnChainState sourceChain, destChain uint64 } @@ -36,8 +42,9 @@ type messagingTestCase struct { } type messagingTestCaseOutput struct { - replayed bool - nonce uint64 + replayed bool + nonce uint64 + msgSentEvent *onramp.OnRampCCIPMessageSent } func Test_CCIPMessaging(t *testing.T) { @@ -65,7 +72,7 @@ func Test_CCIPMessaging(t *testing.T) { require.NoError(t, err) require.NoError(t, e.Env.ExistingAddresses.Merge(output.AddressBook)) - tokenConfig := ccipdeployment.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) + tokenConfig := ccdeploy.NewTestTokenConfig(state.Chains[e.FeedChainSel].USDFeeds) // Apply migration output, err = changeset.InitialDeploy(e.Env, ccdeploy.DeployCCIPContractConfig{ HomeChainSel: e.HomeChainSel, @@ -98,7 +105,7 @@ func Test_CCIPMessaging(t *testing.T) { } // connect a single lane, source to dest - require.NoError(t, ccipdeployment.AddLane(e.Env, state, sourceChain, destChain)) + require.NoError(t, ccdeploy.AddLane(e.Env, state, sourceChain, destChain)) var ( replayed bool @@ -123,8 +130,8 @@ func Test_CCIPMessaging(t *testing.T) { }, common.HexToAddress("0xdead"), []byte("hello eoa"), - nil, // default extraArgs - ccipdeployment.EXECUTION_STATE_SUCCESS, // success because offRamp won't call an EOA + nil, // default extraArgs + ccdeploy.EXECUTION_STATE_SUCCESS, // success because offRamp won't call an EOA ) }) @@ -137,12 +144,14 @@ func Test_CCIPMessaging(t *testing.T) { }, state.Chains[destChain].FeeQuoter.Address(), []byte("hello FeeQuoter"), - nil, // default extraArgs - ccipdeployment.EXECUTION_STATE_SUCCESS, // success because offRamp won't call a contract not implementing CCIPReceiver + nil, // default extraArgs + ccdeploy.EXECUTION_STATE_SUCCESS, // success because offRamp won't call a contract not implementing CCIPReceiver ) }) t.Run("message to contract implementing CCIPReceiver", func(t *testing.T) { + latestHead, err := e.Env.Chains[destChain].Client.HeaderByNumber(ctx, nil) + require.NoError(t, err) out = runMessagingTestCase( messagingTestCase{ testCaseSetup: setup, @@ -152,9 +161,12 @@ func Test_CCIPMessaging(t *testing.T) { state.Chains[destChain].Receiver.Address(), []byte("hello CCIPReceiver"), nil, // default extraArgs - ccipdeployment.EXECUTION_STATE_SUCCESS, + ccdeploy.EXECUTION_STATE_SUCCESS, func(t *testing.T) { - iter, err := state.Chains[destChain].Receiver.FilterMessageReceived(nil) + iter, err := state.Chains[destChain].Receiver.FilterMessageReceived(&bind.FilterOpts{ + Context: ctx, + Start: latestHead.Number.Uint64(), + }) require.NoError(t, err) require.True(t, iter.Next()) // MessageReceived doesn't emit the data unfortunately, so can't check that. @@ -163,6 +175,8 @@ func Test_CCIPMessaging(t *testing.T) { }) t.Run("message to contract implementing CCIPReceiver with low exec gas", func(t *testing.T) { + latestHead, err := e.Env.Chains[destChain].Client.HeaderByNumber(ctx, nil) + require.NoError(t, err) out = runMessagingTestCase( messagingTestCase{ testCaseSetup: setup, @@ -171,18 +185,154 @@ func Test_CCIPMessaging(t *testing.T) { }, state.Chains[destChain].Receiver.Address(), []byte("hello CCIPReceiver with low exec gas"), - ccipdeployment.MakeEVMExtraArgsV2(1, false), // 1 gas is too low. - ccipdeployment.EXECUTION_STATE_FAILURE, // state would be failed onchain due to low gas + ccdeploy.MakeEVMExtraArgsV2(1, false), // 1 gas is too low. + ccdeploy.EXECUTION_STATE_FAILURE, // state would be failed onchain due to low gas ) + + manuallyExecute(ctx, t, latestHead.Number.Uint64(), state, destChain, out, sourceChain, e, sender) + + t.Logf("successfully manually executed message %x", + out.msgSentEvent.Message.Header.MessageId) + }) +} + +func manuallyExecute( + ctx context.Context, + t *testing.T, + startBlock uint64, + state ccdeploy.CCIPOnChainState, + destChain uint64, + out messagingTestCaseOutput, + sourceChain uint64, + e ccdeploy.DeployedEnv, + sender []byte, +) { + merkleRoot := getMerkleRoot( + ctx, + t, + state.Chains[destChain].OffRamp, + out.msgSentEvent.SequenceNumber, + startBlock, + ) + messageHash := getMessageHash( + ctx, + t, + state.Chains[destChain].OffRamp, + sourceChain, + out.msgSentEvent.SequenceNumber, + out.msgSentEvent.Message.Header.MessageId, + startBlock, + ) + tree, err := merklemulti.NewTree(hashutil.NewKeccak(), [][32]byte{messageHash}) + require.NoError(t, err) + proof, err := tree.Prove([]int{0}) + require.NoError(t, err) + require.Equal(t, merkleRoot, tree.Root()) + + tx, err := state.Chains[destChain].OffRamp.ManuallyExecute( + e.Env.Chains[destChain].DeployerKey, + []offramp.InternalExecutionReport{ + { + SourceChainSelector: sourceChain, + Messages: []offramp.InternalAny2EVMRampMessage{ + { + Header: offramp.InternalRampMessageHeader{ + MessageId: out.msgSentEvent.Message.Header.MessageId, + SourceChainSelector: sourceChain, + DestChainSelector: destChain, + SequenceNumber: out.msgSentEvent.SequenceNumber, + Nonce: out.msgSentEvent.Message.Header.Nonce, + }, + Sender: sender, + Data: []byte("hello CCIPReceiver with low exec gas"), + Receiver: state.Chains[destChain].Receiver.Address(), + GasLimit: big.NewInt(1), + TokenAmounts: []offramp.InternalAny2EVMTokenTransfer{}, + }, + }, + OffchainTokenData: [][][]byte{ + {}, + }, + Proofs: proof.Hashes, + ProofFlagBits: boolsToBitFlags(proof.SourceFlags), + }, + }, + [][]offramp.OffRampGasLimitOverride{ + { + { + ReceiverExecutionGasLimit: big.NewInt(200_000), + TokenGasOverrides: nil, + }, + }, + }, + ) + _, err = deployment.ConfirmIfNoError(e.Env.Chains[destChain], tx, err) + require.NoError(t, err, "failed to send/confirm manuallyExecute tx") + + newExecutionState, err := state.Chains[destChain].OffRamp.GetExecutionState(&bind.CallOpts{Context: ctx}, sourceChain, out.msgSentEvent.SequenceNumber) + require.NoError(t, err) + require.Equal(t, uint8(ccdeploy.EXECUTION_STATE_SUCCESS), newExecutionState) +} + +func getMerkleRoot( + ctx context.Context, + t *testing.T, + offRamp *offramp.OffRamp, + seqNr, + startBlock uint64, +) (merkleRoot [32]byte) { + iter, err := offRamp.FilterCommitReportAccepted(&bind.FilterOpts{ + Context: ctx, + Start: startBlock, }) + require.NoError(t, err) + for iter.Next() { + for _, mr := range iter.Event.MerkleRoots { + if mr.MinSeqNr >= seqNr || mr.MaxSeqNr <= seqNr { + return mr.MerkleRoot + } + } + } + require.Fail( + t, + fmt.Sprintf("no merkle root found for seq nr %d", seqNr), + ) + return merkleRoot +} + +func getMessageHash( + ctx context.Context, + t *testing.T, + offRamp *offramp.OffRamp, + sourceChainSelector, + seqNr uint64, + msgID [32]byte, + startBlock uint64, +) (messageHash [32]byte) { + iter, err := offRamp.FilterExecutionStateChanged( + &bind.FilterOpts{ + Context: ctx, + Start: startBlock, + }, + []uint64{sourceChainSelector}, + []uint64{seqNr}, + [][32]byte{msgID}, + ) + require.NoError(t, err) + require.True(t, iter.Next()) + require.Equal(t, sourceChainSelector, iter.Event.SourceChainSelector) + require.Equal(t, seqNr, iter.Event.SequenceNumber) + require.Equal(t, msgID, iter.Event.MessageId) + + return iter.Event.MessageHash } -func sleepAndReplay(t *testing.T, e ccipdeployment.DeployedEnv, sourceChain, destChain uint64) { +func sleepAndReplay(t *testing.T, e ccdeploy.DeployedEnv, sourceChain, destChain uint64) { time.Sleep(30 * time.Second) replayBlocks := make(map[uint64]uint64) replayBlocks[sourceChain] = 1 replayBlocks[destChain] = 1 - ccipdeployment.ReplayLogs(t, e.Env.Offchain, replayBlocks) + ccdeploy.ReplayLogs(t, e.Env.Offchain, replayBlocks) } func runMessagingTestCase( @@ -201,7 +351,7 @@ func runMessagingTestCase( require.Equal(tc.t, tc.nonce, latestNonce) startBlocks := make(map[uint64]*uint64) - seqNum := ccipdeployment.TestSendRequest(tc.t, tc.deployedEnv.Env, tc.onchainState, tc.sourceChain, tc.destChain, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccdeploy.TestSendRequest(tc.t, tc.deployedEnv.Env, tc.onchainState, tc.sourceChain, tc.destChain, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(receiver.Bytes(), 32), Data: msgData, TokenAmounts: nil, @@ -209,7 +359,8 @@ func runMessagingTestCase( ExtraArgs: extraArgs, }) expectedSeqNum := make(map[uint64]uint64) - expectedSeqNum[tc.destChain] = seqNum + expectedSeqNum[tc.destChain] = msgSentEvent.SequenceNumber + out.msgSentEvent = msgSentEvent // hack if !tc.replayed { @@ -217,17 +368,17 @@ func runMessagingTestCase( out.replayed = true } - ccipdeployment.ConfirmCommitForAllWithExpectedSeqNums(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNum, startBlocks) - execStates := ccipdeployment.ConfirmExecWithSeqNrForAll(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNum, startBlocks) + ccdeploy.ConfirmCommitForAllWithExpectedSeqNums(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNum, startBlocks) + execStates := ccdeploy.ConfirmExecWithSeqNrForAll(tc.t, tc.deployedEnv.Env, tc.onchainState, expectedSeqNum, startBlocks) require.Equalf( tc.t, expectedExecutionState, - execStates[seqNum], + execStates[msgSentEvent.SequenceNumber], "wrong execution state for seq nr %d, expected %d, got %d", - seqNum, + msgSentEvent.SequenceNumber, expectedExecutionState, - execStates[seqNum], + execStates[msgSentEvent.SequenceNumber], ) // check the sender latestNonce on the dest, should be incremented @@ -245,3 +396,14 @@ func runMessagingTestCase( return } + +// boolsToBitFlags transforms a list of boolean flags to a *big.Int encoded number. +func boolsToBitFlags(bools []bool) *big.Int { + encodedFlags := big.NewInt(0) + for i := 0; i < len(bools); i++ { + if bools[i] { + encodedFlags.SetBit(encodedFlags, i, 1) + } + } + return encodedFlags +} diff --git a/integration-tests/smoke/ccip_rmn_test.go b/integration-tests/smoke/ccip_rmn_test.go index d058b3c0e72..7372e10550c 100644 --- a/integration-tests/smoke/ccip_rmn_test.go +++ b/integration-tests/smoke/ccip_rmn_test.go @@ -361,15 +361,15 @@ func runRmnTestCase(t *testing.T, tc rmnTestCase) { toChain := chainSelectors[msg.toChainIdx] for i := 0; i < msg.count; i++ { - seqNum := ccipdeployment.TestSendRequest(t, envWithRMN.Env, onChainState, fromChain, toChain, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccipdeployment.TestSendRequest(t, envWithRMN.Env, onChainState, fromChain, toChain, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(onChainState.Chains[toChain].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - expectedSeqNum[toChain] = seqNum - t.Logf("Sent message from chain %d to chain %d with seqNum %d", fromChain, toChain, seqNum) + expectedSeqNum[toChain] = msgSentEvent.SequenceNumber + t.Logf("Sent message from chain %d to chain %d with seqNum %d", fromChain, toChain, msgSentEvent.SequenceNumber) } zero := uint64(0) diff --git a/integration-tests/smoke/ccip_test.go b/integration-tests/smoke/ccip_test.go index 30e66f292a0..b063b26ae8d 100644 --- a/integration-tests/smoke/ccip_test.go +++ b/integration-tests/smoke/ccip_test.go @@ -81,14 +81,14 @@ func TestInitialDeployOnLocal(t *testing.T) { require.NoError(t, err) block := latesthdr.Number.Uint64() startBlocks[dest] = &block - seqNum := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ Receiver: common.LeftPadBytes(state.Chains[dest].Receiver.Address().Bytes(), 32), Data: []byte("hello world"), TokenAmounts: nil, FeeToken: common.HexToAddress("0x0"), ExtraArgs: nil, }) - expectedSeqNum[dest] = seqNum + expectedSeqNum[dest] = msgSentEvent.SequenceNumber } } @@ -230,23 +230,23 @@ func TestTokenTransfer(t *testing.T) { feeToken = common.HexToAddress("0x0") ) if src == tenv.HomeChainSel && dest == tenv.FeedChainSel { - seqNum := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ Receiver: receiver, Data: data, TokenAmounts: tokens[src], FeeToken: feeToken, ExtraArgs: nil, }) - expectedSeqNum[dest] = seqNum + expectedSeqNum[dest] = msgSentEvent.SequenceNumber } else { - seqNum := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ + msgSentEvent := ccdeploy.TestSendRequest(t, e, state, src, dest, false, router.ClientEVM2AnyMessage{ Receiver: receiver, Data: data, TokenAmounts: nil, FeeToken: feeToken, ExtraArgs: nil, }) - expectedSeqNum[dest] = seqNum + expectedSeqNum[dest] = msgSentEvent.SequenceNumber } } }