@chainlink/ccip-sdk 0.97.0 → 1.1.0

package/src/messages.ts

@@ -0,0 +1,278 @@
+import { type BytesLike, dataSlice, hexlify, toBigInt, toNumber } from 'ethers'
+
+import { CCIPMessageDecodeError } from './errors/index.ts'
+import type { ChainFamily } from './types.ts'
+import { decodeAddress, getDataBytes, networkInfo } from './utils.ts'
+
+/** Token transfer in MessageV1 format. */
+export type TokenTransferV1 = {
+  amount: bigint
+  sourcePoolAddress: string
+  sourceTokenAddress: string
+  destTokenAddress: string
+  tokenReceiver: string
+  extraData: string
+}
+
+/** MessageV1 struct matching the Solidity MessageV1Codec format. */
+export type MessageV1 = {
+  sourceChainSelector: bigint
+  destChainSelector: bigint
+  messageNumber: bigint
+  executionGasLimit: number
+  ccipReceiveGasLimit: number
+  finality: number
+  ccvAndExecutorHash: string
+  onRampAddress: string
+  offRampAddress: string
+  sender: string
+  receiver: string
+  destBlob: string
+  tokenTransfer: readonly TokenTransferV1[]
+  data: string
+}
+
+/**
+ * Decodes a TokenTransferV1 from bytes.
+ * @param encoded - The encoded bytes.
+ * @param offset - The starting offset.
+ * @param sourceFamily - The source chain family for source addresses.
+ * @param destFamily - The destination chain family for dest addresses.
+ * @returns The decoded token transfer and the new offset.
+ */
+function decodeTokenTransferV1(
+  encoded: Uint8Array,
+  offset: number,
+  sourceFamily: ChainFamily,
+  destFamily: ChainFamily,
+): { tokenTransfer: TokenTransferV1; newOffset: number } {
+  // version (1 byte)
+  if (offset >= encoded.length) throw new CCIPMessageDecodeError('TOKEN_TRANSFER_VERSION')
+  const version = encoded[offset++]!
+  if (version !== 1) throw new CCIPMessageDecodeError(`Invalid encoding version: ${version}`)
+
+  // amount (32 bytes)
+  if (offset + 32 > encoded.length) throw new CCIPMessageDecodeError('TOKEN_TRANSFER_AMOUNT')
+  const amount = toBigInt(dataSlice(encoded, offset, offset + 32))
+  offset += 32
+
+  // sourcePoolAddressLength and sourcePoolAddress
+  if (offset >= encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_POOL_LENGTH')
+  }
+  const sourcePoolAddressLength = encoded[offset++]!
+  if (offset + sourcePoolAddressLength > encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_POOL_CONTENT')
+  }
+  const sourcePoolAddress = decodeAddress(
+    dataSlice(encoded, offset, offset + sourcePoolAddressLength),
+    sourceFamily,
+  )
+  offset += sourcePoolAddressLength
+
+  // sourceTokenAddressLength and sourceTokenAddress
+  if (offset >= encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_TOKEN_LENGTH')
+  }
+  const sourceTokenAddressLength = encoded[offset++]!
+  if (offset + sourceTokenAddressLength > encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_SOURCE_TOKEN_CONTENT')
+  }
+  const sourceTokenAddress = decodeAddress(
+    dataSlice(encoded, offset, offset + sourceTokenAddressLength),
+    sourceFamily,
+  )
+  offset += sourceTokenAddressLength
+
+  // destTokenAddressLength and destTokenAddress
+  if (offset >= encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_DEST_TOKEN_LENGTH')
+  }
+  const destTokenAddressLength = encoded[offset++]!
+  if (offset + destTokenAddressLength > encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_DEST_TOKEN_CONTENT')
+  }
+  const destTokenAddress = decodeAddress(
+    dataSlice(encoded, offset, offset + destTokenAddressLength),
+    destFamily,
+  )
+  offset += destTokenAddressLength
+
+  // tokenReceiverLength and tokenReceiver
+  if (offset >= encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_TOKEN_RECEIVER_LENGTH')
+  }
+  const tokenReceiverLength = encoded[offset++]!
+  if (offset + tokenReceiverLength > encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_TOKEN_RECEIVER_CONTENT')
+  }
+  const tokenReceiver = decodeAddress(
+    dataSlice(encoded, offset, offset + tokenReceiverLength),
+    destFamily,
+  )
+  offset += tokenReceiverLength
+
+  // extraDataLength and extraData
+  if (offset + 2 > encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_EXTRA_DATA_LENGTH')
+  }
+  const extraDataLength = toNumber(dataSlice(encoded, offset, offset + 2))
+  offset += 2
+  if (offset + extraDataLength > encoded.length) {
+    throw new CCIPMessageDecodeError('TOKEN_TRANSFER_EXTRA_DATA_CONTENT')
+  }
+  const extraData = hexlify(dataSlice(encoded, offset, offset + extraDataLength))
+  offset += extraDataLength
+
+  return {
+    tokenTransfer: {
+      amount,
+      sourcePoolAddress,
+      sourceTokenAddress,
+      destTokenAddress,
+      tokenReceiver,
+      extraData,
+    },
+    newOffset: offset,
+  }
+}
+
+/**
+ * Decodes a MessageV1 from bytes following the v1 protocol format.
+ * @param encodedMessage - The encoded message bytes to decode.
+ * @returns The decoded MessageV1 struct.
+ */
+export function decodeMessageV1(encodedMessage: BytesLike): MessageV1 {
+  const MESSAGE_V1_BASE_SIZE = 77
+  const encoded = getDataBytes(encodedMessage)
+
+  if (encoded.length < MESSAGE_V1_BASE_SIZE) throw new CCIPMessageDecodeError('MESSAGE_MIN_SIZE')
+
+  const version = encoded[0]!
+  if (version !== 1) throw new CCIPMessageDecodeError(`Invalid encoding version: ${version}`)
+
+  // sourceChainSelector (8 bytes, big endian)
+  const sourceChainSelector = toBigInt(dataSlice(encoded, 1, 9))
+
+  // destChainSelector (8 bytes, big endian)
+  const destChainSelector = toBigInt(dataSlice(encoded, 9, 17))
+
+  // Get chain families for address decoding
+  const sourceNetworkInfo = networkInfo(sourceChainSelector)
+  const destNetworkInfo = networkInfo(destChainSelector)
+  const sourceFamily = sourceNetworkInfo.family
+  const destFamily = destNetworkInfo.family
+
+  // messageNumber (8 bytes, big endian)
+  const messageNumber = toBigInt(dataSlice(encoded, 17, 25))
+
+  // executionGasLimit (4 bytes, big endian)
+  const executionGasLimit = toNumber(dataSlice(encoded, 25, 29))
+
+  // ccipReceiveGasLimit (4 bytes, big endian)
+  const ccipReceiveGasLimit = toNumber(dataSlice(encoded, 29, 33))
+
+  // finality (2 bytes, big endian)
+  const finality = toNumber(dataSlice(encoded, 33, 35))
+
+  // ccvAndExecutorHash (32 bytes)
+  const ccvAndExecutorHash = hexlify(dataSlice(encoded, 35, 67))
+
+  // onRampAddressLength and onRampAddress
+  let offset = 67
+  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_ONRAMP_ADDRESS_LENGTH')
+  const onRampAddressLength = encoded[offset++]!
+  if (offset + onRampAddressLength > encoded.length) {
+    throw new CCIPMessageDecodeError('MESSAGE_ONRAMP_ADDRESS_CONTENT')
+  }
+  const onRampAddress = decodeAddress(
+    dataSlice(encoded, offset, offset + onRampAddressLength),
+    sourceFamily,
+  )
+  offset += onRampAddressLength
+
+  // offRampAddressLength and offRampAddress
+  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_OFFRAMP_ADDRESS_LENGTH')
+  const offRampAddressLength = encoded[offset++]!
+  if (offset + offRampAddressLength > encoded.length) {
+    throw new CCIPMessageDecodeError('MESSAGE_OFFRAMP_ADDRESS_CONTENT')
+  }
+  const offRampAddress = decodeAddress(
+    dataSlice(encoded, offset, offset + offRampAddressLength),
+    destFamily,
+  )
+  offset += offRampAddressLength
+
+  // senderLength and sender
+  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_SENDER_LENGTH')
+  const senderLength = encoded[offset++]!
+  if (offset + senderLength > encoded.length) {
+    throw new CCIPMessageDecodeError('MESSAGE_SENDER_CONTENT')
+  }
+  const sender = decodeAddress(dataSlice(encoded, offset, offset + senderLength), sourceFamily)
+  offset += senderLength
+
+  // receiverLength and receiver
+  if (offset >= encoded.length) throw new CCIPMessageDecodeError('MESSAGE_RECEIVER_LENGTH')
+  const receiverLength = encoded[offset++]!
+  if (offset + receiverLength > encoded.length) {
+    throw new CCIPMessageDecodeError('MESSAGE_RECEIVER_CONTENT')
+  }
+  const receiver = decodeAddress(dataSlice(encoded, offset, offset + receiverLength), destFamily)
+  offset += receiverLength
+
+  // destBlobLength and destBlob
+  if (offset + 2 > encoded.length) throw new CCIPMessageDecodeError('MESSAGE_DEST_BLOB_LENGTH')
+  const destBlobLength = toNumber(dataSlice(encoded, offset, offset + 2))
+  offset += 2
+  if (offset + destBlobLength > encoded.length) {
+    throw new CCIPMessageDecodeError('MESSAGE_DEST_BLOB_CONTENT')
+  }
+  const destBlob = hexlify(dataSlice(encoded, offset, offset + destBlobLength))
+  offset += destBlobLength
+
+  // tokenTransferLength and tokenTransfer
+  if (offset + 2 > encoded.length) throw new CCIPMessageDecodeError('MESSAGE_TOKEN_TRANSFER_LENGTH')
+  const tokenTransferLength = toNumber(dataSlice(encoded, offset, offset + 2))
+  offset += 2
+
+  // Decode token transfer, which is either 0 or 1
+  const tokenTransfer: TokenTransferV1[] = []
+  if (tokenTransferLength > 0) {
+    const expectedEnd = offset + tokenTransferLength
+    const result = decodeTokenTransferV1(encoded, offset, sourceFamily, destFamily)
+    tokenTransfer.push(result.tokenTransfer)
+    offset = result.newOffset
+    if (offset !== expectedEnd) throw new CCIPMessageDecodeError('MESSAGE_TOKEN_TRANSFER_CONTENT')
+  }
+
+  // dataLength and data
+  if (offset + 2 > encoded.length) throw new CCIPMessageDecodeError('MESSAGE_DATA_LENGTH')
+  const dataLength = toNumber(dataSlice(encoded, offset, offset + 2))
+  offset += 2
+  if (offset + dataLength > encoded.length) {
+    throw new CCIPMessageDecodeError('MESSAGE_DATA_CONTENT')
+  }
+  const data = hexlify(dataSlice(encoded, offset, offset + dataLength))
+  offset += dataLength
+
+  // Ensure we've consumed all bytes
+  if (offset !== encoded.length) throw new CCIPMessageDecodeError('MESSAGE_FINAL_OFFSET')
+
+  return {
+    sourceChainSelector,
+    destChainSelector,
+    messageNumber,
+    executionGasLimit,
+    ccipReceiveGasLimit,
+    finality,
+    ccvAndExecutorHash,
+    onRampAddress,
+    offRampAddress,
+    sender,
+    receiver,
+    destBlob,
+    tokenTransfer,
+    data,
+  }
+}

