@chainlink/ccip-sdk 0.0.0 → 0.90.0

package/src/aptos/logs.ts

@@ -0,0 +1,210 @@
+import {
+  type Aptos,
+  type Event as AptosEvent,
+  type UserTransactionResponse,
+  TransactionResponseType,
+  getAptosFullNode,
+} from '@aptos-labs/ts-sdk'
+import moize from 'moize'
+
+import type { LogFilter } from '../chain.ts'
+import type { Log_ } from '../types.ts'
+
+const eventToHandler = {
+  CCIPMessageSent: 'OnRampState/ccip_message_sent_events',
+  CommitReportAccepted: 'OffRampState/commit_report_accepted_events',
+  ExecutionStateChanged: 'OffRampState/execution_state_changed_events',
+} as const
+
+export async function getUserTxByVersion(
+  provider: Aptos,
+  version: number,
+): Promise<UserTransactionResponse> {
+  const tx = await provider.getTransactionByVersion({
+    ledgerVersion: version,
+  })
+  if (tx.type !== TransactionResponseType.User)
+    throw new Error(`Unexpected transaction type="${tx.type}"`)
+  return tx
+}
+
+export async function getVersionTimestamp(
+  provider: Aptos,
+  version: number | 'finalized',
+): Promise<number> {
+  if (version === 'finalized') {
+    const info = await provider.getLedgerInfo()
+    const tx = await provider.getTransactionByVersion({
+      ledgerVersion: +info.ledger_version,
+    })
+    return +(tx as UserTransactionResponse).timestamp / 1e6
+  }
+  const tx = await getUserTxByVersion(provider, version)
+  return +tx.timestamp / 1e6
+}
+
+type ResEvent = AptosEvent & { version: string }
+
+/**
+ * Binary search to find the first element that does NOT satisfy a condition.
+ * Assumes the first element satisfies the condition, and elements after it may or may not.
+ * @param low - The starting index (inclusive, must satisfy condition)
+ * @param high - The ending index (inclusive)
+ * @param predicate - Function that returns true when condition is met
+ * @returns The first index where predicate returns false, or high + 1 if all elements satisfy the condition
+ */
+async function binarySearchFirst(
+  low: number,
+  high: number,
+  predicate: (index: number) => Promise<boolean>,
+): Promise<number> {
+  let result = high + 1
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2)
+    if (await predicate(mid)) {
+      low = mid + 1
+    } else {
+      result = mid
+      high = mid - 1
+    }
+  }
+  return result
+}
+
+async function* fetchEventsForward(
+  provider: Aptos,
+  opts: LogFilter,
+  eventHandlerField: string,
+  stateAddr: string,
+  limit = 100,
+): AsyncGenerator<ResEvent> {
+  const fetchBatch = moize.default(
+    async (start?: number) => {
+      const { data }: { data: ResEvent[] } = await getAptosFullNode({
+        aptosConfig: provider.config,
+        originMethod: 'getEventsByEventHandle',
+        path: `accounts/${stateAddr}/events/${opts.address}::${eventHandlerField}`,
+        params: { start, limit },
+      })
+      if (!start) fetchBatch.set([+data[0].sequence_number], data)
+      return data
+    },
+    { maxArgs: 1, maxSize: 100 },
+  )
+
+  const initialBatch = await fetchBatch()
+  if (!initialBatch.length) return
+  const end = +initialBatch[initialBatch.length - 1].sequence_number
+
+  let start
+  if (
+    (!opts.startBlock || opts.startBlock < +initialBatch[0].version) &&
+    (!opts.startTime ||
+      opts.startTime < (await getVersionTimestamp(provider, +initialBatch[0].version)))
+  ) {
+    const i = await binarySearchFirst(0, Math.floor(end / limit) - 1, async (i) => {
+      const batch = await fetchBatch(end - (i + 1) * limit + 1)
+      const firstTimestamp = await getVersionTimestamp(provider, +batch[0].version)
+      return firstTimestamp > opts.startTime!
+    })
+    start = end - (i + 1) * limit + 1
+  } else {
+    start = end - limit + 1
+  }
+
+  let first = true
+  for (; start < end; start += limit) {
+    const data = await fetchBatch(start)
+    if (
+      first &&
+      opts.startTime &&
+      (await getVersionTimestamp(provider, +data[0].version)) < opts.startTime
+    ) {
+      // the first batch may have some head which is not in the range
+      const actualStart = await binarySearchFirst(0, data.length - 1, async (i) => {
+        const timestamp = await getVersionTimestamp(provider, +data[i].version)
+        return timestamp < opts.startTime!
+      })
+      data.splice(0, actualStart - 1)
+    }
+    first = false
+    for (const ev of data) {
+      if (opts.startBlock && +ev.version < opts.startBlock) continue
+      if (opts.endBlock && +ev.version > opts.endBlock) return
+      yield ev
+    }
+  }
+}
+
+async function* fetchEventsBackward(
+  provider: Aptos,
+  opts: LogFilter,
+  eventHandlerField: string,
+  stateAddr: string,
+  limit = 100,
+): AsyncGenerator<ResEvent> {
+  let start
+  let cont = true
+  do {
+    const { data } = await getAptosFullNode<object, ResEvent[]>({
+      aptosConfig: provider.config,
+      originMethod: 'getEventsByEventHandle',
+      path: `accounts/${stateAddr}/events/${opts.address}::${eventHandlerField}`,
+      params: { start, limit },
+    })
+
+    if (!data.length) break
+    else if (start === 1) cont = false
+    else start = Math.max(+data[0].sequence_number - limit, 1)
+
+    for (const ev of data.reverse()) {
+      if (opts.endBlock && +ev.version > opts.endBlock) continue
+      if (+ev.sequence_number <= 1) cont = false
+      yield ev
+    }
+  } while (cont)
+}
+
+export async function* streamAptosLogs(
+  provider: Aptos,
+  opts: LogFilter & { versionAsHash?: boolean },
+): AsyncGenerator<Log_> {
+  const limit = 100
+  if (!opts.address || !opts.address.includes('::'))
+    throw new Error('address with module is required')
+  if (opts.topics?.length !== 1 || typeof opts.topics[0] !== 'string')
+    throw new Error('single string topic required')
+  let eventHandlerField = opts.topics[0]
+  if (!eventHandlerField.includes('/')) {
+    eventHandlerField = (eventToHandler as Record<string, string>)[eventHandlerField]
+    if (!eventHandlerField) throw new Error(`Unknown topic event handler="${opts.topics[0]}"`)
+  }
+  const [stateAddr] = await provider.view<[string]>({
+    payload: {
+      function: `${opts.address}::get_state_address` as `0x${string}::${string}::get_state_address`,
+    },
+  })
+
+  let eventsIter
+  if (opts.startBlock || opts.startTime) {
+    eventsIter = fetchEventsForward(provider, opts, eventHandlerField, stateAddr, limit)
+  } else {
+    // backwards, just paginate down to lowest sequence number
+    eventsIter = fetchEventsBackward(provider, opts, eventHandlerField, stateAddr, limit)
+  }
+
+  let topics
+  for await (const ev of eventsIter) {
+    topics ??= [ev.type.slice(ev.type.lastIndexOf('::') + 2)]
+    yield {
+      address: opts.address,
+      topics,
+      index: +ev.sequence_number,
+      blockNumber: +ev.version,
+      transactionHash: opts?.versionAsHash
+        ? `${ev.version}`
+        : (await getUserTxByVersion(provider, +ev.version)).hash,
+      data: ev.data as Record<string, unknown>,
+    }
+  }
+}

