@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/aptos/index.ts

@@ -1,11 +1,9 @@
-import util from 'util'
-
 import {
-  Account,
   Aptos,
   AptosConfig,
-  Ed25519PrivateKey,
+  Deserializer,
   Network,
+  SimpleTransaction,
   TransactionResponseType,
 } from '@aptos-labs/ts-sdk'
 import {
@@ -20,17 +18,11 @@ import {
   isHexString,
   zeroPadValue,
 } from 'ethers'
-import moize from 'moize'
+import { memoize } from 'micro-memoize'
+import type { PickDeep, SetRequired } from 'type-fest'
 
-import { ccipSend, getFee } from './send.ts'
-import {
-  type ChainTransaction,
-  type LogFilter,
-  type TokenInfo,
-  type TokenPoolRemote,
-  Chain,
-  ChainFamily,
-} from '../chain.ts'
+import { generateUnsignedCcipSend, getFee } from './send.ts'
+import { type LogFilter, type TokenInfo, type TokenPoolRemote, Chain } from '../chain.ts'
 import {
   type EVMExtraArgsV2,
   type ExtraArgs,
@@ -40,17 +32,20 @@ import {
 } from '../extra-args.ts'
 import type { LeafHasher } from '../hasher/common.ts'
 import { supportedChains } from '../supported-chains.ts'
-import type {
-  AnyMessage,
-  CCIPMessage,
-  CCIPRequest,
-  CommitReport,
-  ExecutionReceipt,
-  ExecutionReport,
-  Lane,
-  Log_,
-  NetworkInfo,
-  OffchainTokenData,
+import {
+  type AnyMessage,
+  type CCIPMessage,
+  type CCIPRequest,
+  type ChainTransaction,
+  type CommitReport,
+  type ExecutionReceipt,
+  type ExecutionReport,
+  type Lane,
+  type Log_,
+  type NetworkInfo,
+  type OffchainTokenData,
+  type WithLogger,
+  ChainFamily,
 } from '../types.ts'
 import {
   convertKeysToCamelCase,
@@ -60,102 +55,138 @@ import {
   getDataBytes,
   networkInfo,
   parseTypeAndVersion,
+  util,
 } from '../utils.ts'
-import { executeReport } from './exec.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 AptosAsyncAccount, EVMExtraArgsV2Codec, SVMExtraArgsV1Codec } from './types.ts'
+import {
+  type UnsignedAptosTx,
+  EVMExtraArgsV2Codec,
+  SVMExtraArgsV1Codec,
+  isAptosAccount,
+} from './types.ts'
 import type { CCIPMessage_V1_6_EVM } from '../evm/messages.ts'
-import { decodeMessage } from '../requests.ts'
-
+import {
+  decodeMessage,
+  fetchAllMessagesInBatch,
+  fetchCCIPRequestById,
+  fetchCCIPRequestsInTx,
+} from '../requests.ts'
+
+/**
+ * Aptos chain implementation supporting Aptos networks.
+ */
 export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
+  static {
+    supportedChains[ChainFamily.Aptos] = AptosChain
+  }
   static readonly family = ChainFamily.Aptos
   static readonly decimals = 8
 
-  readonly network: NetworkInfo<typeof ChainFamily.Aptos>
-  readonly provider: Aptos
+  provider: Aptos
 
   getTokenInfo: (token: string) => Promise<TokenInfo>
   _getAccountModulesNames: (address: string) => Promise<string[]>
 
-  constructor(provider: Aptos, network: NetworkInfo) {
-    if (network.family !== ChainFamily.Aptos) {
-      throw new Error(`Invalid network family: ${network.family}, expected ${ChainFamily.Aptos}`)
-    }
-    super()
+  /**
+   * Creates a new AptosChain instance.
+   * @param provider - Aptos SDK provider instance.
+   * @param network - Network information for this chain.
+   */
+  constructor(provider: Aptos, network: NetworkInfo, ctx?: WithLogger) {
+    super(network, ctx)
 
     this.provider = provider
-    this.network = network
-    this.typeAndVersion = moize.default(this.typeAndVersion.bind(this), {
+    this.typeAndVersion = memoize(this.typeAndVersion.bind(this), {
       maxSize: 100,
       maxArgs: 1,
-      maxAge: 60e3, // 1min
+      expires: 60e3, // 1min
     })
-    this.getTransaction = moize.default(this.getTransaction.bind(this), {
+    this.getTransaction = memoize(this.getTransaction.bind(this), {
       maxSize: 100,
       maxArgs: 1,
     })
-    this.getTokenForTokenPool = moize.default(this.getTokenForTokenPool.bind(this), {
+    this.getTokenForTokenPool = memoize(this.getTokenForTokenPool.bind(this), {
       maxSize: 100,
       maxArgs: 1,
     })
-    this.getTokenInfo = moize.default((token) => getTokenInfo(this.provider, token), {
+    this.getTokenInfo = memoize((token) => getTokenInfo(this.provider, token), {
       maxSize: 100,
       maxArgs: 1,
     })
 
-    this._getAccountModulesNames = moize.default(
+    this._getAccountModulesNames = memoize(
       (address) =>
         this.provider
           .getAccountModules({ accountAddress: address })
           .then((modules) => modules.map(({ abi }) => abi!.name)),
       { maxSize: 100, maxArgs: 1 },
     )
-    this.getWallet = moize.default(this.getWallet.bind(this), { maxSize: 1, maxArgs: 0 })
-    this.provider.getTransactionByVersion = moize.default(
+    this.provider.getTransactionByVersion = memoize(
       this.provider.getTransactionByVersion.bind(this.provider),
       {
         maxSize: 100,
-        isPromise: true,
-        transformArgs: ([arg]) => [(arg as { ledgerVersion: number }).ledgerVersion],
+        async: true,
+        transformKey: ([arg]) => [(arg as { ledgerVersion: number }).ledgerVersion],
       },
     )
   }
 
-  static async fromProvider(provider: Aptos): Promise<AptosChain> {
-    return new AptosChain(provider, networkInfo(`aptos:${await provider.getChainId()}`))
+  /**
+   * Creates an AptosChain instance from an existing Aptos provider.
+   * @param provider - Aptos SDK provider instance.
+   * @param ctx - context containing logger.
+   * @returns A new AptosChain instance.
+   */
+  static async fromProvider(provider: Aptos, ctx?: WithLogger): Promise<AptosChain> {
+    return new AptosChain(provider, networkInfo(`aptos:${await provider.getChainId()}`), ctx)
   }
 
-  static async fromAptosConfig(config: AptosConfig): Promise<AptosChain> {
+  /**
+   * Creates an AptosChain instance from an Aptos configuration.
+   * @param config - Aptos configuration object.
+   * @param ctx - context containing logger.
+   * @returns A new AptosChain instance.
+   */
+  static async fromAptosConfig(config: AptosConfig, ctx?: WithLogger): Promise<AptosChain> {
     const provider = new Aptos(config)
-    return this.fromProvider(provider)
-  }
-
-  static async fromUrl(url: string | Network, network?: Network): Promise<AptosChain> {
-    if (network) {
-      // pass
+    return this.fromProvider(provider, ctx)
+  }
+
+  /**
+   * Creates an AptosChain instance from a URL or network identifier.
+   * @param url - RPC URL, Aptos Network enum value or [fullNodeUrl, Network] tuple.
+   * @param ctx - context containing logger
+   * @returns A new AptosChain instance.
+   */
+  static async fromUrl(
+    url: string | Network | readonly [string, Network],
+    ctx?: WithLogger,
+  ): Promise<AptosChain> {
+    let network: Network
+    if (Array.isArray(url)) {
+      ;[url, network] = url
     } else if (Object.values(Network).includes(url as Network)) network = url as Network
     else if (url.includes('mainnet')) network = Network.MAINNET
     else if (url.includes('testnet')) network = Network.TESTNET
     else if (url.includes('local')) network = Network.LOCAL
-    else throw new Error(`Unknown Aptos network: ${url}`)
+    else throw new Error(`Unknown Aptos network: ${util.inspect(url)}`)
     const config: AptosConfig = new AptosConfig({
       network,
-      fullnode: url.includes('://') ? url : undefined,
+      fullnode: typeof url === 'string' && url.includes('://') ? url : undefined,
       // indexer: url.includes('://') ? `${url}/v1/graphql` : undefined,
     })
-    return this.fromAptosConfig(config)
-  }
-
-  async destroy(): Promise<void> {
-    // Nothing to cleanup for Aptos implementation
+    return this.fromAptosConfig(config, ctx)
   }
 
+  /** {@inheritDoc Chain.getBlockTimestamp} */
   async getBlockTimestamp(version: number | 'finalized'): Promise<number> {
     return getVersionTimestamp(this.provider, version)
   }
 
+  /** {@inheritDoc Chain.getTransaction} */
   async getTransaction(hashOrVersion: string | number): Promise<ChainTransaction> {
     let tx
     if (isHexString(hashOrVersion, 32)) {
@@ -170,7 +201,6 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     if (tx.type !== TransactionResponseType.User) throw new Error('Invalid transaction type')
 
     return {
-      chain: this,
       hash: tx.hash,
       blockNumber: +tx.version,
       from: tx.sender,
@@ -186,46 +216,81 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
+  /** {@inheritDoc Chain.getLogs} */
   async *getLogs(opts: LogFilter & { versionAsHash?: boolean }): AsyncIterableIterator<Log_> {
     yield* streamAptosLogs(this.provider, opts)
   }
 
-  async typeAndVersion(
-    address: string,
-  ): Promise<
-    | [type_: string, version: string, typeAndVersion: string]
-    | [type_: string, version: string, typeAndVersion: string, suffix: string]
-  > {
+  /** {@inheritDoc Chain.fetchRequestsInTx} */
+  async fetchRequestsInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]> {
+    return fetchCCIPRequestsInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx)
+  }
+
+  /** {@inheritDoc Chain.fetchRequestById} */
+  override async fetchRequestById(
+    messageId: string,
+    onRamp?: string,
+    opts?: { page?: number },
+  ): Promise<CCIPRequest> {
+    if (!onRamp) throw new Error('onRamp is required')
+    return fetchCCIPRequestById(this, messageId, {
+      address: await this.getOnRampForRouter(onRamp, 0n),
+      ...opts,
+    })
+  }
+
+  /** {@inheritDoc Chain.fetchAllMessagesInBatch} */
+  async fetchAllMessagesInBatch<
+    R extends PickDeep<
+      CCIPRequest,
+      'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.header.sequenceNumber'
+    >,
+  >(
+    request: R,
+    commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
+    opts?: { page?: number },
+  ): Promise<R['message'][]> {
+    return fetchAllMessagesInBatch(this, request, commit, opts)
+  }
+
+  /** {@inheritDoc Chain.typeAndVersion} */
+  async typeAndVersion(address: string) {
+    // requires address with `::<module>` suffix
     const [typeAndVersion] = await this.provider.view<[string]>({
       payload: {
         function: `${address}::type_and_version` as `${string}::${string}::type_and_version`,
       },
     })
-
     return parseTypeAndVersion(typeAndVersion)
   }
 
+  /** {@inheritDoc Chain.getRouterForOnRamp} */
   getRouterForOnRamp(onRamp: string, _destChainSelector: bigint): Promise<string> {
     // router is same package as onramp, changing only module
     return Promise.resolve(onRamp.split('::')[0] + '::router')
   }
 
+  /** {@inheritDoc Chain.getRouterForOffRamp} */
   getRouterForOffRamp(offRamp: string, _sourceChainSelector: bigint): Promise<string> {
     return Promise.resolve(offRamp.split('::')[0] + '::router')
   }
 
+  /** {@inheritDoc Chain.getNativeTokenForRouter} */
   getNativeTokenForRouter(_router: string): Promise<string> {
     return Promise.resolve('0xa')
   }
 
+  /** {@inheritDoc Chain.getOffRampsForRouter} */
   getOffRampsForRouter(router: string, _sourceChainSelector: bigint): Promise<string[]> {
     return Promise.resolve([router.split('::')[0] + '::offramp'])
   }
 
+  /** {@inheritDoc Chain.getOnRampForRouter} */
   getOnRampForRouter(router: string, _destChainSelector: bigint): Promise<string> {
     return Promise.resolve(router.split('::')[0] + '::onramp')
   }
 
+  /** {@inheritDoc Chain.getOnRampForOffRamp} */
   async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
     const [sourceChainConfig] = await this.provider.view<[{ on_ramp: string }]>({
       payload: {
@@ -237,10 +302,12 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return decodeAddress(sourceChainConfig.on_ramp, networkInfo(sourceChainSelector).family)
   }
 
+  /** {@inheritDoc Chain.getCommitStoreForOffRamp} */
   getCommitStoreForOffRamp(offRamp: string): Promise<string> {
     return Promise.resolve(offRamp.split('::')[0] + '::offramp')
   }
 
+  /** {@inheritDoc Chain.getTokenForTokenPool} */
   async getTokenForTokenPool(tokenPool: string): Promise<string> {
     const modulesNames = (await this._getAccountModulesNames(tokenPool))
       .reverse()
@@ -261,6 +328,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     throw firstErr ?? new Error(`Could not view 'get_token' in ${tokenPool}`)
   }
 
+  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
   async getTokenAdminRegistryFor(address: string): Promise<string> {
     const registry = address.split('::')[0] + '::token_admin_registry'
     const [type] = await this.typeAndVersion(registry)
@@ -270,25 +338,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return registry
   }
 
-  static getWallet(_opts: { wallet?: unknown } = {}): Promise<AptosAsyncAccount> {
-    return Promise.reject(new Error('TODO according to your environment'))
-  }
-
-  // cached
-  async getWallet(opts: { wallet?: unknown } = {}): Promise<AptosAsyncAccount> {
-    if (isBytesLike(opts.wallet)) {
-      return Account.fromPrivateKey({
-        privateKey: new Ed25519PrivateKey(opts.wallet, false),
-      })
-    }
-    return (this.constructor as typeof AptosChain).getWallet(opts)
-  }
-
-  async getWalletAddress(opts?: { wallet?: unknown }): Promise<string> {
-    return (await this.getWallet(opts)).accountAddress.toString()
-  }
-
-  // Static methods for decoding
+  /**
+   * Decodes a CCIP message from an Aptos log event.
+   * @param log - Log with data field.
+   * @returns Decoded CCIPMessage or undefined if not valid.
+   */
   static decodeMessage(log: {
     data: BytesLike | Record<string, unknown>
   }): CCIPMessage | undefined {
@@ -306,7 +360,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
-  // decodes an Aptos-generated extraArgs, destinated *to* other chains (EVM, Solana, etc)
+  /**
+   * Decodes extra arguments from Aptos CCIP messages.
+   * @param extraArgs - Encoded extra arguments bytes.
+   * @returns Decoded extra arguments or undefined if unknown format.
+   */
   static decodeExtraArgs(
     extraArgs: BytesLike,
   ):
@@ -342,7 +400,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
-  // encodes extraArgs destinated *to other* chains (EVM, Solana, etc), using Aptos-specific encoding (i.e. *from* Aptos)
+  /**
+   * Encodes extra arguments for Aptos CCIP messages.
+   * @param extraArgs - Extra arguments to encode.
+   * @returns Encoded extra arguments as hex string.
+   */
   static encodeExtraArgs(extraArgs: ExtraArgs): string {
     if ('gasLimit' in extraArgs && 'allowOutOfOrderExecution' in extraArgs)
       return concat([EVMExtraArgsV2Tag, EVMExtraArgsV2Codec.serialize(extraArgs).toBytes()])
@@ -359,6 +421,12 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     throw new Error('Aptos can only encode EVMExtraArgsV2 & SVMExtraArgsV1')
   }
 
+  /**
+   * Decodes commit reports from an Aptos log event.
+   * @param log - Log with data field.
+   * @param lane - Lane info for filtering.
+   * @returns Array of CommitReport or undefined if not valid.
+   */
   static decodeCommits({ data }: Pick<Log_, 'data'>, lane?: Lane): CommitReport[] | undefined {
     if (!data || typeof data != 'object') throw new Error('invalid aptos log')
     const data_ = data as { blessed_merkle_roots: unknown[]; unblessed_merkle_roots: unknown[] }
@@ -384,6 +452,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return commits
   }
 
+  /**
+   * Decodes an execution receipt from an Aptos log event.
+   * @param log - Log with data field.
+   * @returns ExecutionReceipt or undefined if not valid.
+   */
   static decodeReceipt({ data }: Pick<Log_, 'data'>): ExecutionReceipt | undefined {
     if (!data || typeof data != 'object') throw new Error('invalid aptos log')
     const data_ = data as { message_id: string; state: number }
@@ -393,6 +466,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     ) as ExecutionReceipt
   }
 
+  /**
+   * Converts bytes to an Aptos address.
+   * @param bytes - Bytes to convert.
+   * @returns Aptos address (0x-prefixed hex, 32 bytes padded).
+   */
   static getAddress(bytes: BytesLike): string {
     let suffix = ''
     if (typeof bytes === 'string' && !bytes.startsWith('0x')) {
@@ -408,55 +486,152 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return zeroPadValue(bytes, 32) + suffix
   }
 
-  static getDestLeafHasher(lane: Lane): LeafHasher {
+  /**
+   * Gets the leaf hasher for Aptos destination chains.
+   * @param lane - Lane configuration.
+   * @returns Leaf hasher function.
+   */
+  static getDestLeafHasher(lane: Lane, _ctx?: WithLogger): LeafHasher {
     return getAptosLeafHasher(lane)
   }
 
+  /** {@inheritDoc Chain.getFee} */
   async getFee(router: string, destChainSelector: bigint, message: AnyMessage): Promise<bigint> {
     return getFee(this.provider, router, destChainSelector, message)
   }
 
+  /** generate raw/unsigned `ccip_send` transaction */
+  async generateUnsignedSendMessage(
+    sender: string,
+    router: string,
+    destChainSelector: bigint,
+    message: AnyMessage & { fee?: bigint },
+    opts: { approveMax?: boolean },
+  ): Promise<UnsignedAptosTx> {
+    if (!message.fee) message.fee = await this.getFee(router, destChainSelector, message)
+    const tx = await generateUnsignedCcipSend(
+      this.provider,
+      sender,
+      router,
+      destChainSelector,
+      message as SetRequired<typeof message, 'fee'>,
+      opts,
+    )
+    return {
+      family: ChainFamily.Aptos,
+      transactions: [tx],
+    }
+  }
+
+  /** {@inheritDoc Chain.sendMessage} */
   async sendMessage(
     router: string,
     destChainSelector: bigint,
-    message: AnyMessage & { fee: bigint },
-    opts?: { wallet?: unknown; approveMax?: boolean },
-  ): Promise<ChainTransaction> {
-    const account = await this.getWallet(opts)
+    message: AnyMessage & { fee?: bigint },
+    opts: { wallet: unknown; approveMax?: boolean },
+  ): Promise<CCIPRequest> {
+    const account = opts.wallet
+    if (!isAptosAccount(account)) {
+      throw new Error(
+        `${this.constructor.name}.sendMessage requires an Aptos account wallet, got=${util.inspect(opts.wallet)}`,
+      )
+    }
+
+    const unsignedTx = await this.generateUnsignedSendMessage(
+      account.accountAddress.toString(),
+      router,
+      destChainSelector,
+      message,
+      opts,
+    )
+    const unsigned = SimpleTransaction.deserialize(new Deserializer(unsignedTx.transactions[0]))
 
-    const hash = await ccipSend(this.provider, account, router, destChainSelector, message)
+    // Sign and submit the transaction
+    const signed = await account.signTransactionWithAuthenticator(unsigned)
+    const pendingTxn = await this.provider.transaction.submit.simple({
+      transaction: unsigned,
+      senderAuthenticator: signed,
+    })
 
-    // Return the ChainTransaction by fetching it
-    return this.getTransaction(hash)
+    // Wait for the transaction to be confirmed
+    const { hash } = await this.provider.waitForTransaction({
+      transactionHash: pendingTxn.hash,
+    })
+
+    // Return the CCIPRequest by fetching it
+    return (await this.fetchRequestsInTx(await this.getTransaction(hash)))[0]
   }
 
+  /** {@inheritDoc Chain.fetchOffchainTokenData} */
   fetchOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
     // default offchain token data
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
 
-  async executeReport(
+  /** generate raw/unsigned `manually_execute` transaction data */
+  async generateUnsignedExecuteReport(
+    payer: string,
     offRamp: string,
     execReport: ExecutionReport,
-    opts?: { wallet?: unknown; gasLimit?: number },
-  ): Promise<ChainTransaction> {
-    const account = await this.getWallet(opts)
-
+    opts: { gasLimit?: number },
+  ): Promise<UnsignedAptosTx> {
     if (!('allowOutOfOrderExecution' in execReport.message && 'gasLimit' in execReport.message)) {
       throw new Error('Aptos expects EVMExtraArgsV2 reports')
     }
 
-    const hash = await executeReport(
+    const tx = await generateUnsignedExecuteReport(
       this.provider,
-      account,
+      payer,
       offRamp,
       execReport as ExecutionReport<CCIPMessage_V1_6_EVM>,
       opts,
     )
+    return {
+      family: ChainFamily.Aptos,
+      transactions: [tx],
+    }
+  }
+
+  /** {@inheritDoc Chain.executeReport} */
+  async executeReport(
+    offRamp: string,
+    execReport: ExecutionReport,
+    opts: { wallet: unknown; gasLimit?: number },
+  ): Promise<ChainTransaction> {
+    const account = opts.wallet
+    if (!isAptosAccount(account)) {
+      throw new Error(
+        `${this.constructor.name}.sendMessage requires an Aptos account wallet, got=${util.inspect(opts.wallet)}`,
+      )
+    }
+
+    const unsignedTx = await this.generateUnsignedExecuteReport(
+      account.accountAddress.toString(),
+      offRamp,
+      execReport,
+      opts,
+    )
+    const unsigned = SimpleTransaction.deserialize(new Deserializer(unsignedTx.transactions[0]))
 
+    // Sign and submit the transaction
+    const signed = await account.signTransactionWithAuthenticator(unsigned)
+    const pendingTxn = await this.provider.transaction.submit.simple({
+      transaction: unsigned,
+      senderAuthenticator: signed,
+    })
+
+    // Wait for the transaction to be confirmed
+    const { hash } = await this.provider.waitForTransaction({
+      transactionHash: pendingTxn.hash,
+    })
     return this.getTransaction(hash)
   }
 
+  /**
+   * Parses raw Aptos data into typed structures.
+   * @param data - Raw data to parse.
+   * @returns Parsed data or undefined.
+   */
   static parse(data: unknown) {
     if (isBytesLike(data)) {
       const parsedExtraArgs = this.decodeExtraArgs(data)
@@ -464,6 +639,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
+  /** {@inheritDoc Chain.getSupportedTokens} */
   async getSupportedTokens(address: string, opts?: { page?: number }): Promise<string[]> {
     const res = []
     let page,
@@ -482,6 +658,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     return page
   }
 
+  /** {@inheritDoc Chain.getRegistryTokenConfig} */
   async getRegistryTokenConfig(
     registry: string,
     token: string,
@@ -508,6 +685,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     }
   }
 
+  /** {@inheritDoc Chain.getTokenPoolConfigs} */
   async getTokenPoolConfigs(tokenPool: string): Promise<{
     token: string
     router: string
@@ -546,6 +724,7 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     throw firstErr ?? new Error(`Could not get tokenPool configs from ${tokenPool}`)
   }
 
+  /** {@inheritDoc Chain.getTokenPoolRemotes} */
   async getTokenPoolRemotes(
     tokenPool: string,
     remoteChainSelector?: bigint,
@@ -642,7 +821,8 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     throw firstErr ?? new Error(`Could not view 'get_remote_token' in ${tokenPool}`)
   }
 
-  async listFeeTokens(router: string): Promise<Record<string, TokenInfo>> {
+  /** {@inheritDoc Chain.getFeeTokens} */
+  async getFeeTokens(router: string): Promise<Record<string, TokenInfo>> {
     const [feeTokens] = await this.provider.view<[string[]]>({
       payload: {
         function:
@@ -656,5 +836,3 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     )
   }
 }
-
-supportedChains[ChainFamily.Aptos] = AptosChain