change data types

Author: RensR

chains/evm/contracts/ccvs/CCTPVerifier.sol

@@ -242,7 +242,9 @@ contract CCTPVerifier is Ownable2StepMsgSender, BaseVerifier {
     }
 
     DepositForBurnParams memory params = DepositForBurnParams({
-      messageId: messageId, finality: message.finality, finalityThreshold: CCTP_STANDARD_FINALITY_THRESHOLD
+      messageId: messageId,
+      finality: uint32(uint16(message.finality)),
+      finalityThreshold: CCTP_STANDARD_FINALITY_THRESHOLD
     });
 
     // The maximum fee, taken on destination, is a portion of the total amount transferred.

chains/evm/contracts/ccvs/components/BaseVerifier.sol

@@ -241,7 +241,7 @@ abstract contract BaseVerifier is ICrossChainVerifierV1, ITypeAndVersion {
     uint64 destChainSelector,
     Client.EVM2AnyMessage memory, // message
     bytes memory, // extraArgs
-    uint16 // blockConfirmations
+    bytes2 // finalityConfig
   ) external view virtual returns (uint16 feeUSDCents, uint32 gasForVerification, uint32 payloadSizeBytes) {
     if (s_remoteChainConfigs[destChainSelector].router == IRouter(address(0))) {
       revert RemoteChainNotSupported(destChainSelector);

chains/evm/contracts/executor/Executor.sol

@@ -196,12 +196,12 @@ contract Executor is IExecutor, Ownable2StepMsgSender {
 
   /// @notice Validates whether or not the executor can process the message and returns the fee required to do so.
   /// @param destChainSelector The destination chain selector.
-  /// @param blockConfirmationsRequested The requested block confirmations for the message. `0` indicates waiting for finality.
+  /// @param finalityConfig The requested finality encoding for the message. `bytes2(0)` indicates waiting for finality.
   /// @param ccvs The CCVs that are requested on source.
   /// @return usdCentsFee The USD denominated fee for the executor.
   function getFee(
     uint64 destChainSelector,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     address[] calldata ccvs,
     bytes calldata, // extraArgs
     address // feeToken
@@ -210,8 +210,9 @@ contract Executor is IExecutor, Ownable2StepMsgSender {
     if (!remoteChainConfig.enabled) {
       revert InvalidDestChain(destChainSelector);
     }
-    if (blockConfirmationsRequested != 0 && blockConfirmationsRequested < s_dynamicConfig.minBlockConfirmations) {
-      revert Executor__RequestedBlockDepthTooLow(blockConfirmationsRequested, s_dynamicConfig.minBlockConfirmations);
+    uint16 requested = uint16(finalityConfig);
+    if (requested != 0 && requested < s_dynamicConfig.minBlockConfirmations) {
+      revert Executor__RequestedBlockDepthTooLow(requested, s_dynamicConfig.minBlockConfirmations);
     }
 
     if (s_dynamicConfig.ccvAllowlistEnabled) {

chains/evm/contracts/interfaces/IAdvancedPoolHooks.sol

@@ -8,42 +8,42 @@ import {IPoolV2} from "./IPoolV2.sol";
 interface IAdvancedPoolHooks {
   /// @notice Preflight check before lock or burn operation.
   /// @param lockOrBurnIn The lock or burn input parameters.
-  /// @param blockConfirmationsRequested The block confirmations requested.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @param tokenArgs Additional token arguments.
   /// @param amountPostFee The amount after token pool bps-based fees have been deducted.
   /// @dev This function may revert if the preflight check fails. This means the transaction is rolled back on source.
   function preflightCheck(
     Pool.LockOrBurnInV1 calldata lockOrBurnIn,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     bytes calldata tokenArgs,
     uint256 amountPostFee
   ) external;
 
   /// @notice Postflight check before releasing or minting tokens.
   /// @param releaseOrMintIn The release or mint output parameters.
   /// @param localAmount The local amount to be released or minted.
-  /// @param blockConfirmationsRequested The block confirmations requested.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @dev This function may revert if the postflight check fails. This means the transaction is unexecutable until
   /// the issue is resolved.
   function postflightCheck(
     Pool.ReleaseOrMintInV1 calldata releaseOrMintIn,
     uint256 localAmount,
-    uint16 blockConfirmationsRequested
+    bytes2 finalityConfig
   ) external;
 
   /// @notice Returns the set of required CCVs for transfers in a specific direction.
   /// @param localToken The address of the local token.
   /// @param remoteChainSelector The remote chain selector for this transfer.
   /// @param amount The amount being transferred.
-  /// @param blockConfirmationsRequested Requested block confirmations.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @param extraData Direction-specific payload forwarded by the caller (e.g. token args or source pool data).
   /// @param direction The direction of the transfer (Inbound or Outbound).
   /// @return requiredCCVs Set of required CCV addresses.
   function getRequiredCCVs(
     address localToken,
     uint64 remoteChainSelector,
     uint256 amount,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     bytes calldata extraData,
     IPoolV2.MessageDirection direction
   ) external view returns (address[] memory requiredCCVs);

chains/evm/contracts/interfaces/ICrossChainVerifierV1.sol

@@ -38,12 +38,12 @@ interface ICrossChainVerifierV1 is IERC165 {
   /// @param destChainSelector The destination chain selector of the message.
   /// @param message The message to be sent.
   /// @param extraArgs Opaque extra args that can be used by the fee quoter,
-  /// @param blockConfirmations The user requested number of block confirmations.
+  /// @param finalityConfig The user requested finality encoding (see `FinalityCodec`).
   function getFee(
     uint64 destChainSelector,
     Client.EVM2AnyMessage memory message,
     bytes memory extraArgs,
-    uint16 blockConfirmations
+    bytes2 finalityConfig
   ) external view returns (uint16 feeUSDCents, uint32 gasForVerification, uint32 payloadSizeBytes);
 
   /// @notice Message sending, verifier hook.

chains/evm/contracts/interfaces/IExecutor.sol

@@ -9,12 +9,12 @@ interface IExecutor {
 
   /// @notice Validates whether or not the executor can process the message and returns the fee required to do so.
   /// @param destChainSelector The destination chain selector.
-  /// @param blockConfirmationsRequested The requested block confirmations for finality.
+  /// @param finalityConfig The requested finality encoding for the message (see `FinalityCodec`).
   /// @param ccvAddresses Array of CCV addresses that will be used for the message.
   /// @param extraArgs Extra arguments for the executor.
   function getFee(
     uint64 destChainSelector,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     address[] memory ccvAddresses,
     bytes memory extraArgs,
     address feeToken

chains/evm/contracts/interfaces/IPoolV2.sol

@@ -26,52 +26,52 @@ interface IPoolV2 is IERC165 {
 
   /// @notice Lock tokens into the pool or burn the tokens.
   /// @param lockOrBurnIn Encoded data fields for the processing of tokens on the source chain.
-  /// @param blockConfirmationsRequested Requested block confirmations.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @param tokenArgs Additional token arguments.
   /// @return lockOrBurnOut Encoded data fields for the processing of tokens on the destination chain.
   /// @return destTokenAmount The amount of tokens that will be set in TokenTransferV1.amount to be released/mint on destination.
   function lockOrBurn(
     Pool.LockOrBurnInV1 calldata lockOrBurnIn,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     bytes calldata tokenArgs
   ) external returns (Pool.LockOrBurnOutV1 memory lockOrBurnOut, uint256 destTokenAmount);
 
   /// @notice Releases or mints tokens on the destination chain.
   /// @param releaseOrMintIn Encoded data fields for the processing of tokens on the destination chain.
-  /// @param blockConfirmationsRequested Requested block confirmations.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @return releaseOrMintOut Encoded data fields describing the result of the release or mint.
   function releaseOrMint(
     Pool.ReleaseOrMintInV1 calldata releaseOrMintIn,
-    uint16 blockConfirmationsRequested
+    bytes2 finalityConfig
   ) external returns (Pool.ReleaseOrMintOutV1 memory releaseOrMintOut);
 
   /// @notice Returns the set of required CCVs for transfers in a given direction.
   /// @param localToken The address of the local token.
   /// @param remoteChainSelector The chain selector of the remote chain.
   /// @param sourceAmount The source-denominated amount of tokens to be transferred.
-  /// @param blockConfirmationsRequested Requested block confirmations.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @param extraData Direction-specific payload forwarded by the caller (e.g. token args or source pool data).
   /// @param direction Whether CCVs are required for outbound (source -> remote) or inbound (remote -> destination) transfers.
   /// @return requiredCCVs A set of addresses representing the required CCVs.
   function getRequiredCCVs(
     address localToken,
     uint64 remoteChainSelector,
     uint256 sourceAmount,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     bytes calldata extraData,
     MessageDirection direction
   ) external view returns (address[] memory requiredCCVs);
 
   /// @notice Returns the fee overrides for transferring the pool's token to a destination chain.
   /// @param localToken The address of the local token.
   /// @param destChainSelector The chain selector of the destination chain.
-  /// @param blockConfirmationsRequested Requested block confirmations.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @param tokenArgs Additional token argument from the CCIP message.
   /// @return feeConfig the fee configuration for transferring the token to the destination chain.
   function getTokenTransferFeeConfig(
     address localToken,
     uint64 destChainSelector,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     bytes calldata tokenArgs
   ) external view returns (TokenTransferFeeConfig memory feeConfig);
 
@@ -80,7 +80,7 @@ interface IPoolV2 is IERC165 {
   /// @param destChainSelector The destination lane selector.
   /// @param amount The amount of tokens being bridged on this lane.
   /// @param feeToken The token used to pay feeUSDCents.
-  /// @param blockConfirmationsRequested Requested block confirmations.
+  /// @param finalityConfig Requested finality encoding (see `FinalityCodec`).
   /// @param tokenArgs Opaque token arguments supplied by the caller.
   /// @return feeUSDCents Flat fee charged in USD cents (crumbs) for this transfer.
   /// @return destGasOverhead Destination gas charged for accounting in the cost model.
@@ -92,7 +92,7 @@ interface IPoolV2 is IERC165 {
     uint64 destChainSelector,
     uint256 amount,
     address feeToken,
-    uint16 blockConfirmationsRequested,
+    bytes2 finalityConfig,
     bytes calldata tokenArgs
   )
     external

chains/evm/contracts/libraries/ExtraArgsCodec.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.4;
 
+import {FinalityCodec} from "./FinalityCodec.sol";
+
 /// @notice Gas-optimized assembly version of ExtraArgsCodec library.
 library ExtraArgsCodec {
   error InvalidDataLength(EncodingErrorLocation location, uint256 offset);
@@ -14,7 +16,7 @@ library ExtraArgsCodec {
 
   // Base size excludes all variable-length fields (CCV addresses/args, executor address, executorArgs, tokenReceiver,
   // tokenArgs).
-  // Encoding order: tag(4) + gasLimit(4) + blockConfirmations(2) + ccvsLength(1) + executorLength(1) +
+  // Encoding order: tag(4) + gasLimit(4) + finalityConfig(2) + ccvsLength(1) + executorLength(1) +
   // executorArgsLength(2) + tokenReceiverLength(1) + tokenArgsLength(2) = 17 bytes.
   uint256 public constant GENERIC_EXTRA_ARGS_V3_BASE_SIZE = 4 + 4 + 2 + 1 + 1 + 2 + 1 + 2;
   uint256 public constant GENERIC_EXTRA_ARGS_V3_STATIC_LENGTH_SIZE = 4 + 4 + 2 + 1;
@@ -49,7 +51,7 @@ library ExtraArgsCodec {
   /// Static length fields.
   ///   bytes4 tag;                     Version tag.
   ///   uint32 gasLimit;                Gas limit for the callback on the destination chain.
-  ///   uint16 blockConfirmations;      Number of block confirmations to wait for (0 = default finality).
+  ///   bytes2 finalityConfig;           Finality config (see `FinalityCodec`): block depth and/or flags.
   ///   uint8 ccvsLength;               Number of cross-chain verifiers.
   ///
   /// Variable length fields (per CCV, repeated ccvsLength times).
@@ -78,12 +80,9 @@ library ExtraArgsCodec {
     /// There are various ways to estimate the gas required for a callback on the destination chain, depending on the
     /// chain family. Please refer to the documentation for each chain for more details.
     uint32 gasLimit;
-    /// @notice The number of block confirmations to wait for. 0 means the default finality that the CCV considers
-    /// final. Any non-zero value means a block depth. CCVs, Pools and the executor may all reject this value by
-    /// reverting the transaction on the source chain if they do not want to take on the risk of the block confirmations
-    /// specified.
+    /// @notice The finality config, see FinalityCodec for encoding details.
     /// @dev May be zero to indicate waiting for finality is desired.
-    uint16 blockConfirmations;
+    bytes2 finalityConfig;
     /// @notice An array of CCV addresses representing the cross-chain verifiers to be used for the message.
     /// @dev May be empty to specify the default verifier(s) should be used.
     address[] ccvs;
@@ -116,15 +115,15 @@ library ExtraArgsCodec {
     bytes tokenArgs;
   }
 
-  /// @notice Creates a basic encoded GenericExtraArgsV3 with only gasLimit and blockConfirmations set.
+  /// @notice Creates a basic encoded GenericExtraArgsV3 with only gasLimit and block-depth finality set.
   /// @param gasLimit The gas limit for the callback on the destination chain.
-  /// @param blockConfirmations The user requested number of block confirmations.
+  /// @param blockDepth Block depth encoded via `FinalityCodec._encodeBlockDepth` (no upper flag bits).
   /// @return encoded The encoded extra args as bytes. These are ready to be passed into CCIP functions.
   function _getBasicEncodedExtraArgsV3(
     uint32 gasLimit,
-    uint16 blockConfirmations
+    uint16 blockDepth
   ) internal pure returns (bytes memory) {
-    return abi.encodePacked(GENERIC_EXTRA_ARGS_V3_TAG, gasLimit, blockConfirmations, bytes7(0));
+    return abi.encodePacked(GENERIC_EXTRA_ARGS_V3_TAG, gasLimit, FinalityCodec._encodeBlockDepth(blockDepth), bytes7(0));
   }
 
   enum SVMTokenReceiverUsage {
@@ -395,7 +394,7 @@ library ExtraArgsCodec {
     );
 
     bytes memory staticFields =
-      abi.encodePacked(GENERIC_EXTRA_ARGS_V3_TAG, extraArgs.gasLimit, extraArgs.blockConfirmations, uint8(ccvsLength));
+      abi.encodePacked(GENERIC_EXTRA_ARGS_V3_TAG, extraArgs.gasLimit, extraArgs.finalityConfig, uint8(ccvsLength));
 
     uint256 ptr;
     // This block is memory safe because it only writes to the allocated `encoded` bytes.
@@ -462,15 +461,17 @@ library ExtraArgsCodec {
       let gasLimit := calldataload(add(encoded.offset, 4))
       mstore(extraArgs, and(shr(224, gasLimit), 0xFFFFFFFF))
 
-      // Read block confirmations (2 bytes).
-      let blockConfirmations := calldataload(add(encoded.offset, 8))
-      mstore(add(extraArgs, 32), and(shr(240, blockConfirmations), 0xFFFF))
+      // Read finalityConfig (2 bytes).
+      // bytes2 is left-aligned in memory, so mask the top 2 bytes of the loaded word directly
+      // instead of shifting right (which would produce a right-aligned uint that reads back as zero).
+      let finalityWord := calldataload(add(encoded.offset, 8))
+      mstore(add(extraArgs, 32), and(finalityWord, shl(240, 0xFFFF)))
 
       // Read ccvs length (1 byte).
       ccvsLength := byte(0, calldataload(add(encoded.offset, 10)))
     }
 
-    uint256 offset = GENERIC_EXTRA_ARGS_V3_STATIC_LENGTH_SIZE; // Skip tag, gasLimit, blockConfirmations, ccvsLength.
+    uint256 offset = GENERIC_EXTRA_ARGS_V3_STATIC_LENGTH_SIZE; // Skip tag, gasLimit, finalityConfig, ccvsLength.
 
     // Allocate arrays for CCVs.
     extraArgs.ccvs = new address[](ccvsLength);

chains/evm/contracts/libraries/FinalityCodec.sol

@@ -49,8 +49,9 @@ library FinalityCodec {
     return _encodeBlockDepth(blockDepth) | WAIT_FOR_SAFE_FLAG;
   }
 
-  /// @notice Validates requested finality: either `bytes2(0)`, exactly `WAIT_FOR_SAFE_FLAG`, or a pure block depth
-  /// (no flag bits, depth in `1..MAX_BLOCK_DEPTH`). Never a flag combined with a non-zero depth.
+  /// @notice Validates requested finality: either `bytes2(0)`, exactly one set bit among the upper flag bits, or a pure
+  /// block depth (no flag bits, depth in `1..MAX_BLOCK_DEPTH`). Never a flag combined with a non-zero depth. Unknown
+  /// flags are accepted here for wire compatibility; pools/CCVs reject modes they do not implement.
   /// @param encodedFinality The encoded finality params to validate.
   function _validateRequestedFinality(
     bytes2 encodedFinality

chains/evm/contracts/libraries/MessageV1Codec.sol

@@ -90,7 +90,7 @@ library MessageV1Codec {
   ///   uint64 messageNumber;       Auto-incrementing number for the message.
   ///   uint32 executionGasLimit;   Gas limit for message execution on the destination chain.
   ///   uint32 ccipReceiveGasLimit; Gas limit for the user callback on the destination chain.
-  ///   uint16 finality;            Configurable per-message finality value.
+  ///   bytes2 finality;            Configurable per-message finality value (see `FinalityCodec`).
   ///   bytes32 ccvAndExecutorHash; Hash of the verifiers and executor addresses.
   ///
   /// Variable length fields.
@@ -134,7 +134,7 @@ library MessageV1Codec {
     // Gas limit for the user callback on the destination chain.
     uint32 ccipReceiveGasLimit;
     // Configurable per-message finality value.
-    uint16 finality;
+    bytes2 finality;
     // A hash of the verifiers and executor addresses. This is used by the offchain systems to validate the list of CCVs
     // and executor that should be used for this message. This has no meaning on the destination chain ans is not
     // checked against anything.
@@ -428,7 +428,7 @@ library MessageV1Codec {
       message.ccipReceiveGasLimit = uint32(bytes4(encoded[29:33]));
 
       // finality (2 bytes, big endian).
-      message.finality = uint16(bytes2(encoded[33:35]));
+      message.finality = bytes2(encoded[33:35]);
 
       message.ccvAndExecutorHash = bytes32(encoded[35:67]);