package/src/aptos/send.ts

@@ -0,0 +1,120 @@
+import type { Aptos } from '@aptos-labs/ts-sdk'
+import { getBytes, zeroPadValue } from 'ethers'
+
+import { ChainFamily } from '../chain.ts'
+import { encodeExtraArgs } from '../extra-args.ts'
+import type { AnyMessage } from '../types.ts'
+import { getDataBytes } from '../utils.ts'
+import type { AptosAsyncAccount } from './types.ts'
+
+export const DEFAULT_FEE_TOKEN = '0xa'
+
+function messageArgs(
+  destChainSelector: bigint,
+  message: AnyMessage,
+): [
+  destChainSelector: bigint,
+  receiver: Uint8Array,
+  data: Uint8Array,
+  tokenAddresses: string[],
+  tokenAmounts: string[],
+  tokenStoreAddresses: string[],
+  feeToken: string,
+  feeTokenStore: string,
+  encodedExtraArgs: Uint8Array,
+] {
+  // Prepare the message structure for the view call
+  const receiver = getBytes(zeroPadValue(getDataBytes(message.receiver), 32))
+  const data = getDataBytes(message.data)
+
+  // Get the native token to use as fee token if not specified
+  const feeToken = message.feeToken || DEFAULT_FEE_TOKEN
+  const feeTokenStore = '0x0' // auto-fetch primary store
+
+  // Split token amounts into separate arrays for Aptos Move
+  const tokenAddresses = (message.tokenAmounts ?? []).map((ta) => ta.token)
+  const tokenAmounts = (message.tokenAmounts ?? []).map((ta) => ta.amount.toString())
+  const tokenStoreAddresses = tokenAddresses.map(() => '0x0')
+
+  // Encode extraArgs for the router
+  const encodedExtraArgs = getBytes(encodeExtraArgs(message.extraArgs, ChainFamily.Aptos))
+
+  return [
+    destChainSelector,
+    receiver,
+    data,
+    tokenAddresses,
+    tokenAmounts,
+    tokenStoreAddresses,
+    feeToken,
+    feeTokenStore,
+    encodedExtraArgs,
+  ]
+}
+
+export async function getFee(
+  provider: Aptos,
+  router: string,
+  destChainSelector: bigint,
+  message: AnyMessage,
+): Promise<bigint> {
+  // Call the get_fee view function on the router
+  // Signature: get_fee(dest_chain_selector, receiver, data, token_addresses, token_amounts,
+  //                    token_store_addresses, fee_token, fee_token_store, extra_args)
+  const [fee] = await provider.view<[string]>({
+    payload: {
+      function:
+        `${router.includes('::') ? router : router + '::router'}::get_fee` as `${string}::${string}::get_fee`,
+      functionArguments: messageArgs(destChainSelector, message),
+    },
+  })
+
+  return BigInt(fee)
+}
+
+export async function ccipSend(
+  provider: Aptos,
+  account: AptosAsyncAccount,
+  router: string,
+  destChainSelector: bigint,
+  message: AnyMessage & { fee: bigint },
+  _opts?: { approveMax?: boolean },
+): Promise<string> {
+  // Build and submit the transaction
+  // Call ccip_send entry function with signature:
+  // public entry fun ccip_send(
+  //     caller: &signer,
+  //     dest_chain_selector: u64,
+  //     receiver: vector<u8>,
+  //     data: vector<u8>,
+  //     token_addresses: vector<address>,
+  //     token_amounts: vector<u64>,
+  //     token_store_addresses: vector<address>,
+  //     fee_token: address,
+  //     fee_token_store: address,
+  //     extra_args: vector<u8>
+  // )
+  const transaction = await provider.transaction.build.simple({
+    sender: account.accountAddress,
+    data: {
+      function:
+        `${router.includes('::') ? router : router + '::router'}::ccip_send` as `${string}::${string}::${string}`,
+      functionArguments: messageArgs(destChainSelector, message),
+    },
+  })
+
+  // Sign and submit the transaction
+  const signed = await account.signTransactionWithAuthenticator(transaction)
+  const pendingTxn = await provider.transaction.submit.simple({
+    transaction,
+    senderAuthenticator: signed,
+  })
+
+  // Wait for the transaction to be confirmed
+  const { hash } = await provider.waitForTransaction({
+    transactionHash: pendingTxn.hash,
+  })
+
+  // Return the transaction hash
+  return hash
+}

