@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/aptos/logs.ts

@@ -5,7 +5,7 @@ import {
   TransactionResponseType,
   getAptosFullNode,
 } from '@aptos-labs/ts-sdk'
-import moize from 'moize'
+import { memoize } from 'micro-memoize'
 
 import type { LogFilter } from '../chain.ts'
 import type { Log_ } from '../types.ts'
@@ -16,6 +16,12 @@ const eventToHandler = {
   ExecutionStateChanged: 'OffRampState/execution_state_changed_events',
 } as const
 
+/**
+ * Fetches a user transaction by its version number.
+ * @param provider - Aptos provider instance.
+ * @param version - Transaction version number.
+ * @returns User transaction response.
+ */
 export async function getUserTxByVersion(
   provider: Aptos,
   version: number,
@@ -28,6 +34,12 @@ export async function getUserTxByVersion(
   return tx
 }
 
+/**
+ * Gets the timestamp for a given transaction version.
+ * @param provider - Aptos provider instance.
+ * @param version - Version number or 'finalized'.
+ * @returns Timestamp in seconds.
+ */
 export async function getVersionTimestamp(
   provider: Aptos,
   version: number | 'finalized',
@@ -78,7 +90,7 @@ async function* fetchEventsForward(
   stateAddr: string,
   limit = 100,
 ): AsyncGenerator<ResEvent> {
-  const fetchBatch = moize.default(
+  const fetchBatch = memoize(
     async (start?: number) => {
       const { data }: { data: ResEvent[] } = await getAptosFullNode({
         aptosConfig: provider.config,
@@ -86,7 +98,7 @@ async function* fetchEventsForward(
         path: `accounts/${stateAddr}/events/${opts.address}::${eventHandlerField}`,
         params: { start, limit },
       })
-      if (!start) fetchBatch.set([+data[0].sequence_number], data)
+      if (!start) fetchBatch.cache.set([+data[0].sequence_number], Promise.resolve(data))
       return data
     },
     { maxArgs: 1, maxSize: 100 },
@@ -165,6 +177,12 @@ async function* fetchEventsBackward(
   } while (cont)
 }
 
+/**
+ * Streams logs from the Aptos blockchain based on filter options.
+ * @param provider - Aptos provider instance.
+ * @param opts - Log filter options.
+ * @returns Async generator of log entries.
+ */
 export async function* streamAptosLogs(
   provider: Aptos,
   opts: LogFilter & { versionAsHash?: boolean },

package/src/aptos/send.ts

@@ -1,11 +1,9 @@
-import type { Aptos } from '@aptos-labs/ts-sdk'
+import { type Aptos, AccountAddress } 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 { type AnyMessage, ChainFamily } from '../types.ts'
 import { getDataBytes } from '../utils.ts'
-import type { AptosAsyncAccount } from './types.ts'
 
 export const DEFAULT_FEE_TOKEN = '0xa'
 
@@ -52,6 +50,14 @@ function messageArgs(
   ]
 }
 
+/**
+ * Gets the fee for sending a CCIP message on Aptos.
+ * @param provider - Aptos provider instance.
+ * @param router - Router module address.
+ * @param destChainSelector - Destination chain selector.
+ * @param message - CCIP message to send.
+ * @returns Fee amount in native tokens.
+ */
 export async function getFee(
   provider: Aptos,
   router: string,
@@ -72,14 +78,24 @@ export async function getFee(
   return BigInt(fee)
 }
 
-export async function ccipSend(
+/**
+ * Generate an unsigned ccip_send tx to send a CCIP message through the Aptos router.
+ * @param provider - Aptos provider instance.
+ * @param sender - sender account address
+ * @param router - Router module address.
+ * @param destChainSelector - Destination chain selector.
+ * @param message - CCIP message with fee.
+ * @param _opts - Optional parameters.
+ * @returns Transaction hash.
+ */
+export async function generateUnsignedCcipSend(
   provider: Aptos,
-  account: AptosAsyncAccount,
+  sender: string,
   router: string,
   destChainSelector: bigint,
   message: AnyMessage & { fee: bigint },
   _opts?: { approveMax?: boolean },
-): Promise<string> {
+): Promise<Uint8Array> {
   // Build and submit the transaction
   // Call ccip_send entry function with signature:
   // public entry fun ccip_send(
@@ -95,7 +111,7 @@ export async function ccipSend(
   //     extra_args: vector<u8>
   // )
   const transaction = await provider.transaction.build.simple({
-    sender: account.accountAddress,
+    sender: AccountAddress.fromString(sender),
     data: {
       function:
         `${router.includes('::') ? router : router + '::router'}::ccip_send` as `${string}::${string}::${string}`,
@@ -103,18 +119,5 @@ export async function ccipSend(
     },
   })
 
-  // 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
+  return transaction.bcsToBytes()
 }

package/src/aptos/token.ts

@@ -2,6 +2,12 @@ import type { Aptos } from '@aptos-labs/ts-sdk'
 
 import type { TokenInfo } from '../chain.ts'
 
+/**
+ * Retrieves token metadata (symbol and decimals) from Aptos.
+ * @param provider - Aptos provider instance.
+ * @param token - Token address.
+ * @returns Token information with symbol and decimals.
+ */
 export async function getTokenInfo(provider: Aptos, token: string): Promise<TokenInfo> {
   let lastErr: Error | undefined
 

package/src/aptos/types.ts

@@ -8,10 +8,10 @@ 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 type { ChainFamily, ExecutionReport } from '../types.ts'
 import { getAddressBytes } from '../utils.ts'
 
-// Aptos Account is synchronous; this specialisation adds async signTransactionWithAuthenticator
+/** Aptos account type with async transaction signing capability. */
 export type AptosAsyncAccount = {
   publicKey: AccountPublicKey
   accountAddress: AccountAddress
@@ -20,6 +20,17 @@ export type AptosAsyncAccount = {
   ) => Promise<AccountAuthenticator> | AccountAuthenticator
 }
 
+/** Typeguard for an aptos-ts-sdk-like Account */
+export function isAptosAccount(account: unknown): account is AptosAsyncAccount {
+  return (
+    typeof account === 'object' &&
+    account !== null &&
+    'publicKey' in account &&
+    'accountAddress' in account &&
+    'signTransactionWithAuthenticator' in account
+  )
+}
+
 export const EVMExtraArgsV2Codec = bcs.struct('EVMExtraArgsV2', {
   gasLimit: bcs.u256(),
   allowOutOfOrderExecution: bcs.bool(),
@@ -57,6 +68,11 @@ export const ExecutionReportCodec = bcs.struct('ExecutionReport', {
   proofs: bcs.vector(bcs.fixedArray(32, bcs.u8())),
 })
 
+/**
+ * Serializes an execution report for Aptos using BCS encoding.
+ * @param execReport - Execution report to serialize.
+ * @returns BCS-encoded bytes.
+ */
 export function serializeExecutionReport(
   execReport: ExecutionReport<CCIPMessage_V1_6_EVM>,
 ): Uint8Array {
@@ -83,3 +99,11 @@ export function serializeExecutionReport(
     proofs: execReport.proofs.map((p) => getBytes(p)),
   }).toBytes()
 }
+
+/**
+ * Unsigned Aptos transactions, BCS-serialized.
+ */
+export type UnsignedAptosTx = {
+  family: typeof ChainFamily.Aptos
+  transactions: [Uint8Array]
+}

package/src/aptos/utils.ts

@@ -9,7 +9,7 @@ import {
 
 /**
  * Encodes a numeric value as a 32-byte hex string.
- * @param value Numeric value to encode.
+ * @param value - Numeric value to encode.
  * @returns 32-byte hex string representation of the value.
  */
 export const encodeNumber = (value: BigNumberish): string => toBeHex(value, 32)