@chainlink/ccip-sdk 0.95.0 → 0.97.0

package/src/evm/const.ts

@@ -1,3 +1,4 @@
+import { parseAbi } from 'abitype'
 import { type EventFragment, AbiCoder, Interface } from 'ethers'
 
 import Token_ABI from './abi/BurnMintERC677Token.ts'
@@ -10,24 +11,26 @@ import TokenPool_1_6_ABI from './abi/LockReleaseTokenPool_1_6_1.ts'
 import EVM2EVMOffRamp_1_2_ABI from './abi/OffRamp_1_2.ts'
 import EVM2EVMOffRamp_1_5_ABI from './abi/OffRamp_1_5.ts'
 import OffRamp_1_6_ABI from './abi/OffRamp_1_6.ts'
+import OffRamp_2_0_ABI from './abi/OffRamp_2_0.ts'
 import EVM2EVMOnRamp_1_2_ABI from './abi/OnRamp_1_2.ts'
 import EVM2EVMOnRamp_1_5_ABI from './abi/OnRamp_1_5.ts'
 import OnRamp_1_6_ABI from './abi/OnRamp_1_6.ts'
+import OnRamp_2_0_ABI from './abi/OnRamp_2_0.ts'
 import PriceRegistry_1_2_ABI from './abi/PriceRegistry_1_2.ts'
 import Router_ABI from './abi/Router.ts'
 import TokenAdminRegistry_ABI from './abi/TokenAdminRegistry_1_5.ts'
 
 export const defaultAbiCoder = AbiCoder.defaultAbiCoder()
 
-export const DEFAULT_GAS_LIMIT = 200_000n
-export const DEFAULT_APPROVE_GAS_LIMIT = 120_000n
-
 const customErrors = [
   'error NoContract()',
   'error NoGasForCallExactCheck()',
   'error NotEnoughGasForCall()',
+  'error InvalidChain(uint64 chainSelector)',
 ] as const
 