package/src/aptos/token.ts

@@ -0,0 +1,150 @@
+import type { Aptos } from '@aptos-labs/ts-sdk'
+
+import type { TokenInfo } from '../chain.ts'
+
+export async function getTokenInfo(provider: Aptos, token: string): Promise<TokenInfo> {
+  let lastErr: Error | undefined
+
+  // First, try to get info from Fungible Asset metadata resource
+  try {
+    const resources = await provider.getAccountResources({ accountAddress: token })
+    const metadataResource = resources.find((r) => r.type === '0x1::fungible_asset::Metadata')
+
+    if (metadataResource?.data) {
+      const metadata = metadataResource.data as {
+        name?: string
+        symbol?: string
+        decimals?: number
+      }
+      if (metadata.symbol !== undefined && metadata.decimals !== undefined) {
+        return {
+          name: metadata.name,
+          symbol: metadata.symbol,
+          decimals: metadata.decimals,
+        }
+      }
+    }
+  } catch (err) {
+    lastErr = err as Error
+  }
+
+  // Try to get info using standard coin functions with type arguments
+  try {
+    const symbolRes = await provider.view({
+      payload: {
+        function: '0x1::coin::symbol',
+        typeArguments: [token],
+      },
+    })
+
+    const decimalsRes = await provider.view({
+      payload: {
+        function: '0x1::coin::decimals',
+        typeArguments: [token],
+      },
+    })
+
+    let name: string | undefined
+    try {
+      const nameRes = await provider.view({
+        payload: {
+          function: '0x1::coin::name',
+          typeArguments: [token],
+        },
+      })
+      name = nameRes[0] as string
+    } catch {
+      // name function not available, continue without it
+    }
+
+    return {
+      name,
+      symbol: symbolRes[0] as string,
+      decimals: decimalsRes[0] as number,
+    }
+  } catch (err) {
+    lastErr = err as Error
+  }
+
+  // Try to get symbol and decimals from token module functions (legacy approach)
+  const modules = await provider.getAccountModules({ accountAddress: token })
+  const moduleNames = modules
+    .map(({ abi }) => abi!.name)
+    .filter((name) => name.includes('coin') || name.includes('token'))
+
+  for (const moduleName of moduleNames) {
+    try {
+      const symbolRes = await provider.view({
+        payload: {
+          function: `${token}::${moduleName}::symbol`,
+        },
+      })
+
+      const decimalsRes = await provider.view({
+        payload: {
+          function: `${token}::${moduleName}::decimals`,
+        },
+      })
+
+      let name: string | undefined
+      try {
+        const nameRes = await provider.view({
+          payload: {
+            function: `${token}::${moduleName}::name`,
+          },
+        })
+        name = nameRes[0] as string
+      } catch {
+        // name function not available, continue without it
+      }
+
+      return {
+        name,
+        symbol: symbolRes[0] as string,
+        decimals: decimalsRes[0] as number,
+      }
+    } catch (err) {
+      lastErr = err as Error
+    }
+  }
+
+  // Fallback: try common coin module patterns
+  const commonPatterns = ['coin', 'token', 'fungible_asset']
+  for (const pattern of commonPatterns) {
+    try {
+      const symbolRes = await provider.view({
+        payload: {
+          function: `${token}::${pattern}::symbol`,
+        },
+      })
+
+      const decimalsRes = await provider.view({
+        payload: {
+          function: `${token}::${pattern}::decimals`,
+        },
+      })
+
+      let name: string | undefined
+      try {
+        const nameRes = await provider.view({
+          payload: {
+            function: `${token}::${pattern}::name`,
+          },
+        })
+        name = nameRes[0] as string
+      } catch {
+        // name function not available, continue without it
+      }
+
+      return {
+        name,
+        symbol: symbolRes[0] as string,
+        decimals: decimalsRes[0] as number,
+      }
+    } catch (err) {
+      lastErr = err as Error
+    }
+  }
+
+  throw lastErr ?? new Error(`Could not view token info for ${token}`)
+}

