CCIP-4948: Adding new test for disable and enable lane

.github/integration-in-memory-tests.yml

@@ -111,5 +111,13 @@ runner-test-matrix:
       - PR Integration CCIP Tests
     test_cmd: cd integration-tests/ && go test smoke/ccip/ccip_cs_rmn_curse_uncurse_test.go -timeout 10m -test.parallel=1 -count=1 -json
 
+  - id: smoke/ccip/ccip_disable_lane_test.go:*
+    path: integration-tests/smoke/ccip/ccip_disable_lane_test.go
+    test_env_type: in-memory
+    runs_on: ubuntu-latest
+    triggers:
+      - PR Integration CCIP Tests
+    test_cmd: cd integration-tests/smoke/ccip/ && go test ccip_disable_lane_test.go -timeout 10m -test.parallel=1 -count=1 -json
+
 
   # END: CCIP tests

deployment/ccip/changeset/cs_active_candidate_test.go

@@ -76,7 +76,7 @@ func Test_ActiveCandidate(t *testing.T) {
 			Config: changeset.UpdateFeeQuoterDestsConfig{
 				UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{
 					source: {
-						dest: changeset.DefaultFeeQuoterDestChainConfig(),
+						dest: changeset.DefaultFeeQuoterDestChainConfig(true),
 					},
 				},
 			},

deployment/ccip/changeset/cs_chain_contracts.go

@@ -706,12 +706,10 @@ func UpdateOffRampSourcesChangeset(e deployment.Environment, cfg UpdateOffRampSo
 		var args []offramp.OffRampSourceChainConfigArgs
 		for source, update := range updates {
 			router := common.HexToAddress("0x0")
-			if update.IsEnabled {
-				if update.TestRouter {
-					router = s.Chains[chainSel].TestRouter.Address()
-				} else {
-					router = s.Chains[chainSel].Router.Address()
-				}
+			if update.TestRouter {
+				router = s.Chains[chainSel].TestRouter.Address()
+			} else {
+				router = s.Chains[chainSel].Router.Address()
 			}
 			onRamp := s.Chains[source].OnRamp
 			args = append(args, offramp.OffRampSourceChainConfigArgs{
@@ -1115,7 +1113,9 @@ func isOCR3ConfigSetOnOffRamp(
 	return true, nil
 }
 
-func DefaultFeeQuoterDestChainConfig() fee_quoter.FeeQuoterDestChainConfig {
+// DefaultFeeQuoterDestChainConfig returns the default FeeQuoterDestChainConfig
+// with the config enabled/disabled based on the configEnabled flag.
+func DefaultFeeQuoterDestChainConfig(configEnabled bool) fee_quoter.FeeQuoterDestChainConfig {
 	// https://github.com/smartcontractkit/ccip/blob/c4856b64bd766f1ddbaf5d13b42d3c4b12efde3a/contracts/src/v0.8/ccip/libraries/Internal.sol#L337-L337
 	/*
 		```Solidity
@@ -1124,7 +1124,7 @@ func DefaultFeeQuoterDestChainConfig() fee_quoter.FeeQuoterDestChainConfig {
 		```
 	*/
 	evmFamilySelector, _ := hex.DecodeString("2812d52c")
-	return fee_quoter.FeeQuoterDestChainConfig{
+	feeQuoterDestChainConfig := fee_quoter.FeeQuoterDestChainConfig{
 		IsEnabled:                         true,
 		MaxNumberOfTokensPerMsg:           10,
 		MaxDataBytes:                      256,
@@ -1143,4 +1143,8 @@ func DefaultFeeQuoterDestChainConfig() fee_quoter.FeeQuoterDestChainConfig {
 		NetworkFeeUSDCents:                1,
 		ChainFamilySelector:               [4]byte(evmFamilySelector),
 	}
+	if !configEnabled {
+		feeQuoterDestChainConfig.IsEnabled = false
+	}
+	return feeQuoterDestChainConfig
 }

deployment/ccip/changeset/cs_chain_contracts_test.go

@@ -198,8 +198,8 @@ func TestUpdateFQDests(t *testing.T) {
 				}
 			}
 
-			fqCfg1 := changeset.DefaultFeeQuoterDestChainConfig()
-			fqCfg2 := changeset.DefaultFeeQuoterDestChainConfig()
+			fqCfg1 := changeset.DefaultFeeQuoterDestChainConfig(true)
+			fqCfg2 := changeset.DefaultFeeQuoterDestChainConfig(true)
 			fqCfg2.DestGasOverhead = 1000
 			_, err = commonchangeset.ApplyChangesets(t, tenv.Env, tenv.TimelockContracts(t), []commonchangeset.ChangesetApplication{
 				{

deployment/ccip/changeset/testhelpers/test_helpers.go

@@ -482,6 +482,65 @@ func AddLane(
 	require.NoError(t, err)
 }
 
+// RemoveLane removes a lane between the source and destination chains in the deployed environment.
+func RemoveLane(t *testing.T, e *DeployedEnv, src, dest uint64, isTestRouter bool) {
+	var err error
+	apps := []commoncs.ChangesetApplication{
+		{
+			Changeset: commoncs.WrapChangeSet(changeset.UpdateRouterRampsChangeset),
+			Config: changeset.UpdateRouterRampsConfig{
+				UpdatesByChain: map[uint64]changeset.RouterUpdates{
+					// onRamp update on source chain
+					src: {
+						OnRampUpdates: map[uint64]bool{
+							dest: false,
+						},
+					},
+				},
+			},
+		},
+		{
+			Changeset: commoncs.WrapChangeSet(changeset.UpdateFeeQuoterDestsChangeset),
+			Config: changeset.UpdateFeeQuoterDestsConfig{
+				UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{
+					src: {
+						dest: changeset.DefaultFeeQuoterDestChainConfig(false),
+					},
+				},
+			},
+		},
+		{
+			Changeset: commoncs.WrapChangeSet(changeset.UpdateOnRampsDestsChangeset),
+			Config: changeset.UpdateOnRampDestsConfig{
+				UpdatesByChain: map[uint64]map[uint64]changeset.OnRampDestinationUpdate{
+					src: {
+						dest: {
+							IsEnabled:        false,
+							TestRouter:       isTestRouter,
+							AllowListEnabled: false,
+						},
+					},
+				},
+			},
+		},
+		{
+			Changeset: commoncs.WrapChangeSet(changeset.UpdateOffRampSourcesChangeset),
+			Config: changeset.UpdateOffRampSourcesConfig{
+				UpdatesByChain: map[uint64]map[uint64]changeset.OffRampSourceUpdate{
+					dest: {
+						src: {
+							IsEnabled:  false,
+							TestRouter: isTestRouter,
+						},
+					},
+				},
+			},
+		},
+	}
+	e.Env, err = commoncs.ApplyChangesets(t, e.Env, e.TimelockContracts(t), apps)
+	require.NoError(t, err)
+}
+
 func AddLaneWithDefaultPricesAndFeeQuoterConfig(t *testing.T, e *DeployedEnv, state changeset.CCIPOnChainState, from, to uint64, isTestRouter bool) {
 	stateChainFrom := state.Chains[from]
 	AddLane(
@@ -494,7 +553,7 @@ func AddLaneWithDefaultPricesAndFeeQuoterConfig(t *testing.T, e *DeployedEnv, st
 		}, map[common.Address]*big.Int{
 			stateChainFrom.LinkToken.Address(): DefaultLinkPrice,
 			stateChainFrom.Weth9.Address():     DefaultWethPrice,
-		}, changeset.DefaultFeeQuoterDestChainConfig())
+		}, changeset.DefaultFeeQuoterDestChainConfig(true))
 }
 
 // AddLanesForAll adds densely connected lanes for all chains in the environment so that each chain

deployment/environment/crib/ccip_deployer.go

@@ -278,7 +278,7 @@ func DeployCCIPAndAddLanes(ctx context.Context, lggr logger.Logger, envConfig de
 						Config: changeset.UpdateFeeQuoterDestsConfig{
 							UpdatesByChain: map[uint64]map[uint64]fee_quoter.FeeQuoterDestChainConfig{
 								src: {
-									dst: changeset.DefaultFeeQuoterDestChainConfig(),
+									dst: changeset.DefaultFeeQuoterDestChainConfig(true),
 								},
 							},
 						},

integration-tests/smoke/ccip/ccip_add_chain_test.go

@@ -667,7 +667,7 @@ func feeQuoterDestUpdates(t *testing.T, dests []uint64, sources []uint64) (updat
 			if _, ok := updates[source]; !ok {
 				updates[source] = make(map[uint64]fee_quoter.FeeQuoterDestChainConfig)
 			}
-			updates[source][dest] = ccipcs.DefaultFeeQuoterDestChainConfig()
+			updates[source][dest] = ccipcs.DefaultFeeQuoterDestChainConfig(true)
 		}
 	}
 	return

integration-tests/smoke/ccip/ccip_disable_lane_test.go

@@ -0,0 +1,137 @@
+package ccip
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
+	"github.com/smartcontractkit/chainlink-testing-framework/lib/utils/testcontext"
+	"github.com/smartcontractkit/chainlink/deployment"
+	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset"
+	"github.com/smartcontractkit/chainlink/deployment/ccip/changeset/testhelpers"
+	testsetups "github.com/smartcontractkit/chainlink/integration-tests/testsetups/ccip"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/onramp"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/router"
+)
+
+// Intention of this test is to ensure that the lane can be disabled and enabled correctly without disrupting the other lanes.
+func TestDisableLane(t *testing.T) {
+	tenv, _, _ := testsetups.NewIntegrationEnvironment(t,
+		testhelpers.WithNumOfChains(3),
+		testhelpers.WithNumOfUsersPerChain(2),
+	)
+
+	e := tenv.Env
+	state, err := changeset.LoadOnchainState(e)
+	require.NoError(t, err)
+
+	// add all lanes
+	testhelpers.AddLanesForAll(t, &tenv, state)
+
+	var (
+		chains                 = e.AllChainSelectors()
+		chainA, chainB, chainC = chains[0], chains[1], chains[2]
+		expectedSeqNumExec     = make(map[testhelpers.SourceDestPair][]uint64)
+		startBlocks            = make(map[uint64]*uint64)
+		pairs                  = testsetups.GetSourceDestPairs([]uint64{chainA, chainB, chainC})
+
+		sendmessage = func(src, dest uint64, deployer *bind.TransactOpts) (*onramp.OnRampCCIPMessageSent, error) {
+			return testhelpers.DoSendRequest(
+				t,
+				e,
+				state,
+				testhelpers.WithSender(deployer),
+				testhelpers.WithSourceChain(src),
+				testhelpers.WithDestChain(dest),
+				testhelpers.WithTestRouter(false),
+				testhelpers.WithEvm2AnyMessage(router.ClientEVM2AnyMessage{
+					Receiver:     common.LeftPadBytes(state.Chains[chainB].Receiver.Address().Bytes(), 32),
+					Data:         []byte("hello"),
+					TokenAmounts: nil,
+					FeeToken:     common.HexToAddress("0x0"),
+					ExtraArgs:    nil,
+				}))
+		}
+
+		assertSendRequestReverted = func(src, dest uint64, deployer *bind.TransactOpts) {
+			_, err = sendmessage(src, dest, deployer)
+			require.Error(t, err)
+			require.Contains(t, err.Error(), "execution reverted")
+		}
+
+		assertRequestSent = func(src, dest uint64, deployer *bind.TransactOpts) {
+			latestHeader, err := e.Chains[dest].Client.HeaderByNumber(testcontext.Get(t), nil)
+			require.NoError(t, err)
+			block := latestHeader.Number.Uint64()
+			messageSentEvent, err := sendmessage(src, dest, e.Chains[src].DeployerKey)
+			require.NoError(t, err)
+			expectedSeqNumExec[testhelpers.SourceDestPair{
+				SourceChainSelector: src,
+				DestChainSelector:   dest,
+			}] = []uint64{messageSentEvent.SequenceNumber}
+			startBlocks[dest] = &block
+		}
+	)
+
+	// disable lane A -> B
+	testhelpers.RemoveLane(t, &tenv, chainA, chainB, false)
+	// send a message to confirm it is reverted between chainA and chainB
+	assertSendRequestReverted(chainA, chainB, e.Chains[chainA].Users[0])
+	// send a message between chainB and chainA to confirm it is not reverted
+	assertRequestSent(chainB, chainA, e.Chains[chainB].Users[0])
+	// disable lane B -> A
+	testhelpers.RemoveLane(t, &tenv, chainB, chainA, false)
+	assertSendRequestReverted(chainB, chainA, e.Chains[chainB].Users[0])
+
+	// send message in other lanes and ensure they are delivered
+	go func() {
+		assertRequestSent(chainA, chainC, e.Chains[chainA].Users[1])
+		assertRequestSent(chainC, chainA, e.Chains[chainC].Users[1])
+		assertRequestSent(chainB, chainC, e.Chains[chainB].Users[1])
+		assertRequestSent(chainC, chainB, e.Chains[chainC].Users[1])
+	}()
+	// disable lanes between A & C and C & B while requests are getting sent
+	testhelpers.RemoveLane(t, &tenv, chainA, chainC, false)
+	testhelpers.RemoveLane(t, &tenv, chainC, chainA, false)
+	testhelpers.RemoveLane(t, &tenv, chainB, chainC, false)
+	testhelpers.RemoveLane(t, &tenv, chainC, chainB, false)
+	// check fee quoter returns error when the lane is disabled
+	gp, err := state.Chains[chainA].FeeQuoter.GetTokenAndGasPrices(&bind.CallOpts{
+		Context: tests.Context(t),
+	}, state.Chains[chainB].Weth9.Address(), chainB)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "execution reverted")
+	require.Nil(t, gp.GasPriceValue)
+	require.Nil(t, gp.TokenPrice)
+	// confirm that message sent in all lanes are reverted after disabling the lanes
+	for _, pair := range pairs {
+		assertSendRequestReverted(pair.SourceChainSelector, pair.DestChainSelector, e.Chains[pair.SourceChainSelector].Users[0])
+	}
+	// re-enable all the lanes
+	var (
+		linkPrice = deployment.E18Mult(100)
+		wethPrice = deployment.E18Mult(4000)
+	)
+	for _, pair := range pairs {
+		testhelpers.AddLane(t, &tenv, pair.SourceChainSelector, pair.DestChainSelector, false,
+			map[uint64]*big.Int{
+				pair.DestChainSelector: testhelpers.DefaultGasPrice,
+			},
+			map[common.Address]*big.Int{
+				state.Chains[pair.SourceChainSelector].LinkToken.Address(): linkPrice,
+				state.Chains[pair.SourceChainSelector].Weth9.Address():     wethPrice,
+			},
+			changeset.DefaultFeeQuoterDestChainConfig(true))
+	}
+	// send a message in all the lane including re-enabled lanes
+	for _, pair := range pairs {
+		assertRequestSent(pair.SourceChainSelector, pair.DestChainSelector, e.Chains[pair.SourceChainSelector].Users[0])
+	}
+	// confirm all messages are delivered
+	testhelpers.ConfirmExecWithSeqNrsForAll(t, e, state, expectedSeqNumExec, startBlocks)
+}

integration-tests/smoke/ccip/ccip_fee_boosting_test.go

@@ -80,7 +80,7 @@ func Test_CCIPFeeBoosting(t *testing.T) {
 		)
 	t.Log("Adjusted gas price on dest chain:", adjustedGasPriceDest)
 
-	feeQuoterCfg := changeset.DefaultFeeQuoterDestChainConfig()
+	feeQuoterCfg := changeset.DefaultFeeQuoterDestChainConfig(true)
 	// the default adds 10% to the gas price, we want to increase it
 	// to make sure the fee boosting will be finished in proper time for testing
 	feeQuoterCfg.GasMultiplierWeiPerEth = 120e16

integration-tests/smoke/ccip/ccip_reader_test.go

@@ -802,7 +802,7 @@ func Test_GetMedianDataAvailabilityGasConfig(t *testing.T) {
 	boundContracts := map[cciptypes.ChainSelector][]types.BoundContract{}
 	for i, selector := range env.Env.AllChainSelectorsExcluding([]uint64{destChain}) {
 		feeQuoter := state.Chains[selector].FeeQuoter
-		destChainCfg := changeset.DefaultFeeQuoterDestChainConfig()
+		destChainCfg := changeset.DefaultFeeQuoterDestChainConfig(true)
 		//nolint:gosec // disable G115
 		destChainCfg.DestDataAvailabilityOverheadGas = uint32(100 + i)
 		//nolint:gosec // disable G115

integration-tests/testsetups/ccip/test_helpers.go

@@ -721,3 +721,18 @@ func SetNodeConfig(nets []blockchain.EVMNetwork, nodeConfig, commonChain string,
 	tomlStr, err := tomlCfg.TOMLString()
 	return tomlCfg, tomlStr, err
 }
+
+func GetSourceDestPairs(chains []uint64) []testhelpers.SourceDestPair {
+	var pairs []testhelpers.SourceDestPair
+	for i, src := range chains {
+		for j, dest := range chains {
+			if i != j {
+				pairs = append(pairs, testhelpers.SourceDestPair{
+					SourceChainSelector: src,
+					DestChainSelector:   dest,
+				})
+			}
+		}
+	}
+	return pairs
+}