fixes

Author: RensR

chains/evm/deployment/utils/common.go

@@ -43,6 +43,14 @@ func ParseTypeAndVersion(tvStr string) (string, string, error) {
 	return typeAndVersionValues[0], typeAndVersionValues[1], nil
 }
 
+// Wrap returns fmt.Errorf("%s: %w", msg, err) when err is non-nil.
+func Wrap(err error, msg string) error {
+	if err != nil {
+		return fmt.Errorf("%s: %w", msg, err)
+	}
+	return nil
+}
+
 // ValidateEVMAddress validates that a non-empty string is a valid Ethereum hex address.
 // Returns nil if the address is empty (optional field) or valid.
 func ValidateEVMAddress(addr string, fieldName string) error {

chains/evm/deployment/v1_0_0/adapters/token_adapter.go

@@ -1,6 +1,7 @@
 package adapters
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -74,10 +75,10 @@ func (a *EVMTokenBase) DeployTokenVerify(e deployment.Environment, input tokensa
 		return nil
 	}
 
-	if err := utils.ValidateEVMAddress(input.CCIPAdmin, "CCIPAdmin"); err != nil {
-		return err
-	}
-	if err := utils.ValidateEVMAddress(input.ExternalAdmin, "ExternalAdmin"); err != nil {
+	if err := errors.Join(
+		utils.ValidateEVMAddress(input.CCIPAdmin, "CCIPAdmin"),
+		utils.ValidateEVMAddress(input.ExternalAdmin, "ExternalAdmin"),
+	); err != nil {
 		return err
 	}
 

chains/evm/deployment/v1_6_1/sequences/configure_token_pool_for_remote_chain.go

@@ -14,6 +14,7 @@ import (
 	"github.com/smartcontractkit/chainlink-deployments-framework/chain/evm"
 	cldf_ops "github.com/smartcontractkit/chainlink-deployments-framework/operations"
 
+	evmutils "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/utils"
 	"github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v1_0_0/operations/type_and_version"
 	"github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v1_6_1/operations/token_pool"
 	"github.com/smartcontractkit/chainlink-ccip/deployment/tokens"
@@ -37,10 +38,7 @@ func (c ConfigureTokenPoolForRemoteChainInput) Validate(chain evm.Chain) error {
 	if c.ChainSelector != chain.Selector {
 		return fmt.Errorf("chain selector %d does not match chain %s", c.ChainSelector, chain)
 	}
-	if err := c.RemoteChainConfig.Validate(); err != nil {
-		return fmt.Errorf("invalid remote chain config: %w", err)
-	}
-	return nil
+	return evmutils.Wrap(c.RemoteChainConfig.Validate(), "invalid remote chain config")
 }
 
 var ConfigureTokenPoolForRemoteChain = cldf_ops.NewSequence(

chains/evm/deployment/v2_0_0/changesets/remove_fee_tokens.go

@@ -277,10 +277,7 @@ func collectLegacyFeeTokens(
 	}
 
 	feeTokens, err := queryPriceRegistryFeeTokens(e, chain, common.HexToAddress(priceRegistryRef.Address))
-	if err != nil {
-		return nil, err
-	}
-	return feeTokens, nil
+	return feeTokens, err
 }
 
 func queryPriceRegistryFeeTokens(e cldf_deployment.Environment, chain evm.Chain, priceRegistry common.Address) ([]common.Address, error) {

chains/evm/deployment/v2_0_0/create2_factory/create2_factory_test.go

@@ -48,17 +48,12 @@ func sendFunds(ctx context.Context, chain evm.Chain, to common.Address, percenta
 		return err
 	}
 
-	err = chain.Client.SendTransaction(ctx, signedTx)
-	if err != nil {
+	if err = chain.Client.SendTransaction(ctx, signedTx); err != nil {
 		return err
 	}
 
 	_, err = chain.Confirm(signedTx)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return err
 }
 
 func TestCREATE2Factory(t *testing.T) {

chains/evm/deployment/v2_0_0/sequences/deploy_verifier_resolver_via_create2.go

@@ -35,25 +35,26 @@ func validateQualifier(contractType datastore.ContractType, qualifier string) er
 	// Since all resolver types share the same bytecode, the CREATE2 salt is solely determined by the qualifier.
 	// Therefore, we must ensure that different resolver types do not use the same qualifier, or else they would collide on CREATE2 address.
 	// NOTE: DO NOT CHANGE EXISITING VALUES, EVER. Otherwise it will break determistic addresses of already deployed resolvers!!
-	var LombardVerifierQualifier = versioned_verifier_resolver.LombardVerifierResolverType.String()
-	var CCTPVerifierQualifier = versioned_verifier_resolver.CCTPVerifierResolverType.String()
+	lombardVerifierQualifier := versioned_verifier_resolver.LombardVerifierResolverType.String()
+	cctpVerifierQualifier := versioned_verifier_resolver.CCTPVerifierResolverType.String()
 
 	switch contractType {
 	case datastore.ContractType(versioned_verifier_resolver.CommitteeVerifierResolverType):
 		// The CommiteeVerifierResolver is allowed to be any value as multiple commitees can be deployed
 		return nil
 	case datastore.ContractType(versioned_verifier_resolver.CCTPVerifierResolverType):
-		if qualifier != CCTPVerifierQualifier {
-			return fmt.Errorf("qualifier must be %s for %s", CCTPVerifierQualifier, contractType)
+		if qualifier != cctpVerifierQualifier {
+			return fmt.Errorf("qualifier must be %s for %s", cctpVerifierQualifier, contractType)
 		}
+		return nil
 	case datastore.ContractType(versioned_verifier_resolver.LombardVerifierResolverType):
-		if qualifier != LombardVerifierQualifier {
-			return fmt.Errorf("qualifier must be %s for %s", LombardVerifierQualifier, contractType)
+		if qualifier != lombardVerifierQualifier {
+			return fmt.Errorf("qualifier must be %s for %s", lombardVerifierQualifier, contractType)
 		}
+		return nil
 	default:
 		return fmt.Errorf("unsupported contract type: %s", contractType)
 	}
-	return nil
 }
 
 var DeployVerifierResolverViaCREATE2 = cldf_ops.NewSequence(

chains/evm/deployment/v2_0_0/sequences/tokens/configure_token_pool_for_remote_chain.go

@@ -29,6 +29,7 @@ import (
 	"github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v2_0_0/operations/token_pool"
 	v17seq "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v2_0_0/sequences"
 
+	evmutils "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/utils"
 	"github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v1_0_0/operations/type_and_version"
 	token_pool_v150 "github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v1_5_0/operations/burn_mint_token_pool_and_proxy"
 	"github.com/smartcontractkit/chainlink-ccip/chains/evm/deployment/v1_5_0/operations/token_admin_registry"
@@ -62,10 +63,7 @@ func (c ConfigureTokenPoolForRemoteChainInput) Validate(chain evm.Chain) error {
 	if c.ChainSelector != chain.Selector {
 		return fmt.Errorf("chain selector %d does not match chain %s", c.ChainSelector, chain)
 	}
-	if err := c.RemoteChainConfig.Validate(); err != nil {
-		return fmt.Errorf("invalid remote chain config: %w", err)
-	}
-	return nil
+	return evmutils.Wrap(c.RemoteChainConfig.Validate(), "invalid remote chain config")
 }
 
 // activePoolImportedConfig holds config imported from an active pool (< 2.0.0) for upgrade cutover.
@@ -540,10 +538,7 @@ func importConfigFromActivePoolV150(
 		}
 	}
 	cfg, err := fetchRateLimitsAndRemotePoolV150(b, chain, chainSelector, poolForRateLimits, activePool, remoteChainSelector)
-	if err != nil {
-		return nil, err
-	}
-	return cfg, nil
+	return cfg, err
 }
 
 // fetchRateLimitsAndRemotePoolV150 fetches rate limiter state and the single remote pool for the given remote chain

chains/evm/deployment/v2_0_0/sequences/tokens/set_allowed_finality_config_for_token_pools.go

@@ -36,34 +36,33 @@ var SetAllowedFinalityConfigForTokenPools = operations.NewSequence(
 				return sequences.OnChainOutput{}, fmt.Errorf("invalid finality config for pool %s for src %d: %w", pool, input.Selector, err)
 			}
 
-			selector := chain.Selector
 			if !common.IsHexAddress(pool) {
-				return sequences.OnChainOutput{}, fmt.Errorf("invalid pool address for src %d: %s", selector, pool)
+				return sequences.OnChainOutput{}, fmt.Errorf("invalid pool address for src %d: %s", chain.Selector, pool)
 			}
 
 			addr := common.HexToAddress(pool)
 			if addr == (common.Address{}) {
-				return sequences.OnChainOutput{}, fmt.Errorf("pool address cannot be the zero address for src %d", selector)
+				return sequences.OnChainOutput{}, fmt.Errorf("pool address cannot be the zero address for src %d", chain.Selector)
 			}
 
 			currentFinalityConfigReport, err := operations.ExecuteOperation(b, token_pool.GetAllowedFinalityConfig, chain, contract.FunctionInput[struct{}]{
-				ChainSelector: selector,
+				ChainSelector: chain.Selector,
 				Address:       addr,
 				Args:          struct{}{},
 			})
 			if err != nil {
-				return sequences.OnChainOutput{}, fmt.Errorf("failed to get current finality config for token pool at address %s on chain %d: %w", addr.Hex(), selector, err)
+				return sequences.OnChainOutput{}, fmt.Errorf("failed to get current finality config for token pool at address %s on chain %d: %w", addr.Hex(), chain.Selector, err)
 			}
 
 			requestedFinalityConfig := finalityConfig.Raw()
 			if !bytes.Equal(currentFinalityConfigReport.Output[:], requestedFinalityConfig[:]) {
 				write, err := operations.ExecuteOperation(b, token_pool.SetAllowedFinalityConfig, chain, contract.FunctionInput[[4]byte]{
-					ChainSelector: selector,
+					ChainSelector: chain.Selector,
 					Address:       addr,
 					Args:          requestedFinalityConfig,
 				})
 				if err != nil {
-					return sequences.OnChainOutput{}, fmt.Errorf("failed to set finality config for token pool at address %s on chain %d: %w", addr.Hex(), selector, err)
+					return sequences.OnChainOutput{}, fmt.Errorf("failed to set finality config for token pool at address %s on chain %d: %w", addr.Hex(), chain.Selector, err)
 				}
 				writes = append(writes, write.Output)
 			}