package/src/aptos/types.ts

@@ -0,0 +1,85 @@
+import type {
+  AccountAddress,
+  AccountAuthenticator,
+  AccountPublicKey,
+  AnyRawTransaction,
+} from '@aptos-labs/ts-sdk'
+import { bcs } from '@mysten/bcs'
+import { getBytes } from 'ethers'
+
+import type { CCIPMessage_V1_6_EVM } from '../evm/messages.ts'
+import type { ExecutionReport } from '../types.ts'
+import { getAddressBytes } from '../utils.ts'
+
+// Aptos Account is synchronous; this specialisation adds async signTransactionWithAuthenticator
+export type AptosAsyncAccount = {
+  publicKey: AccountPublicKey
+  accountAddress: AccountAddress
+  signTransactionWithAuthenticator: (
+    transaction: AnyRawTransaction,
+  ) => Promise<AccountAuthenticator> | AccountAuthenticator
+}
+
+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()),
+  headerSourceChainSelector: bcs.u64(),
+  destChainSelector: bcs.u64(),
+  sequenceNumber: bcs.u64(),
+  nonce: bcs.u64(),
+  sender: bcs.vector(bcs.u8()),
+  data: bcs.vector(bcs.u8()),
+  receiver: bcs.fixedArray(32, bcs.u8()),
+  gasLimit: bcs.u256(),
+  tokenAmounts: bcs.vector(
+    bcs.struct('TokenAmounts', {
+      sourcePoolAddress: bcs.vector(bcs.u8()),
+      destTokenAddress: bcs.fixedArray(32, bcs.u8()),
+      destGasAmount: bcs.u32(),
+      extraData: bcs.vector(bcs.u8()),
+      amount: bcs.u256(),
+    }),
+  ),
+  offchainTokenData: bcs.vector(bcs.vector(bcs.u8())),
+  proofs: bcs.vector(bcs.fixedArray(32, bcs.u8())),
+})
+
+export function serializeExecutionReport(
+  execReport: ExecutionReport<CCIPMessage_V1_6_EVM>,
+): Uint8Array {
+  const message = execReport.message
+  return ExecutionReportCodec.serialize({
+    sourceChainSelector: message.header.sourceChainSelector,
+    messageId: getBytes(message.header.messageId),
+    headerSourceChainSelector: message.header.sourceChainSelector,
+    destChainSelector: message.header.destChainSelector,
+    sequenceNumber: message.header.sequenceNumber,
+    nonce: message.header.nonce,
+    sender: getAddressBytes(message.sender),
+    data: getBytes(message.data),
+    receiver: getAddressBytes(message.receiver),
+    gasLimit: message.gasLimit,
+    tokenAmounts: message.tokenAmounts.map((ta) => ({
+      sourcePoolAddress: getAddressBytes(ta.sourcePoolAddress),
+      destTokenAddress: getAddressBytes(ta.destTokenAddress),
+      destGasAmount: Number(ta.destGasAmount),
+      extraData: getBytes(ta.extraData),
+      amount: ta.amount,
+    })),
+    offchainTokenData: execReport.offchainTokenData.map(() => []),
+    proofs: execReport.proofs.map((p) => getBytes(p)),
+  }).toBytes()
+}

package/src/aptos/utils.ts

@@ -0,0 +1,24 @@
+import {
+  type BigNumberish,
+  type BytesLike,
+  concat,
+  dataLength,
+  toBeHex,
+  zeroPadBytes,
+} from 'ethers'
+
+/**
+ * Encodes a numeric value as a 32-byte hex string.
+ * @param value Numeric value to encode.
+ * @returns 32-byte hex string representation of the value.
+ */
+export const encodeNumber = (value: BigNumberish): string => toBeHex(value, 32)
+
+/**
+ * Encodes dynamic bytes without the struct offset prefix.
+ */
+export const encodeRawBytes = (value: BytesLike): string =>
+  concat([
+    encodeNumber(dataLength(value)),
+    zeroPadBytes(value, Math.ceil(dataLength(value) / 32) * 32),
+  ])