+export const VersionedContractABI = parseAbi(['function typeAndVersion() view returns (string)'])
+
 export const interfaces = {
   Router: new Interface(Router_ABI),
   Token: new Interface(Token_ABI),
@@ -38,9 +41,11 @@ export const interfaces = {
   TokenPool_v1_6: new Interface(TokenPool_1_6_ABI),
   CommitStore_v1_5: new Interface(CommitStore_1_5_ABI),
   CommitStore_v1_2: new Interface(CommitStore_1_2_ABI),
+  OffRamp_v2_0: new Interface(OffRamp_2_0_ABI),
   OffRamp_v1_6: new Interface(OffRamp_1_6_ABI),
   EVM2EVMOffRamp_v1_5: new Interface(EVM2EVMOffRamp_1_5_ABI),
   EVM2EVMOffRamp_v1_2: new Interface(EVM2EVMOffRamp_1_2_ABI),
+  OnRamp_v2_0: new Interface(OnRamp_2_0_ABI),
   OnRamp_v1_6: new Interface(OnRamp_1_6_ABI),
   EVM2EVMOnRamp_v1_5: new Interface(EVM2EVMOnRamp_1_5_ABI),
   EVM2EVMOnRamp_v1_2: new Interface(EVM2EVMOnRamp_1_2_ABI),
@@ -74,3 +79,5 @@ export const commitsFragments = getAllFragmentsMatchingEvents([
   'CommitReportAccepted',
 ])
 export const receiptsFragments = getAllFragmentsMatchingEvents(['ExecutionStateChanged'])
+
+export const CCV_INDEXER_URL = 'https://chainlink-ccv-indexer.ccip.stage.external.griddle.sh/all'

package/src/evm/errors.ts

@@ -118,7 +118,7 @@ export function parseWithFragment(
 
 // join truthy property names, separated by a dot
 function j(...args: string[]): string {
-  return args.filter(Boolean).join('.')
+  return args.reduce((acc, v) => (!v ? acc : acc ? acc + (v.match(/^\w/) ? '.' : '') + v : v), '')
 }
 
 /**
@@ -137,7 +137,11 @@ export function recursiveParseError(
     if (data.length === 0) return key ? [[key, data.toArray()]] : []
     let kv: ReturnType<typeof recursiveParseError>
     try {
-      kv = Object.entries(data.toObject()).map(([k, v]) => [j(key, k), v])
+      const obj = data.toObject()
+      const keys = Object.keys(obj)
+      // eslint-disable-next-line no-restricted-syntax
+      if (keys.length > 0 && keys.every((k) => k.startsWith('_'))) throw new Error('not an obj')
+      kv = Object.entries(obj).map(([k, v]) => [j(key, k), v])
     } catch (_) {
       kv = data.toArray().map((v, i) => [j(key, `[${i}]`), v])
     }

package/src/evm/extra-args.ts

@@ -0,0 +1,360 @@
+import {
+  type BytesLike,
+  concat,
+  dataSlice,
+  encodeBase58,
+  getAddress,
+  hexlify,
+  toBeHex,
+  toBigInt,
+  toNumber,
+  zeroPadValue,
+} from 'ethers'
+
+import {
+  type EVMExtraArgsV1,
+  type EVMExtraArgsV2,
+  type ExtraArgs,
+  type GenericExtraArgsV3,
+  type SVMExtraArgsV1,
+  type SuiExtraArgsV1,
+  EVMExtraArgsV1Tag,
+  EVMExtraArgsV2Tag,
+  GenericExtraArgsV3Tag,
+  SVMExtraArgsV1Tag,
+  SuiExtraArgsV1Tag,
+} from '../extra-args.ts'
+import { DEFAULT_GAS_LIMIT } from '../shared/constants.ts'
+import { getAddressBytes, getDataBytes } from '../utils.ts'
+import { defaultAbiCoder } from './const.ts'
+import { resultToObject } from './types.ts'
+
+// ABI type strings for extra args encoding
+const EVMExtraArgsV1ABI = 'tuple(uint256 gasLimit)'
+const EVMExtraArgsV2ABI = 'tuple(uint256 gasLimit, bool allowOutOfOrderExecution)'
+const SVMExtraArgsV1ABI =
+  'tuple(uint32 computeUnits, uint64 accountIsWritableBitmap, bool allowOutOfOrderExecution, bytes32 tokenReceiver, bytes32[] accounts)'
+const SuiExtraArgsV1ABI =
+  'tuple(uint256 gasLimit, bool allowOutOfOrderExecution, bytes32 tokenReceiver, bytes32[] receiverObjectIds)'
+
+/**
+ * Encodes GenericExtraArgsV3 using tightly packed binary format.
+ *
+ * Binary format:
+ * - tag (4 bytes): 0xa69dd4aa
+ * - gasLimit (4 bytes): uint32 big-endian
+ * - blockConfirmations (2 bytes): uint16 big-endian
+ * - ccvsLength (1 byte): uint8
+ * - For each CCV:
+ *   - ccvAddressLength (1 byte): 0 or 20
+ *   - ccvAddress (0 or 20 bytes)
+ *   - ccvArgsLength (2 bytes): uint16 big-endian
+ *   - ccvArgs (variable)
+ * - executorLength (1 byte): 0 or 20
+ * - executor (0 or 20 bytes)
+ * - executorArgsLength (2 bytes): uint16 big-endian
+ * - executorArgs (variable)
+ * - tokenReceiverLength (1 byte): uint8
+ * - tokenReceiver (variable)
+ * - tokenArgsLength (2 bytes): uint16 big-endian
+ * - tokenArgs (variable)
+ */
+function encodeExtraArgsV3(args: GenericExtraArgsV3): string {
+  const parts: Uint8Array[] = []
+
+  // Tag (4 bytes)
+  parts.push(getDataBytes(GenericExtraArgsV3Tag))
+
+  // gasLimit (4 bytes, uint32 big-endian)
+  parts.push(getDataBytes(toBeHex(args.gasLimit, 4)))
+
+  // blockConfirmations (2 bytes, uint16 big-endian)
+  parts.push(getDataBytes(toBeHex(args.blockConfirmations, 2)))
+
+  // ccvsLength (1 byte)
+  parts.push(new Uint8Array([args.ccvs.length]))
+
+  // For each CCV
+  for (let i = 0; i < args.ccvs.length; i++) {
+    const ccvAddress = args.ccvs[i]!
+    const ccvArgsBytes = getDataBytes(args.ccvArgs[i] ?? '0x')
+
+    if (ccvAddress && ccvAddress !== '' && ccvAddress !== '0x') {
+      // ccvAddressLength = 20
+      parts.push(new Uint8Array([20]))
+      // ccvAddress (20 bytes)
+      parts.push(getDataBytes(ccvAddress))
+    } else {
+      // ccvAddressLength = 0
+      parts.push(new Uint8Array([0]))
+    }
+
+    // ccvArgsLength (2 bytes, uint16 big-endian)
+    parts.push(getDataBytes(toBeHex(ccvArgsBytes.length, 2)))
+
+    // ccvArgs (variable)
+    if (ccvArgsBytes.length > 0) {
+      parts.push(ccvArgsBytes)
+    }
+  }
+
+  // executorLength (1 byte)
+  if (args.executor && args.executor !== '' && args.executor !== '0x') {
+    parts.push(new Uint8Array([20]))
+    parts.push(getDataBytes(args.executor))
+  } else {
+    parts.push(new Uint8Array([0]))
+  }
+
+  // Convert BytesLike fields to Uint8Array
+  const executorArgsBytes = getDataBytes(args.executorArgs)
+  const tokenReceiverBytes = getDataBytes(args.tokenReceiver)
+  const tokenArgsBytes = getDataBytes(args.tokenArgs)
+
+  // executorArgsLength (2 bytes, uint16 big-endian)
+  parts.push(getDataBytes(toBeHex(executorArgsBytes.length, 2)))
+
+  // executorArgs (variable)
+  if (executorArgsBytes.length > 0) {
+    parts.push(executorArgsBytes)
+  }
+
+  // tokenReceiverLength (1 byte)
+  parts.push(new Uint8Array([tokenReceiverBytes.length]))
+
+  // tokenReceiver (variable)
+  if (tokenReceiverBytes.length > 0) {
+    parts.push(tokenReceiverBytes)
+  }
+
+  // tokenArgsLength (2 bytes, uint16 big-endian)
+  parts.push(getDataBytes(toBeHex(tokenArgsBytes.length, 2)))
+
+  // tokenArgs (variable)
+  if (tokenArgsBytes.length > 0) {
+    parts.push(tokenArgsBytes)
+  }
+
+  return hexlify(concat(parts))
+}
+
+/**
+ * Decodes GenericExtraArgsV3 from tightly packed binary format.
+ * @param data - Bytes to decode (without the tag prefix).
+ * @returns Decoded GenericExtraArgsV3 or undefined if parsing fails.
+ */
+function decodeExtraArgsV3(data: Uint8Array): GenericExtraArgsV3 | undefined {
+  let offset = 0
+
+  // gasLimit (4 bytes, uint32 big-endian)
+  if (offset + 4 > data.length) return undefined
+  const gasLimit = toBigInt(data.subarray(offset, offset + 4))
+  offset += 4
+
+  // blockConfirmations (2 bytes, uint16 big-endian)
+  if (offset + 2 > data.length) return undefined
+  const blockConfirmations = toNumber(data.subarray(offset, offset + 2))
+  offset += 2
+
+  // ccvsLength (1 byte)
+  if (offset + 1 > data.length) return undefined
+  const ccvsLength = data[offset]!
+  offset += 1
+
+  const ccvs: string[] = []
+  const ccvArgs: string[] = []
+
+  // For each CCV
+  for (let i = 0; i < ccvsLength; i++) {
+    // ccvAddressLength (1 byte)
+    if (offset + 1 > data.length) return undefined
+    const ccvAddrLen = data[offset]!
+    offset += 1
+
+    // ccvAddress (0 or 20 bytes)
+    if (ccvAddrLen === 20) {
+      if (offset + 20 > data.length) return undefined
+      ccvs.push(getAddress(hexlify(data.slice(offset, offset + 20))))
+      offset += 20
+    } else if (ccvAddrLen === 0) {
+      ccvs.push('')
+    } else {
+      return undefined // Invalid address length
+    }
+
+    // ccvArgsLength (2 bytes, uint16 big-endian)
+    if (offset + 2 > data.length) return undefined
+    const ccvArgsLen = toNumber(data.subarray(offset, offset + 2))
+    offset += 2
+
+    // ccvArgs (variable)
+    if (offset + ccvArgsLen > data.length) return undefined
+    ccvArgs.push(hexlify(data.slice(offset, offset + ccvArgsLen)))
+    offset += ccvArgsLen
+  }
+
+  // executorLength (1 byte)
+  if (offset + 1 > data.length) return undefined
+  const executorLen = data[offset]!
+  offset += 1
+
+  // executor (0 or 20 bytes)
+  let executor = ''
+  if (executorLen === 20) {
+    if (offset + 20 > data.length) return undefined
+    executor = getAddress(hexlify(data.slice(offset, offset + 20)))
+    offset += 20
+  } else if (executorLen !== 0) {
+    return undefined // Invalid executor length
+  }
+
+  // executorArgsLength (2 bytes, uint16 big-endian)
+  if (offset + 2 > data.length) return undefined
+  const executorArgsLen = toNumber(data.subarray(offset, offset + 2))
+  offset += 2
+
+  // executorArgs (variable)
+  if (offset + executorArgsLen > data.length) return undefined
+  const executorArgs = hexlify(data.slice(offset, offset + executorArgsLen))
+  offset += executorArgsLen
+
+  // tokenReceiverLength (1 byte)
+  if (offset + 1 > data.length) return undefined
+  const tokenReceiverLen = data[offset]!
+  offset += 1
+
+  // tokenReceiver (variable)
+  if (offset + tokenReceiverLen > data.length) return undefined
+  const tokenReceiverBytes = data.slice(offset, offset + tokenReceiverLen)
+  offset += tokenReceiverLen
+
+  // Convert tokenReceiver bytes to string
+  let tokenReceiver: string
+  if (tokenReceiverLen === 0) {
+    tokenReceiver = ''
+  } else if (tokenReceiverLen === 20) {
+    // 20 bytes = EVM address, return checksummed
+    tokenReceiver = getAddress(hexlify(tokenReceiverBytes))
+  } else {
+    // Other lengths: return as hex string
+    tokenReceiver = hexlify(tokenReceiverBytes)
+  }
+
+  // tokenArgsLength (2 bytes, uint16 big-endian)
+  if (offset + 2 > data.length) return undefined
+  const tokenArgsLen = toNumber(data.subarray(offset, offset + 2))
+  offset += 2
+
+  // tokenArgs (variable)
+  if (offset + tokenArgsLen > data.length) return undefined
+  const tokenArgs = hexlify(data.slice(offset, offset + tokenArgsLen))
+  offset += tokenArgsLen
+
+  return {
+    gasLimit,
+    blockConfirmations,
+    ccvs,
+    ccvArgs,
+    executor,
+    executorArgs,
+    tokenReceiver,
+    tokenArgs,
+  }
+}
+
+/**
+ * Decodes extra arguments from a CCIP message.
+ * @param extraArgs - Encoded extra arguments bytes.
+ * @returns Decoded extra arguments with tag, or undefined if unknown format.
+ */
+export function decodeExtraArgs(
+  extraArgs: BytesLike,
+):
+  | (EVMExtraArgsV1 & { _tag: 'EVMExtraArgsV1' })
+  | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
+  | (GenericExtraArgsV3 & { _tag: 'GenericExtraArgsV3' })
+  | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
+  | (SuiExtraArgsV1 & { _tag: 'SuiExtraArgsV1' })
+  | undefined {
+  const data = getDataBytes(extraArgs),
+    tag = dataSlice(data, 0, 4)
+  switch (tag) {
+    case EVMExtraArgsV1Tag: {
+      const args = defaultAbiCoder.decode([EVMExtraArgsV1ABI], dataSlice(data, 4))
+      return { ...(resultToObject(args[0]) as EVMExtraArgsV1), _tag: 'EVMExtraArgsV1' }
+    }
+    case EVMExtraArgsV2Tag: {
+      const args = defaultAbiCoder.decode([EVMExtraArgsV2ABI], dataSlice(data, 4))
+      return { ...(resultToObject(args[0]) as EVMExtraArgsV2), _tag: 'EVMExtraArgsV2' }
+    }
+    case GenericExtraArgsV3Tag: {
+      const parsed = decodeExtraArgsV3(data.slice(4))
+      if (!parsed) return undefined
+      return { ...parsed, _tag: 'GenericExtraArgsV3' }
+    }
+    case SVMExtraArgsV1Tag: {
+      const args = defaultAbiCoder.decode([SVMExtraArgsV1ABI], dataSlice(data, 4))
+      const parsed = resultToObject(args[0]) as SVMExtraArgsV1
+      parsed.tokenReceiver = encodeBase58(parsed.tokenReceiver)
+      parsed.accounts = parsed.accounts.map((a: string) => encodeBase58(a))
+      return { ...parsed, _tag: 'SVMExtraArgsV1' }
+    }
+    case SuiExtraArgsV1Tag: {
+      const args = defaultAbiCoder.decode([SuiExtraArgsV1ABI], dataSlice(data, 4))
+      const parsed = resultToObject(args[0]) as SuiExtraArgsV1
+      return {
+        ...parsed,
+        _tag: 'SuiExtraArgsV1',
+      }
+    }
+    default:
+      return undefined
+  }
+}
+
+/**
+ * Encodes extra arguments for a CCIP message.
+ * @param args - Extra arguments to encode.
+ * @returns Encoded extra arguments as hex string.
+ */
+export function encodeExtraArgs(args: ExtraArgs | undefined): string {
+  if (!args) return '0x'
+  if ('blockConfirmations' in args) {
+    // GenericExtraArgsV3 - tightly packed binary encoding
+    return encodeExtraArgsV3(args)
+  } else if ('computeUnits' in args) {
+    return concat([
+      SVMExtraArgsV1Tag,
+      defaultAbiCoder.encode(
+        [SVMExtraArgsV1ABI],
+        [
+          {
+            ...args,
+            tokenReceiver: getAddressBytes(args.tokenReceiver),
+            accounts: args.accounts.map((a) => getAddressBytes(a)),
+          },
+        ],
+      ),
+    ])
+  } else if ('receiverObjectIds' in args) {
+    return concat([
+      SuiExtraArgsV1Tag,
+      defaultAbiCoder.encode(
+        [SuiExtraArgsV1ABI],
+        [
+          {
+            ...args,
+            tokenReceiver: zeroPadValue(getAddressBytes(args.tokenReceiver), 32),
+            receiverObjectIds: args.receiverObjectIds.map((a) => getDataBytes(a)),
+          },
+        ],
+      ),
+    ])
+  } else if ('allowOutOfOrderExecution' in args) {
+    if ((args as Partial<typeof args>).gasLimit == null) args.gasLimit = DEFAULT_GAS_LIMIT
+    return concat([EVMExtraArgsV2Tag, defaultAbiCoder.encode([EVMExtraArgsV2ABI], [args])])
+  } else if ((args as Partial<typeof args>).gasLimit != null) {
+    return concat([EVMExtraArgsV1Tag, defaultAbiCoder.encode([EVMExtraArgsV1ABI], [args])])
+  }
+  return '0x'
+}

package/src/evm/gas.ts

@@ -32,33 +32,34 @@ const ccipReceive = FunctionFragment.from({
 })
 type Any2EVMMessage = Parameters<TypedContract<typeof RouterABI>['routeMessage']>[0]
 
-const transferFragment = interfaces.Token.getFunction('transfer')!
-
 /**
  * Finds suitable token balance slot by simulating a fake transfer between 2 non-existent accounts,
  * with state overrides for the holders' balance, which reverts if override slot is wrong
  */
 const findBalancesSlot = memoize(
-  async function findBalancesSlot_(token: string, provider: JsonRpcApiProvider): Promise<number> {
-    const fakeHolder = getAddress(hexlify(randomBytes(20)))
-    const fakeRecipient = getAddress(hexlify(randomBytes(20)))
-    const fakeAmount = 1e7
+  async function findBalancesSlot_(
+    token: string,
+    provider: JsonRpcApiProvider,
+    holder: string = getAddress(hexlify(randomBytes(20))),
+    recipient: string = getAddress(hexlify(randomBytes(20))),
+  ): Promise<number> {
+    const contract = new Contract(token, interfaces.Token, provider) as unknown as TypedContract<
+      typeof TokenABI
+    >
+    const fakeAmount = (await contract.totalSupply()) + 1n
+    const calldata = interfaces.Token.encodeFunctionData('transfer', [recipient, fakeAmount])
 
-    const calldata = concat([
-      transferFragment.selector,
-      defaultAbiCoder.encode(transferFragment.inputs, [fakeRecipient, fakeAmount]),
-    ])
     let firstErr
     // try range(0..15), but start with most probable 0 (common ERC20) and 9 (USDC)
     for (const slot of [0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15]) {
       try {
         await provider.send('eth_estimateGas', [
-          { from: fakeHolder, to: token, data: calldata },
+          { from: holder, to: token, data: calldata },
           'latest',
           {
             [token]: {
               stateDiff: {
-                [solidityPackedKeccak256(['uint256', 'uint256'], [fakeHolder, slot])]: toBeHex(
+                [solidityPackedKeccak256(['uint256', 'uint256'], [holder, slot])]: toBeHex(
                   fakeAmount,
                   32,
                 ),
@@ -109,7 +110,7 @@ export async function estimateExecGas({
       destAmounts[token] = currentBalance
     }
     destAmounts[token]! += amount
-    const balancesSlot = await findBalancesSlot(token, provider)
+    const balancesSlot = await findBalancesSlot(token, provider, receiver, router)
     stateOverrides[token] = {
       stateDiff: {
         [solidityPackedKeccak256(['uint256', 'uint256'], [receiver, balancesSlot])]: toBeHex(

package/src/evm/hasher.ts

@@ -102,24 +102,39 @@ export function getV16LeafHasher(
   onRamp: string,
   { logger = console }: WithLogger = {},
 ): LeafHasher<typeof CCIPVersion.V1_6> {
+  const onRampBytes = getAddressBytes(onRamp)
+  // Addresses ≤32 bytes (EVM 20B, Aptos/Solana/Sui 32B) are zero-padded to 32 bytes;
+  // Addresses >32 bytes (e.g., TON 36B) are used as raw bytes without padding
+  const onRampForHash = onRampBytes.length <= 32 ? zeroPadValue(onRampBytes, 32) : onRampBytes
+
   const metadataInput = concat([
     ANY_2_EVM_MESSAGE_HASH,
     toBeHex(sourceChainSelector, 32),
     toBeHex(destChainSelector, 32),
-    keccak256(zeroPadValue(getAddressBytes(onRamp), 32)),
+    keccak256(onRampForHash),
   ])
 
   return (message: ReadonlyDeep<CCIPMessage<typeof CCIPVersion.V1_6>>): string => {
     logger.debug('Message', message)
-    const parsedArgs = decodeExtraArgs(
-      message.extraArgs,
-      networkInfo(message.sourceChainSelector).family,
-    )
-    if (
-      !parsedArgs ||
-      (parsedArgs._tag !== 'EVMExtraArgsV1' && parsedArgs._tag !== 'EVMExtraArgsV2')
-    )
-      throw new CCIPExtraArgsInvalidError('EVM', message.extraArgs)
+
+    // Non-EVM sources (e.g., TON) embed gasLimit on the message during parsing,
+    // since their extraArgs format differs. EVM sources decode from extraArgs.
+    let gasLimit: bigint
+    if ('gasLimit' in message) {
+      gasLimit = message.gasLimit
+    } else {
+      const parsedArgs = decodeExtraArgs(
+        message.extraArgs,
+        networkInfo(message.sourceChainSelector).family,
+      )
+      if (
+        !parsedArgs ||
+        (parsedArgs._tag !== 'EVMExtraArgsV1' && parsedArgs._tag !== 'EVMExtraArgsV2')
+      )
+        throw new CCIPExtraArgsInvalidError('EVM', message.extraArgs)
+      gasLimit = parsedArgs.gasLimit
+    }
+
     const tokenAmounts = message.tokenAmounts.map((ta) => ({
       ...ta,
       sourcePoolAddress: zeroPadValue(getAddressBytes(ta.sourcePoolAddress), 32),
@@ -140,16 +155,13 @@ export function getV16LeafHasher(
         'uint256 gasLimit',
         'uint64 nonce',
       ],
-      [
-        message.messageId,
-        message.receiver,
-        message.sequenceNumber,
-        parsedArgs.gasLimit,
-        message.nonce,
-      ],
+      [message.messageId, message.receiver, message.sequenceNumber, gasLimit, message.nonce],
     )
 
-    const sender = zeroPadValue(getAddressBytes(message.sender), 32)
+    const senderBytes = getAddressBytes(message.sender)
+    // Addresses ≤32 bytes (EVM 20B, Aptos/Solana/Sui 32B) are zero-padded to 32 bytes;
+    // Addresses >32 bytes (e.g., TON 36B) are used as raw bytes without padding
+    const sender = senderBytes.length <= 32 ? zeroPadValue(senderBytes, 32) : senderBytes
 
     const packedValues = defaultAbiCoder.encode(
       [