@chainlink/ccip-sdk 0.95.0 → 0.97.0

package/src/aptos/index.ts

@@ -1,21 +1,13 @@
 import {
   Aptos,
+  AptosApiError,
   AptosConfig,
   Deserializer,
   Network,
   SimpleTransaction,
   TransactionResponseType,
 } from '@aptos-labs/ts-sdk'
-import {
-  type BytesLike,
-  concat,
-  dataSlice,
-  getBytes,
-  hexlify,
-  isBytesLike,
-  isHexString,
-  zeroPadValue,
-} from 'ethers'
+import { type BytesLike, concat, isBytesLike, isHexString } from 'ethers'
 import { memoize } from 'micro-memoize'
 import type { PickDeep } from 'type-fest'
 
@@ -27,9 +19,11 @@ import {
   type TokenPoolRemote,
   Chain,
 } from '../chain.ts'
+import { generateUnsignedExecuteReport } from './exec.ts'
+import { getAptosLeafHasher } from './hasher.ts'
+import { getUserTxByVersion, getVersionTimestamp, streamAptosLogs } from './logs.ts'
 import { generateUnsignedCcipSend, getFee } from './send.ts'
 import {
-  CCIPAptosAddressInvalidError,
   CCIPAptosExtraArgsEncodingError,
   CCIPAptosExtraArgsV2RequiredError,
   CCIPAptosLogInvalidError,
@@ -40,6 +34,7 @@ import {
   CCIPAptosTransactionTypeInvalidError,
   CCIPAptosWalletInvalidError,
   CCIPError,
+  CCIPTokenPoolChainConfigNotFoundError,
 } from '../errors/index.ts'
 import {
   type EVMExtraArgsV2,
@@ -48,13 +43,14 @@ import {
   EVMExtraArgsV2Tag,
   SVMExtraArgsV1Tag,
 } from '../extra-args.ts'
-import {
-  type UnsignedAptosTx,
-  EVMExtraArgsV2Codec,
-  SVMExtraArgsV1Codec,
-  isAptosAccount,
-} from './types.ts'
+import { type UnsignedAptosTx, isAptosAccount } from './types.ts'
 import type { LeafHasher } from '../hasher/common.ts'
+import {
+  BcsEVMExtraArgsV2Codec,
+  BcsSVMExtraArgsV1Codec,
+  decodeMoveExtraArgs,
+  getMoveAddress,
+} from '../shared/bcs-codecs.ts'
 import { supportedChains } from '../supported-chains.ts'
 import {
   type CCIPExecution,
@@ -62,8 +58,8 @@ import {
   type CCIPRequest,
   type ChainTransaction,
   type CommitReport,
+  type ExecutionInput,
   type ExecutionReceipt,
-  type ExecutionReport,
   type Lane,
   type Log_,
   type NetworkInfo,
@@ -76,14 +72,10 @@ import {
   decodeAddress,
   decodeOnRampAddress,
   getAddressBytes,
-  getDataBytes,
   networkInfo,
   parseTypeAndVersion,
   util,
 } from '../utils.ts'
-import { generateUnsignedExecuteReport } from './exec.ts'
-import { getAptosLeafHasher } from './hasher.ts'
-import { getUserTxByVersion, getVersionTimestamp, streamAptosLogs } from './logs.ts'
 import { getTokenInfo } from './token.ts'
 import type { CCIPMessage_V1_6_EVM } from '../evm/messages.ts'
 import { buildMessageForDest, decodeMessage, getMessagesInBatch } from '../requests.ts'
@@ -96,13 +88,18 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
   static {
     supportedChains[ChainFamily.Aptos] = AptosChain
   }
+  /** Chain family identifier for Aptos networks. */
   static readonly family = ChainFamily.Aptos
+  /** Native token decimals (8 for APT). */
   static readonly decimals = 8
 
   readonly destroy$: Promise<void>
+  /** The Aptos SDK provider for blockchain interactions. */
   provider: Aptos
 
+  /** Retrieves token information for a given token address. */
   getTokenInfo: (token: string) => Promise<TokenInfo>
+  /** @internal */
   _getAccountModulesNames: (address: string) => Promise<string[]>
 
   /**
@@ -177,6 +174,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
    * @param url - RPC URL, Aptos Network enum value or [fullNodeUrl, Network] tuple.
    * @param ctx - context containing logger
    * @returns A new AptosChain instance.
+   * @throws {@link CCIPAptosNetworkUnknownError} if network cannot be determined from URL
    */
   static async fromUrl(
     url: string | Network | readonly [string, Network],
@@ -203,7 +201,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return getVersionTimestamp(this.provider, version)
   }
 
-  /** {@inheritDoc Chain.getTransaction} */
+  /**
+   * {@inheritDoc Chain.getTransaction}
+   * @throws {@link CCIPAptosTransactionInvalidError} if hash/version format is invalid
+   * @throws {@link CCIPAptosTransactionTypeInvalidError} if transaction is not a user transaction
+   */
   async getTransaction(hashOrVersion: string | number): Promise<ChainTransaction> {
     let tx
     if (isHexString(hashOrVersion, 32)) {
@@ -239,17 +241,17 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
   }
 
   /** {@inheritDoc Chain.getMessagesInBatch} */
-  async getMessagesInBatch<
+  override async getMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
       'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
     >,
   >(
     request: R,
-    commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
+    range: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
     opts?: { page?: number },
   ): Promise<R['message'][]> {
-    return getMessagesInBatch(this, request, commit, opts)
+    return getMessagesInBatch(this, request, range, opts)
   }
 
   /** {@inheritDoc Chain.typeAndVersion} */
@@ -289,8 +291,8 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return Promise.resolve(router.split('::')[0] + '::onramp')
   }
 
-  /** {@inheritDoc Chain.getOnRampForOffRamp} */
-  async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
+  /** {@inheritDoc Chain.getOnRampsForOffRamp} */
+  async getOnRampsForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string[]> {
     const [sourceChainConfig] = await this.provider.view<[{ on_ramp: string }]>({
       payload: {
         function:
@@ -298,12 +300,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
         functionArguments: [sourceChainSelector],
       },
     })
-    return decodeAddress(sourceChainConfig.on_ramp, networkInfo(sourceChainSelector).family)
-  }
-
-  /** {@inheritDoc Chain.getCommitStoreForOffRamp} */
-  getCommitStoreForOffRamp(offRamp: string): Promise<string> {
-    return Promise.resolve(offRamp.split('::')[0] + '::offramp')
+    return [decodeAddress(sourceChainConfig.on_ramp, networkInfo(sourceChainSelector).family)]
   }
 
   /** {@inheritDoc Chain.getTokenForTokenPool} */
@@ -339,7 +336,10 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return BigInt(balance)
   }
 
-  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
+  /**
+   * {@inheritDoc Chain.getTokenAdminRegistryFor}
+   * @throws {@link CCIPAptosRegistryTypeInvalidError} if registry type is invalid
+   */
   async getTokenAdminRegistryFor(address: string): Promise<string> {
     const registry = address.split('::')[0] + '::token_admin_registry'
     const [type] = await this.typeAndVersion(registry)
@@ -353,6 +353,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
    * Decodes a CCIP message from an Aptos log event.
    * @param log - Log with data field.
    * @returns Decoded CCIPMessage or undefined if not valid.
+   * @throws {@link CCIPAptosLogInvalidError} if log data format is invalid
    */
   static decodeMessage(log: {
     data: BytesLike | Record<string, unknown>
@@ -382,47 +383,22 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
     | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
     | undefined {
-    const data = getDataBytes(extraArgs),
-      tag = dataSlice(data, 0, 4)
-    switch (tag) {
-      case EVMExtraArgsV2Tag: {
-        const parsed = EVMExtraArgsV2Codec.parse(getBytes(dataSlice(data, 4)))
-        // Aptos serialization of EVMExtraArgsV2: 37 bytes total: 4 tag + 32 LE gasLimit + 1 allowOOOE
-        return {
-          _tag: 'EVMExtraArgsV2',
-          ...parsed,
-          gasLimit: BigInt(parsed.gasLimit),
-        }
-      }
-      case SVMExtraArgsV1Tag: {
-        const parsed = SVMExtraArgsV1Codec.parse(getBytes(dataSlice(data, 4)))
-        // Aptos serialization of SVMExtraArgsV1: 13 bytes total: 4 tag + 8 LE computeUnits
-        return {
-          _tag: 'SVMExtraArgsV1',
-          ...parsed,
-          computeUnits: BigInt(parsed.computeUnits),
-          accountIsWritableBitmap: BigInt(parsed.accountIsWritableBitmap),
-          tokenReceiver: decodeAddress(new Uint8Array(parsed.tokenReceiver), ChainFamily.Solana),
-          accounts: parsed.accounts.map((account) =>
-            decodeAddress(new Uint8Array(account), ChainFamily.Solana),
-          ),
-        }
-      }
-    }
+    return decodeMoveExtraArgs(extraArgs)
   }
 
   /**
    * Encodes extra arguments for Aptos CCIP messages.
    * @param extraArgs - Extra arguments to encode.
    * @returns Encoded extra arguments as hex string.
+   * @throws {@link CCIPAptosExtraArgsEncodingError} if extra args format is not supported
    */
   static encodeExtraArgs(extraArgs: ExtraArgs): string {
     if ('gasLimit' in extraArgs && 'allowOutOfOrderExecution' in extraArgs)
-      return concat([EVMExtraArgsV2Tag, EVMExtraArgsV2Codec.serialize(extraArgs).toBytes()])
+      return concat([EVMExtraArgsV2Tag, BcsEVMExtraArgsV2Codec.serialize(extraArgs).toBytes()])
     else if ('computeUnits' in extraArgs)
       return concat([
         SVMExtraArgsV1Tag,
-        SVMExtraArgsV1Codec.serialize({
+        BcsSVMExtraArgsV1Codec.serialize({
           ...extraArgs,
           computeUnits: Number(extraArgs.computeUnits),
           tokenReceiver: getAddressBytes(extraArgs.tokenReceiver),
@@ -437,6 +413,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
    * @param log - Log with data field.
    * @param lane - Lane info for filtering.
    * @returns Array of CommitReport or undefined if not valid.
+   * @throws {@link CCIPAptosLogInvalidError} if log data format is invalid
    */
   static decodeCommits({ data }: Pick<Log_, 'data'>, lane?: Lane): CommitReport[] | undefined {
     if (!data || typeof data != 'object') throw new CCIPAptosLogInvalidError(data)
@@ -470,6 +447,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
    * Decodes an execution receipt from an Aptos log event.
    * @param log - Log with data field.
    * @returns ExecutionReceipt or undefined if not valid.
+   * @throws {@link CCIPAptosLogInvalidError} if log data format is invalid
    */
   static decodeReceipt({ data }: Pick<Log_, 'data'>): ExecutionReceipt | undefined {
     if (!data || typeof data != 'object') throw new CCIPAptosLogInvalidError(data)
@@ -484,20 +462,10 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
    * Converts bytes to an Aptos address.
    * @param bytes - Bytes to convert.
    * @returns Aptos address (0x-prefixed hex, 32 bytes padded).
+   * @throws {@link CCIPDataFormatUnsupportedError} if bytes length exceeds 32
    */
   static getAddress(bytes: BytesLike | readonly number[]): string {
-    let suffix = ''
-    if (Array.isArray(bytes)) bytes = new Uint8Array(bytes)
-    if (typeof bytes === 'string' && bytes.startsWith('0x')) {
-      const idx = bytes.indexOf('::')
-      if (idx > 0) {
-        suffix = bytes.slice(idx)
-        bytes = bytes.slice(0, idx)
-      }
-    }
-    bytes = getDataBytes(bytes)
-    if (bytes.length > 32) throw new CCIPAptosAddressInvalidError(hexlify(bytes))
-    return zeroPadValue(bytes, 32) + suffix
+    return getMoveAddress(bytes)
   }
 
   /**
@@ -553,7 +521,10 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
-  /** {@inheritDoc Chain.sendMessage} */
+  /**
+   * {@inheritDoc Chain.sendMessage}
+   * @throws {@link CCIPAptosWalletInvalidError} if wallet is not a valid Aptos account
+   */
   async sendMessage(opts: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
     const account = opts.wallet
     if (!isAptosAccount(account)) {
@@ -588,22 +559,30 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
 
-  /** {@inheritDoc Chain.generateUnsignedExecuteReport} */
-  async generateUnsignedExecuteReport({
+  /**
+   * {@inheritDoc Chain.generateUnsignedExecute}
+   * @throws {@link CCIPAptosExtraArgsV2RequiredError} if message missing EVMExtraArgsV2 fields
+   */
+  async generateUnsignedExecute({
     payer,
-    offRamp,
-    execReport,
     ...opts
-  }: Parameters<Chain['generateUnsignedExecuteReport']>[0]): Promise<UnsignedAptosTx> {
-    if (!('allowOutOfOrderExecution' in execReport.message && 'gasLimit' in execReport.message)) {
+  }: Parameters<Chain['generateUnsignedExecute']>[0]): Promise<UnsignedAptosTx> {
+    if (
+      !(
+        'input' in opts &&
+        'message' in opts.input &&
+        'allowOutOfOrderExecution' in opts.input.message &&
+        'gasLimit' in opts.input.message
+      )
+    ) {
       throw new CCIPAptosExtraArgsV2RequiredError()
     }
 
     const tx = await generateUnsignedExecuteReport(
       this.provider,
       payer,
-      offRamp,
-      execReport as ExecutionReport<CCIPMessage_V1_6_EVM>,
+      opts.offRamp,
+      opts.input as ExecutionInput<CCIPMessage_V1_6_EVM>,
       opts,
     )
     return {
@@ -612,14 +591,17 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
-  /** {@inheritDoc Chain.executeReport} */
-  async executeReport(opts: Parameters<Chain['executeReport']>[0]): Promise<CCIPExecution> {
+  /**
+   * {@inheritDoc Chain.execute}
+   * @throws {@link CCIPAptosWalletInvalidError} if wallet is not a valid Aptos account
+   */
+  async execute(opts: Parameters<Chain['execute']>[0]): Promise<CCIPExecution> {
     const account = opts.wallet
     if (!isAptosAccount(account)) {
       throw new CCIPAptosWalletInvalidError(this.constructor.name, util.inspect(opts.wallet))
     }
 
-    const unsignedTx = await this.generateUnsignedExecuteReport({
+    const unsignedTx = await this.generateUnsignedExecute({
       ...opts,
       payer: account.accountAddress.toString(),
     })
@@ -646,9 +628,13 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
    * @returns Parsed data or undefined.
    */
   static parse(data: unknown) {
-    if (isBytesLike(data)) {
-      const parsedExtraArgs = this.decodeExtraArgs(data)
-      if (parsedExtraArgs) return parsedExtraArgs
+    try {
+      if (isBytesLike(data)) {
+        const parsedExtraArgs = this.decodeExtraArgs(data)
+        if (parsedExtraArgs) return parsedExtraArgs
+      }
+    } catch {
+      // ignore
     }
   }
 
@@ -671,7 +657,10 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return page
   }
 
-  /** {@inheritDoc Chain.getRegistryTokenConfig} */
+  /**
+   * {@inheritDoc Chain.getRegistryTokenConfig}
+   * @throws {@link CCIPAptosTokenNotRegisteredError} if token is not registered
+   */
   async getRegistryTokenConfig(
     registry: string,
     token: string,
@@ -697,8 +686,8 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
-  /** {@inheritDoc Chain.getTokenPoolConfigs} */
-  async getTokenPoolConfigs(tokenPool: string): Promise<{
+  /** {@inheritDoc Chain.getTokenPoolConfig} */
+  async getTokenPoolConfig(tokenPool: string): Promise<{
     token: string
     router: string
     typeAndVersion?: string
@@ -749,8 +738,8 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
       tokens: string
     }
     const modulesNames = (await this._getAccountModulesNames(tokenPool))
-      .reverse()
       .filter((name) => name.endsWith('token_pool'))
+      .sort((a, b) => b.length - a.length)
     let firstErr
     for (const name of modulesNames) {
       try {
@@ -789,40 +778,49 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
                   functionArguments: [chain.chainSelector],
                 },
               })
-              const [
-                [remoteToken],
-                [remotePools],
-                [inboundRateLimiterState],
-                [outboundRateLimiterState],
-              ] = await Promise.all([
-                remoteToken$,
-                remotePools$,
-                inboundRateLimiterState$,
-                outboundRateLimiterState$,
-              ])
-              return [
-                chain.name,
-                {
-                  remoteToken: decodeAddress(remoteToken, chain.family),
-                  remotePools: remotePools.map((pool) => decodeAddress(pool, chain.family)),
-                  inboundRateLimiterState: inboundRateLimiterState.is_enabled
-                    ? {
-                        capacity: BigInt(inboundRateLimiterState.capacity),
-                        lastUpdated: Number(inboundRateLimiterState.last_updated),
-                        rate: BigInt(inboundRateLimiterState.rate),
-                        tokens: BigInt(inboundRateLimiterState.tokens),
-                      }
-                    : null,
-                  outboundRateLimiterState: outboundRateLimiterState.is_enabled
-                    ? {
-                        capacity: BigInt(outboundRateLimiterState.capacity),
-                        lastUpdated: Number(outboundRateLimiterState.last_updated),
-                        rate: BigInt(outboundRateLimiterState.rate),
-                        tokens: BigInt(outboundRateLimiterState.tokens),
-                      }
-                    : null,
-                },
-              ] as const
+              try {
+                const [
+                  [remoteToken],
+                  [remotePools],
+                  [inboundRateLimiterState],
+                  [outboundRateLimiterState],
+                ] = await Promise.all([
+                  remoteToken$,
+                  remotePools$,
+                  inboundRateLimiterState$,
+                  outboundRateLimiterState$,
+                ])
+                return [
+                  chain.name,
+                  {
+                    remoteToken: decodeAddress(remoteToken, chain.family),
+                    remotePools: remotePools.map((pool) => decodeAddress(pool, chain.family)),
+                    inboundRateLimiterState: inboundRateLimiterState.is_enabled
+                      ? {
+                          capacity: BigInt(inboundRateLimiterState.capacity),
+                          lastUpdated: Number(inboundRateLimiterState.last_updated),
+                          rate: BigInt(inboundRateLimiterState.rate),
+                          tokens: BigInt(inboundRateLimiterState.tokens),
+                        }
+                      : null,
+                    outboundRateLimiterState: outboundRateLimiterState.is_enabled
+                      ? {
+                          capacity: BigInt(outboundRateLimiterState.capacity),
+                          lastUpdated: Number(outboundRateLimiterState.last_updated),
+                          rate: BigInt(outboundRateLimiterState.rate),
+                          tokens: BigInt(outboundRateLimiterState.tokens),
+                        }
+                      : null,
+                  },
+                ] as const
+              } catch (err) {
+                if (
+                  err instanceof AptosApiError &&
+                  err.message.includes('Key not found in the smart table')
+                )
+                  throw new CCIPTokenPoolChainConfigNotFoundError(tokenPool, tokenPool, chain.name)
+                throw err
+              }
             }),
           ),
         )

package/src/aptos/types.ts

@@ -8,7 +8,7 @@ import { bcs } from '@mysten/bcs'
 import { getBytes } from 'ethers'
 
 import type { CCIPMessage_V1_6_EVM } from '../evm/messages.ts'
-import type { ChainFamily, ExecutionReport } from '../types.ts'
+import type { ChainFamily, ExecutionInput } from '../types.ts'
 import { getAddressBytes } from '../utils.ts'
 
 /** Aptos account type with async transaction signing capability. */
@@ -31,19 +31,6 @@ export function isAptosAccount(account: unknown): account is AptosAsyncAccount {
   )
 }
 
-export const EVMExtraArgsV2Codec = bcs.struct('EVMExtraArgsV2', {
-  gasLimit: bcs.u256(),
-  allowOutOfOrderExecution: bcs.bool(),
-})
-
-export const SVMExtraArgsV1Codec = bcs.struct('SVMExtraArgsV1', {
-  computeUnits: bcs.u32(),
-  accountIsWritableBitmap: bcs.u64(),
-  allowOutOfOrderExecution: bcs.bool(),
-  tokenReceiver: bcs.vector(bcs.u8()),
-  accounts: bcs.vector(bcs.vector(bcs.u8())),
-})
-
 export const ExecutionReportCodec = bcs.struct('ExecutionReport', {
   sourceChainSelector: bcs.u64(),
   messageId: bcs.fixedArray(32, bcs.u8()),
@@ -74,7 +61,7 @@ export const ExecutionReportCodec = bcs.struct('ExecutionReport', {
  * @returns BCS-encoded bytes.
  */
 export function serializeExecutionReport(
-  execReport: ExecutionReport<CCIPMessage_V1_6_EVM>,
+  execReport: ExecutionInput<CCIPMessage_V1_6_EVM>,
 ): Uint8Array {
   const message = execReport.message
   return ExecutionReportCodec.serialize({