package/src/offchain.ts

@@ -1,56 +1,79 @@
-import { keccak256 } from 'ethers'
+import { type BytesLike, dataLength, dataSlice, getBytes, toNumber } from 'ethers'
+import type { PickDeep } from 'type-fest'
 
 import {
   CCIPLbtcAttestationNotApprovedError,
   CCIPLbtcAttestationNotFoundError,
   CCIPUsdcAttestationError,
 } from './errors/index.ts'
-import { NetworkType } from './types.ts'
+import { parseSourceTokenData } from './evm/messages.ts'
+import { type CCIPRequest, type OffchainTokenData, type WithLogger, NetworkType } from './types.ts'
+import { networkInfo } from './utils.ts'
 
 const CIRCLE_API_URL = {
-  mainnet: 'https://iris-api.circle.com/v1',
-  testnet: 'https://iris-api-sandbox.circle.com/v1',
+  mainnet: 'https://iris-api.circle.com',
+  testnet: 'https://iris-api-sandbox.circle.com',
 }
 
 type CctpAttestationResponse =
   | { error: 'string' }
-  | { status: 'pending_confirmations' }
-  | { status: 'complete'; attestation: string }
-
-const LOMBARD_API_URL = {
-  mainnet: 'https://mainnet.prod.lombard.finance',
-  testnet: 'https://gastald-testnet.prod.lombard.finance',
-}
-
-type LombardAttestation =
-  | { status: 'NOTARIZATION_STATUS_SESSION_APPROVED'; message_hash: string; attestation: string }
-  | { status: string; message_hash: string }
-type LombardAttestationsResponse = { attestations: Array<LombardAttestation> }
+  | {
+      messages: {
+        status: 'pending_confirmations' | 'complete'
+        eventNonce?: string
+        attestation: string
+        message: string
+      }[]
+    }
 
 /**
- * Returns the USDC attestation for a given MessageSent Log
- * https://developers.circle.com/stablecoins/reference/getattestation
+ * Returns the USDC attestation for a given tokenAmount.extraData and txHash
+ * https://developers.circle.com/cctp/quickstarts/transfer-usdc-ethereum-to-arc#3-3-retrieve-attestation
  *
- * @param message - payload of USDC MessageSent(bytes message) event
+ * @param opts - CCTPv2 options
  * @param networkType - network type (mainnet or testnet)
- * @returns USDC/CCTP attestation bytes
+ * @returns USDC/CCTP attestation and message
  */
 export async function getUsdcAttestation(
-  message: string,
+  opts: {
+    /** CCTP sourceDomain */
+    sourceDomain: number
+    /** CCTP burn eventNonce */
+    nonce: number
+    /** burn txHash, same as CCIP request */
+    txHash: string
+  },
   networkType: NetworkType,
-): Promise<string> {
-  const msgHash = keccak256(message)
-
+): Promise<{ attestation: string; message: string }> {
+  const { sourceDomain, nonce, txHash } = opts
   const circleApiBaseUrl =
     networkType === NetworkType.Mainnet ? CIRCLE_API_URL.mainnet : CIRCLE_API_URL.testnet
-  const res = await fetch(`${circleApiBaseUrl}/attestations/${msgHash}`)
+  const res = await fetch(
+    `${circleApiBaseUrl}/v2/messages/${sourceDomain}?transactionHash=${txHash}`,
+  )
   const json = (await res.json()) as CctpAttestationResponse
-  if (!('status' in json) || json.status !== 'complete' || !json.attestation) {
-    throw new CCIPUsdcAttestationError(msgHash, json)
+  let att
+  if ('messages' in json) {
+    att = json.messages.find((m) => m.status === 'complete' && m.eventNonce === nonce.toString())
   }
-  return json.attestation
+  if (!att?.message) throw new CCIPUsdcAttestationError(txHash, json, { context: opts })
+  return att
+}
+
+const LOMBARD_API_URL = {
+  mainnet: 'https://mainnet.prod.lombard.finance',
+  testnet: 'https://gastald-testnet.prod.lombard.finance',
 }
 
+type LombardAttestation =
+  | {
+      status: 'NOTARIZATION_STATUS_SESSION_APPROVED'
+      message_hash: string
+      attestation: string
+    }
+  | { status: string; message_hash: string }
+type LombardAttestationsResponse = { attestations: Array<LombardAttestation> }
+
 /**
  * Returns the LBTC attestation for a given payload hash
  *
@@ -86,3 +109,77 @@ export async function getLbtcAttestation(
   }
   return attestation
 }
+
+/**
+ * Fetch CCIPv1 offchain token data for USDC and LBTC tokenAmounts
+ * @param request - CCIPRequest containing tx.hash and message
+ * @returns Promise resolving to an OffchainTokenData for each tokenAmount
+ */
+export async function getOffchainTokenData(
+  request: PickDeep<CCIPRequest, 'tx.hash' | `message`>,
+  { logger = console }: WithLogger = {},
+): Promise<OffchainTokenData[]> {
+  const { networkType } = networkInfo(request.message.sourceChainSelector)
+
+  function looksUsdcData(extraData: BytesLike) {
+    if (dataLength(extraData) !== 64) return
+    // USDCTokenPool's extraData is a packed `SourceTokenDataPayloadV1{uint64 nonce, uint32 sourceDomain}`,
+    // which we need to query CCTPv2 (by sourceDomain and txHash) and to filter by nonce among messages,
+    // if more than one in tx
+    let nonce, sourceDomain
+    try {
+      // those toNumber conversions throw early in case the bytearray don't look like small numbers
+      nonce = toNumber(dataSlice(extraData, 0, 32))
+      sourceDomain = toNumber(dataSlice(extraData, 32, 32 + 32))
+      return { nonce, sourceDomain } // maybe USDC
+    } catch {
+      // not USDC
+    }
+  }
+
+  function looksLbtcData(extraData: BytesLike) {
+    // LBTC returns `message_hash`/`payloadHash` directly as `bytes32 extraData`
+    if (
+      dataLength(extraData) === 32 &&
+      getBytes(extraData, 'extraData').filter(Boolean).length > 20 // looks like a hash
+    )
+      return true
+  }
+
+  return Promise.all(
+    request.message.tokenAmounts.map(async (tokenAmount, i) => {
+      let extraData
+      if ('extraData' in tokenAmount) {
+        extraData = tokenAmount.extraData
+      } else if ('sourceTokenData' in request.message) {
+        // v1.2..v1.5
+        if (dataLength(request.message.sourceTokenData[i]!) === 64) {
+          extraData = request.message.sourceTokenData[i]
+        } else {
+          ;({ extraData } = parseSourceTokenData(request.message.sourceTokenData[i]!))
+        }
+      }
+      if (!extraData) return
+      const usdcOpts = looksUsdcData(extraData)
+      if (usdcOpts) {
+        try {
+          const usdcAttestation = await getUsdcAttestation(
+            { ...usdcOpts, txHash: request.tx.hash },
+            networkType,
+          )
+          return { _tag: 'usdc', extraData, ...usdcAttestation }
+        } catch (err) {
+          // maybe not a USDC transfer, or not ready
+          logger.warn(`❌ CCTP: Failed to fetch attestation for message:`, request.message, err)
+        }
+      } else if (looksLbtcData(extraData)) {
+        try {
+          const lbtcAttestation = await getLbtcAttestation(extraData, networkType)
+          return { _tag: 'lbtc', extraData, ...lbtcAttestation }
+        } catch (err) {
+          logger.warn(`❌ LBTC: Failed to fetch attestation for message:`, extraData, err)
+        }
+      }
+    }),
+  )
+}

package/src/requests.ts

@@ -19,8 +19,8 @@ import {
   type CCIPMessage,
   type CCIPRequest,
   type CCIPVersion,
+  type ChainLog,
   type ChainTransaction,
-  type Log_,
   type MessageInput,
   ChainFamily,
 } from './types.ts'
@@ -78,7 +78,6 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     data_.sourceNetworkInfo?.chainSelector
   if (!sourceChainSelector) throw new CCIPMessageInvalidError(data)
   data_.sourceChainSelector ??= sourceChainSelector
-  data_.nonce ??= 0n
   const sourceFamily = networkInfo(sourceChainSelector).family
 
   const destChainSelector =
@@ -181,7 +180,7 @@ export function decodeMessage(data: string | Uint8Array | Record<string, unknown
   // try bytearray decoding on each supported chain
   for (const chain of Object.values(supportedChains)) {
     try {
-      const decoded = chain.decodeMessage({ data } as unknown as Log_)
+      const decoded = chain.decodeMessage({ data } as unknown as ChainLog)
       if (decoded) return decoded
     } catch (_) {
       // continue

package/src/solana/cleanup.ts

@@ -93,7 +93,7 @@ export async function cleanUpBuffers(
       } catch (err) {
         const info = await connection.getAddressLookupTable(lookupTable)
         if (!info.value) break
-        else if (info.value.state.deactivationSlot < 2n ** 63n)
+        else if (info.value.state.deactivationSlot < BigInt(2) ** BigInt(63))
           deactivationSlot = Number(info.value.state.deactivationSlot)
         logger.warn('Failed to close lookup table', altAddr, err)
       }
@@ -196,7 +196,7 @@ export async function cleanUpBuffers(
             'not owned by us, but by',
             info.value.state.authority?.toBase58(),
           )
-        } else if (info.value.state.deactivationSlot < 2n ** 63n) {
+        } else if (info.value.state.deactivationSlot < BigInt(2) ** BigInt(63)) {
           // non-deactivated have deactivationSlot=MAX_UINT64
           pendingPromises.push(closeAlt(lookupTable, Number(info.value.state.deactivationSlot)))
         } else if (

package/src/solana/exec.ts

@@ -198,7 +198,7 @@ async function buildLookupTableIxs(
     lookupTable: new AddressLookupTableAccount({
       key: altAddr,
       state: {
-        deactivationSlot: 2n ** 64n - 1n,
+        deactivationSlot: BigInt(2) ** BigInt(64) - BigInt(1),
         lastExtendedSlot: recentSlot,
         lastExtendedSlotStartIndex: 0,
         addresses,

package/src/solana/idl/1.6.0/BASE_TOKEN_POOL.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type BaseTokenPool = {
-  version: '1.6.0'
+  version: '1.6.1'
   name: 'base_token_pool'
   instructions: []
   types: [
@@ -868,7 +868,7 @@ export type BaseTokenPool = {
 }
 
 export const IDL: BaseTokenPool = {
-  version: '1.6.0',
+  version: '1.6.1',
   name: 'base_token_pool',
   instructions: [],
   types: [

package/src/solana/idl/1.6.0/BURN_MINT_TOKEN_POOL.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type BurnmintTokenPool = {
-  version: '1.6.0'
+  version: '1.6.1'
   name: 'burnmint_token_pool'
   instructions: [
     {
@@ -951,7 +951,7 @@ export type BurnmintTokenPool = {
 }
 
 export const IDL: BurnmintTokenPool = {
-  version: '1.6.0',
+  version: '1.6.1',
   name: 'burnmint_token_pool',
   instructions: [
     {

package/src/solana/idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type CctpTokenPool = {
-  version: '1.6.0'
+  version: '1.6.1'
   name: 'cctp_token_pool'
   instructions: [
     {
@@ -1376,7 +1376,7 @@ export type CctpTokenPool = {
 }
 
 export const IDL: CctpTokenPool = {
-  version: '1.6.0',
+  version: '1.6.1',
   name: 'cctp_token_pool',
   instructions: [
     {

package/src/solana/idl/1.6.0/CCIP_COMMON.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type CcipCommon = {
-  version: '0.1.1'
+  version: '1.6.1'
   name: 'ccip_common'
   instructions: []
   accounts: [
@@ -102,11 +102,26 @@ export type CcipCommon = {
       name: 'InvalidSVMAddress'
       msg: 'Invalid SVM address'
     },
+    {
+      code: 10011
+      name: 'InvalidTVMAddress'
+      msg: 'Invalid TVM address'
+    },
+    {
+      code: 10012
+      name: 'InvalidAptosAddress'
+      msg: 'Invalid Aptos address'
+    },
+    {
+      code: 10013
+      name: 'InvalidSuiAddress'
+      msg: 'Invalid Sui address'
+    },
   ]
 }
 
 export const IDL: CcipCommon = {
-  version: '0.1.1',
+  version: '1.6.1',
   name: 'ccip_common',
   instructions: [],
   accounts: [
@@ -205,6 +220,21 @@ export const IDL: CcipCommon = {
       name: 'InvalidSVMAddress',
       msg: 'Invalid SVM address',
     },
+    {
+      code: 10011,
+      name: 'InvalidTVMAddress',
+      msg: 'Invalid TVM address',
+    },
+    {
+      code: 10012,
+      name: 'InvalidAptosAddress',
+      msg: 'Invalid Aptos address',
+    },
+    {
+      code: 10013,
+      name: 'InvalidSuiAddress',
+      msg: 'Invalid Sui address',
+    },
   ],
 }
 // generate:end

package/src/solana/idl/1.6.0/CCIP_OFFRAMP.ts

@@ -3,7 +3,7 @@
 //   .then((res) => res.text())
 //   .then((text) => text.trim())
 export type CcipOfframp = {
-  version: '0.1.1'
+  version: '1.6.1'
   name: 'ccip_offramp'
   constants: [
     {
@@ -2748,7 +2748,7 @@ export type CcipOfframp = {
 }
 
 export const IDL: CcipOfframp = {
-  version: '0.1.1',
+  version: '1.6.1',
   name: 'ccip_offramp',
   constants: [
     {

package/src/solana/idl/1.6.0/CCIP_ROUTER.ts

@@ -8,7 +8,7 @@
 //     else throw new Error('isMut is already true, no need for this workaround anymore');
 //   }))
 export type CcipRouter = {
-  version: '0.1.1'
+  version: '1.6.1'
   name: 'ccip_router'
   docs: [
     'The `ccip_router` module contains the implementation of the Cross-Chain Interoperability Protocol (CCIP) Router.',
@@ -2339,7 +2339,7 @@ export type CcipRouter = {
 }
 
 export const IDL: CcipRouter = {
-  version: '0.1.1',
+  version: '1.6.1',
   name: 'ccip_router',
   docs: [
     'The `ccip_router` module contains the implementation of the Cross-Chain Interoperability Protocol (CCIP) Router.',