@chainlink/ccip-sdk 0.95.0 → 0.97.0

package/src/extra-args.ts

@@ -8,6 +8,8 @@ import { ChainFamily } from './types.ts'
 export const EVMExtraArgsV1Tag = id('CCIP EVMExtraArgsV1').substring(0, 10) as '0x97a657c9'
 /** Tag identifier for EVMExtraArgsV2 encoding. */
 export const EVMExtraArgsV2Tag = id('CCIP EVMExtraArgsV2').substring(0, 10) as '0x181dcf10'
+/** Tag identifier for GenericExtraArgsV3 encoding (tightly packed binary format). */
+export const GenericExtraArgsV3Tag = id('CCIP GenericExtraArgsV3').substring(0, 10) as '0xa69dd4aa'
 /** Tag identifier for SVMExtraArgsV1 encoding. */
 export const SVMExtraArgsV1Tag = id('CCIP SVMExtraArgsV1').substring(0, 10) as '0x1f3b3aba'
 /** Tag identifier for SuiExtraArgsV1 encoding. */
@@ -15,6 +17,13 @@ export const SuiExtraArgsV1Tag = id('CCIP SuiExtraArgsV1').substring(0, 10) as '
 
 /**
  * EVM extra arguments version 1 with gas limit only.
+ *
+ * @example
+ * ```typescript
+ * const args: EVMExtraArgsV1 = {
+ *   gasLimit: 200_000n,
+ * }
+ * ```
  */
 export type EVMExtraArgsV1 = {
   /** Gas limit for execution on the destination chain. */
@@ -24,14 +33,70 @@ export type EVMExtraArgsV1 = {
 /**
  * EVM extra arguments version 2 with out-of-order execution support.
  * Also known as GenericExtraArgsV2.
+ *
+ * @example
+ * ```typescript
+ * const args: EVMExtraArgsV2 = {
+ *   gasLimit: 200_000n,
+ *   allowOutOfOrderExecution: true,
+ * }
+ * ```
  */
 export type EVMExtraArgsV2 = EVMExtraArgsV1 & {
   /** Whether to allow out-of-order message execution. */
   allowOutOfOrderExecution: boolean
 }
 
+/**
+ * Generic extra arguments version 3 with cross-chain verifiers and executor support.
+ * Uses tightly packed binary encoding (NOT ABI-encoded).
+ *
+ * @example
+ * ```typescript
+ * const args: GenericExtraArgsV3 = {
+ *   gasLimit: 200_000n,
+ *   blockConfirmations: 5,
+ *   ccvs: ['0x1234...'],
+ *   ccvArgs: ['0x010203'],
+ *   executor: '0x5678...',
+ *   executorArgs: '0x',
+ *   tokenReceiver: '0xReceiverAddress...',
+ *   tokenArgs: '0x',
+ * }
+ * ```
+ */
+export type GenericExtraArgsV3 = {
+  /** Gas limit for execution on the destination chain (uint32). */
+  gasLimit: bigint
+  /** Number of block confirmations required. */
+  blockConfirmations: number
+  /** Cross-chain verifier addresses (EVM addresses). */
+  ccvs: string[]
+  /** Per-CCV arguments (BytesLike). */
+  ccvArgs: BytesLike[]
+  /** Executor address (EVM address or empty string for none). */
+  executor: string
+  /** Executor-specific arguments (BytesLike). */
+  executorArgs: BytesLike
+  /** Token receiver address (checksummed EVM address or hex string). */
+  tokenReceiver: string
+  /** Token pool-specific arguments (BytesLike). */
+  tokenArgs: BytesLike
+}
+
 /**
  * Solana (SVM) extra arguments version 1.
+ *
+ * @example
+ * ```typescript
+ * const args: SVMExtraArgsV1 = {
+ *   computeUnits: 200_000n,
+ *   accountIsWritableBitmap: 0n,
+ *   allowOutOfOrderExecution: true,
+ *   tokenReceiver: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+ *   accounts: [],
+ * }
+ * ```
  */
 export type SVMExtraArgsV1 = {
   /** Compute units for Solana execution. */
@@ -48,6 +113,16 @@ export type SVMExtraArgsV1 = {
 
 /**
  * Sui extra arguments version 1.
+ *
+ * @example
+ * ```typescript
+ * const args: SuiExtraArgsV1 = {
+ *   gasLimit: 200_000n,
+ *   allowOutOfOrderExecution: true,
+ *   tokenReceiver: '0x1234...abcd',
+ *   receiverObjectIds: ['0xobject1...', '0xobject2...'],
+ * }
+ * ```
  */
 export type SuiExtraArgsV1 = EVMExtraArgsV2 & {
   /** Token receiver address on Sui. */
@@ -59,13 +134,36 @@ export type SuiExtraArgsV1 = EVMExtraArgsV2 & {
 /**
  * Union type of all supported extra arguments formats.
  */
-export type ExtraArgs = EVMExtraArgsV1 | EVMExtraArgsV2 | SVMExtraArgsV1 | SuiExtraArgsV1
+export type ExtraArgs =
+  | EVMExtraArgsV1
+  | EVMExtraArgsV2
+  | GenericExtraArgsV3
+  | SVMExtraArgsV1
+  | SuiExtraArgsV1
 
 /**
  * Encodes extra arguments for CCIP messages.
- * The args are *to* a dest network, but are encoded as a message *from* this source chain
- * e.g. Solana uses Borsh to encode extraArgs in its produced requests, even those targetting EVM
- **/
+ * The args are *to* a dest network, but are encoded as a message *from* this source chain.
+ * E.g. Solana uses Borsh to encode extraArgs in its produced requests, even those targeting EVM.
+ *
+ * @param args - Extra arguments to encode
+ * @param from - Source chain family for encoding format (defaults to EVM)
+ * @returns Encoded extra arguments as hex string
+ * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported
+ *
+ * @example
+ * ```typescript
+ * import { encodeExtraArgs } from '@chainlink/ccip-sdk'
+ *
+ * const encoded = encodeExtraArgs({
+ *   gasLimit: 200_000n,
+ *   allowOutOfOrderExecution: true,
+ * })
+ * console.log('Encoded:', encoded) // '0x181dcf10...'
+ * ```
+ *
+ * @see {@link decodeExtraArgs} - Decode extra arguments from bytes
+ */
 export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily.EVM): string {
   const chain = supportedChains[from]
   if (!chain) throw new CCIPChainFamilyUnsupportedError(from)
@@ -77,6 +175,21 @@ export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily
  * @param data - Extra arguments bytearray data.
  * @param from - Optional chain family to narrow decoding attempts.
  * @returns Extra arguments object if found, undefined otherwise.
+ * @throws {@link CCIPChainFamilyUnsupportedError} if specified chain family not supported
+ * @throws {@link CCIPExtraArgsParseError} if data cannot be parsed as valid extra args
+ *
+ * @example
+ * ```typescript
+ * import { decodeExtraArgs } from '@chainlink/ccip-sdk'
+ *
+ * const decoded = decodeExtraArgs('0x181dcf10...')
+ * if (decoded?._tag === 'EVMExtraArgsV2') {
+ *   console.log('Gas limit:', decoded.gasLimit)
+ *   console.log('Out of order:', decoded.allowOutOfOrderExecution)
+ * }
+ * ```
+ *
+ * @see {@link encodeExtraArgs} - Encode extra arguments to bytes
  */
 export function decodeExtraArgs(
   data: BytesLike,
@@ -84,6 +197,7 @@ export function decodeExtraArgs(
 ):
   | (EVMExtraArgsV1 & { _tag: 'EVMExtraArgsV1' })
   | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
+  | (GenericExtraArgsV3 & { _tag: 'GenericExtraArgsV3' })
   | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
   | (SuiExtraArgsV1 & { _tag: 'SuiExtraArgsV1' })
   | undefined {

package/src/gas.ts

@@ -4,13 +4,14 @@ import type { Chain } from './chain.ts'
 import {
   CCIPContractTypeInvalidError,
   CCIPMethodUnsupportedError,
+  CCIPOnRampRequiredError,
   CCIPTokenDecimalsInsufficientError,
 } from './errors/index.ts'
 import { discoverOffRamp } from './execution.ts'
 import { sourceToDestTokenAddresses } from './requests.ts'
 
 /**
- * A subset of [[MessageInput]] for estimating receive execution gas.
+ * A subset of {@link MessageInput} for estimating receive execution gas.
  */
 export type EstimateMessageInput = {
   /** receiver contract address */
@@ -19,7 +20,7 @@ export type EstimateMessageInput = {
   messageId?: string
   /** optional sender: zero address will be used if omitted */
   sender?: string
-  /** optional data: zero bytes will be used if ommitted */
+  /** optional data: zero bytes will be used if omitted */
   data?: BytesLike
   /**
    * optional tokenAmounts; `amount` with either source `token` (as in MessageInput) or
@@ -35,7 +36,7 @@ export type EstimateMessageInput = {
 }
 
 /**
- * Options for [[estimateReceiveExecution]] function.
+ * Options for {@link estimateReceiveExecution} function.
  */
 export type EstimateReceiveExecutionOpts = {
   /** Source chain instance (for token data retrieval) */
@@ -50,8 +51,34 @@ export type EstimateReceiveExecutionOpts = {
 
 /**
  * Estimate CCIP gasLimit needed to execute a request on a contract receiver.
- * @param opts - Options for estimation: source and dest chains, router or ramp address, and message
- * @returns Estimated gasLimit.
+ *
+ * @param opts - {@link EstimateReceiveExecutionOpts} for estimation
+ * @returns Estimated gasLimit
+ *
+ * @throws {@link CCIPMethodUnsupportedError} if dest chain doesn't support estimation
+ * @throws {@link CCIPContractTypeInvalidError} if routerOrRamp is not a valid contract type
+ * @throws {@link CCIPTokenDecimalsInsufficientError} if dest token has insufficient decimals
+ *
+ * @example
+ * ```typescript
+ * import { estimateReceiveExecution, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * const dest = await EVMChain.fromUrl('https://rpc.fuji.avax.network')
+ *
+ * const gasLimit = await estimateReceiveExecution({
+ *   source,
+ *   dest,
+ *   routerOrRamp: '0xRouter...',
+ *   message: {
+ *     sender: '0x...',
+ *     receiver: '0x...',
+ *     data: '0x...',
+ *     tokenAmounts: [],
+ *   },
+ * })
+ * console.log('Estimated gas:', gasLimit)
+ * ```
  */
 export async function estimateReceiveExecution({
   source,
@@ -69,12 +96,18 @@ export async function estimateReceiveExecution({
       onRamp = await source.getOnRampForRouter(routerOrRamp, dest.network.chainSelector)
     else onRamp = routerOrRamp
     offRamp = await discoverOffRamp(source, dest, onRamp, source)
-  } catch {
-    const tnv = await dest.typeAndVersion(routerOrRamp)
-    if (!tnv[0].includes('OffRamp'))
-      throw new CCIPContractTypeInvalidError(routerOrRamp, tnv[2], ['OffRamp'])
-    offRamp = routerOrRamp
-    onRamp = await dest.getOnRampForOffRamp(offRamp, source.network.chainSelector)
+  } catch (sourceErr) {
+    try {
+      const tnv = await dest.typeAndVersion(routerOrRamp)
+      if (!tnv[0].includes('OffRamp'))
+        throw new CCIPContractTypeInvalidError(routerOrRamp, tnv[2], ['OffRamp'])
+      offRamp = routerOrRamp
+      const onRamps = await dest.getOnRampsForOffRamp(offRamp, source.network.chainSelector)
+      if (!onRamps.length) throw new CCIPOnRampRequiredError()
+      onRamp = onRamps[onRamps.length - 1]!
+    } catch {
+      throw sourceErr // re-throw original error
+    }
   }
 
   const destTokenAmounts = await Promise.all(

package/src/index.ts

@@ -1,5 +1,14 @@
+/**
+ * \@chainlink/ccip-sdk - SDK for interacting with Chainlink CCIP (Cross-Chain Interoperability Protocol).
+ *
+ * This package provides tools for sending cross-chain messages, tracking message status,
+ * and executing manual message delivery across supported blockchain networks.
+ *
+ * @packageDocumentation
+ */
+
 export type {
-  APICCIPRequest,
+  APICCIPRequestMetadata,
   APIErrorResponse,
   CCIPAPIClientContext,
   LaneLatencyResponse,
@@ -15,7 +24,9 @@ export type {
   GetBalanceOpts,
   LogFilter,
   RateLimiterState,
+  RegistryTokenConfig,
   TokenInfo,
+  TokenPoolConfig,
   TokenPoolRemote,
 } from './chain.ts'
 export { DEFAULT_API_RETRY_CONFIG } from './chain.ts'
@@ -32,14 +43,14 @@ export {
 export { estimateReceiveExecution } from './gas.ts'
 export { decodeMessage, getMessagesForSender, sourceToDestTokenAddresses } from './requests.ts'
 export {
-  type CCIPCommit,
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
+  type CCIPVerifications,
   type ChainTransaction,
   type CommitReport,
+  type ExecutionInput,
   type ExecutionReceipt,
-  type ExecutionReport,
   type Lane,
   type Logger,
   type MessageInput,
@@ -87,11 +98,3 @@ import { ChainFamily, NetworkType } from './types.ts'
 export { AptosChain, ChainFamily, EVMChain, NetworkType, SolanaChain, SuiChain, TONChain }
 // use `supportedChains` to override/register derived classes, if needed
 export { supportedChains } from './supported-chains.ts'
-// import `allSupportedChains` to get them all registered, in tree-shaken environments
-export const allSupportedChains = {
-  [ChainFamily.EVM]: EVMChain,
-  [ChainFamily.Solana]: SolanaChain,
-  [ChainFamily.Aptos]: AptosChain,
-  [ChainFamily.Sui]: SuiChain,
-  [ChainFamily.TON]: TONChain,
-}

package/src/requests.ts

@@ -46,6 +46,14 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     source_chain_selector?: string
     sourceChainSelector?: string
     extraArgs?: string | Record<string, unknown>
+    sequenceNumber?: bigint
+    messageNumber?: bigint
+    tokenTransfer?: {
+      destExecData: string
+      destGasAmount?: bigint
+      token?: string
+      sourceTokenAddress?: string
+    }[]
     tokenAmounts: {
       destExecData: string
       destGasAmount?: bigint
@@ -60,6 +68,7 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
         totalAmount: bigint
       }
     }
+    receipts?: { feeTokenAmount: bigint }[]
     sourceNetworkInfo?: { chainSelector: string }
     destNetworkInfo?: { chainSelector: string }
   }
@@ -82,7 +91,7 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
       ? BigInt(v as string | number | bigint)
       : k?.match(/(^dest.*address)|(receiver|offramp|accounts)/i)
         ? decodeAddress(v as BytesLike, destFamily)
-        : k?.match(/((source.*address)|sender|origin|onramp|(feetoken$)|(token.*address$))/i)
+        : k?.match(/((source.*address)|sender|issuer|origin|onramp|(feetoken$)|(token.*address$))/i)
           ? decodeAddress(v as BytesLike, sourceFamily)
           : v instanceof Uint8Array ||
               (Array.isArray(v) && v.length >= 4 && v.every((e) => typeof e === 'number'))
@@ -90,6 +99,10 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
             : v,
   ) as typeof data_
 
+  if (data_.tokenTransfer) {
+    data_.tokenAmounts = data_.tokenTransfer
+    delete data_.tokenTransfer
+  }
   for (const ta of data_.tokenAmounts) {
     if (ta.token && !ta.sourceTokenAddress) ta.sourceTokenAddress = ta.token
     if (!ta.token && ta.sourceTokenAddress) ta.token = ta.sourceTokenAddress
@@ -121,14 +134,41 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     data_.feeToken = data_.fees.fixedFeesDetails.tokenAddress
     data_.feeTokenAmount = data_.fees.fixedFeesDetails.totalAmount
   }
+  if (data_.sequenceNumber == null && data_.messageNumber != null) {
+    data_.sequenceNumber = data_.messageNumber
+  }
+  if (!data_.feeTokenAmount && data_.receipts) {
+    data_.feeTokenAmount = data_.receipts.reduce(
+      (acc, receipt) => acc + receipt.feeTokenAmount,
+      BigInt(0),
+    )
+  }
 
   return data_ as unknown as CCIPMessage
 }
 
 /**
- * Decodes hex strings, bytearrays, JSON strings and raw objects as CCIPMessages
- * Does minimal validation, but converts objects in the format expected by ccip-tools-ts
- **/
+ * Decodes hex strings, bytearrays, JSON strings and raw objects as CCIPMessages.
+ * Does minimal validation, but converts objects in the format expected by ccip-tools-ts.
+ *
+ * @param data - Data to decode (hex string, Uint8Array, JSON string, or object)
+ * @returns Decoded CCIPMessage
+ * @throws {@link CCIPMessageDecodeError} if data cannot be decoded as a valid message
+ * @throws {@link CCIPMessageInvalidError} if message structure is invalid or missing required fields
+ *
+ * @example
+ * ```typescript
+ * import { decodeMessage } from '@chainlink/ccip-sdk'
+ *
+ * // Decode from JSON string
+ * const message = decodeMessage('{"header":{"sourceChainSelector":"123",...}')
+ *
+ * // Decode from hex-encoded bytes
+ * const message = decodeMessage('0x...')
+ *
+ * console.log('Message ID:', message.messageId)
+ * ```
+ */
 export function decodeMessage(data: string | Uint8Array | Record<string, unknown>): CCIPMessage {
   if (
     (typeof data === 'string' && data.startsWith('{')) ||
@@ -151,10 +191,11 @@ export function decodeMessage(data: string | Uint8Array | Record<string, unknown
 }
 
 /**
- * Populates missing required fields (e.g. `extraArgs`) from AnyMessage
- * @param message - partial AnyMessage
- * @returns original message or shallow copy with defaults for required fields
- **/
+ * Populates missing required fields (e.g. `extraArgs`) from AnyMessage.
+ * @param message - Partial AnyMessage with at least receiver
+ * @param dest - Destination chain family to build message for
+ * @returns Original message or shallow copy with defaults for required fields
+ */
 export function buildMessageForDest(message: MessageInput, dest: ChainFamily): AnyMessage {
   const chain = supportedChains[dest] ?? Chain
   return chain.buildMessageForDest(message)
@@ -162,10 +203,14 @@ export function buildMessageForDest(message: MessageInput, dest: ChainFamily): A
 
 /**
  * Fetch all CCIP messages in a transaction.
- * @param source - Chain
+ * @param source - Source chain instance
  * @param tx - ChainTransaction to search in
  * @returns CCIP requests (messages) in the transaction (at least one)
- **/
+ * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported for legacy messages
+ * @throws {@link CCIPMessageNotFoundInTxError} if no CCIP messages found in transaction
+ *
+ * @see {@link getMessageById} - Search by messageId when tx hash unknown
+ */
 export async function getMessagesInTx(source: Chain, tx: ChainTransaction): Promise<CCIPRequest[]> {
   // RPC fallback
   const requests: CCIPRequest[] = []
@@ -188,17 +233,36 @@ export async function getMessagesInTx(source: Chain, tx: ChainTransaction): Prom
     }
     requests.push({ lane, message, log, tx })
   }
-  if (!requests.length) throw new CCIPMessageNotFoundInTxError(tx.hash)
+  if (!requests.length)
+    throw new CCIPMessageNotFoundInTxError(tx.hash, { context: { network: source.network.name } })
   return requests
 }
 
 /**
- * Fetch a CCIP message by its messageId from RPC (slow).
- * Should be called *after* generic Chain implementation, which fetches from API if available.
- * @param source - Provider to fetch logs from.
- * @param messageId - MessageId to search for.
- * @param opts - Optional hints for pagination (e.g., `address` for onRamp, `page` for pagination size).
- * @returns CCIPRequest with given messageId.
+ * Fetch a CCIP message by messageId from RPC logs (slow scan).
+ *
+ * This is the fallback implementation called by {@link Chain.getMessageById}
+ * when the API client is unavailable or fails.
+ *
+ * @param source - Source chain to scan logs from
+ * @param messageId - Message ID to search for
+ * @param opts - Optional hints (onRamp address narrows search, page controls batch size)
+ * @returns CCIPRequest matching the messageId
+ *
+ * @throws {@link CCIPMessageIdNotFoundError} if message not found after scanning all logs
+ *
+ * @example
+ *
+ * ```typescript
+ * import { getMessageById, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * const request = await getMessageById(source, '0xabc123...', {
+ *   onRamp: '0xOnRampAddress...',
+ * })
+ * console.log(`Found: seqNr=${request.message.sequenceNumber}`)
+ * ```
+ *
  * @internal
  */
 export async function getMessageById(
@@ -243,9 +307,10 @@ const BLOCK_LOG_WINDOW_SIZE = 5000
  * Fetches all CCIP messages contained in a given commit batch.
  * @param source - The source chain.
  * @param request - The CCIP request containing lane and message info.
- * @param seqNrRange - Object containing minSeqNr and maxSeqNr for the batch range.
+ * @param range - Object containing minSeqNr and maxSeqNr for the batch range.
  * @param opts - Optional log filtering parameters.
  * @returns Array of messages in the batch.
+ * @see {@link getVerifications} - Get commit report to determine batch range
  */
 export async function getMessagesInBatch<
   C extends Chain,
@@ -287,6 +352,7 @@ export async function getMessagesInBatch<
       const message = (source.constructor as ChainStatic).decodeMessage(log)
       if (
         !message ||
+        !('sequenceNumber' in message) ||
         ('destChainSelector' in message &&
           message.destChainSelector !== request.lane.destChainSelector)
       )
@@ -308,6 +374,7 @@ export async function getMessagesInBatch<
       const message = (source.constructor as ChainStatic).decodeMessage(log)
       if (
         !message ||
+        !('sequenceNumber' in message) ||
         ('destChainSelector' in message &&
           message.destChainSelector !== request.lane.destChainSelector)
       )
@@ -332,6 +399,22 @@ export async function getMessagesInBatch<
  * @param sender - Sender address.
  * @param filter - Log filter options.
  * @returns Async generator of CCIP requests.
+ * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported for legacy messages
+ *
+ * @example
+ * ```typescript
+ * import { getMessagesForSender, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const chain = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ *
+ * for await (const request of getMessagesForSender(chain, '0xSenderAddress', {})) {
+ *   console.log('Message ID:', request.message.messageId)
+ *   console.log('Destination:', request.lane.destChainSelector)
+ * }
+ * ```
+ *
+ * @see {@link getMessagesInTx} - Fetch from specific transaction
+ * @see {@link getMessageById} - Search by messageId
  */
 export async function* getMessagesForSender(
   source: Chain,
@@ -369,12 +452,33 @@ export async function* getMessagesForSender(
 }
 
 /**
- * Map source `token` to `sourcePoolAddress + destTokenAddress`.
- * @param source - Source chain.
- * @param destChainSelector - Destination network selector.
- * @param onRamp - Contract address.
- * @param sourceTokenAmount - tokenAmount object, usually containing `token` and `amount` properties.
- * @returns tokenAmount object with `sourcePoolAddress`, `sourceTokenAddress`, `destTokenAddress`, and remaining properties.
+ * Map source token to its pool address and destination token address.
+ *
+ * Resolves token routing by querying the TokenAdminRegistry and TokenPool
+ * to find the corresponding destination chain token.
+ *
+ * @param source - Source chain instance
+ * @param destChainSelector - Destination chain selector
+ * @param onRamp - OnRamp contract address
+ * @param sourceTokenAmount - Token amount object containing `token` and `amount`
+ * @returns Extended token amount with `sourcePoolAddress`, `sourceTokenAddress`, and `destTokenAddress`
+ *
+ * @throws {@link CCIPTokenNotInRegistryError} if token is not registered in TokenAdminRegistry
+ *
+ * @example
+ * ```typescript
+ * import { sourceToDestTokenAddresses, EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * const tokenAmount = await sourceToDestTokenAddresses(
+ *   source,
+ *   destChainSelector,
+ *   '0xOnRamp...',
+ *   { token: '0xLINK...', amount: 1000000000000000000n }
+ * )
+ * console.log(`Pool: ${tokenAmount.sourcePoolAddress}`)
+ * console.log(`Dest token: ${tokenAmount.destTokenAddress}`)
+ * ```
  */
 export async function sourceToDestTokenAddresses<S extends { token: string }>(
   source: Chain,

package/src/selectors.ts

@@ -721,6 +721,12 @@ const selectors: Selectors = {
     network_type: 'TESTNET',
     family: 'EVM',
   },
+  '3343': {
+    selector: 6325494908023253251n,
+    name: 'edge-mainnet',
+    network_type: 'MAINNET',
+    family: 'EVM',
+  },
   '3636': {
     selector: 1467223411771711614n,
     name: 'bitcoin-testnet-botanix',
@@ -1003,6 +1009,12 @@ const selectors: Selectors = {
     network_type: 'MAINNET',
     family: 'EVM',
   },
+  '33431': {
+    selector: 13222148116102326311n,
+    name: 'edge-testnet',
+    network_type: 'TESTNET',
+    family: 'EVM',
+  },
   '34443': {
     selector: 7264351850409363825n,
     name: 'ethereum-mainnet-mode-1',
@@ -1087,6 +1099,12 @@ const selectors: Selectors = {
     network_type: 'TESTNET',
     family: 'EVM',
   },
+  '46630': {
+    selector: 2032988798112970440n,
+    name: 'robinhood-testnet',
+    network_type: 'TESTNET',
+    family: 'EVM',
+  },
   '47763': {
     selector: 7222032299962346917n,
     name: 'neox-mainnet',
@@ -1337,6 +1355,12 @@ const selectors: Selectors = {
     network_type: 'MAINNET',
     family: 'EVM',
   },
+  '202601': {
+    selector: 1091131740251125869n,
+    name: 'ethereum-testnet-sepolia-ronin-1',
+    network_type: 'TESTNET',
+    family: 'EVM',
+  },
   '421613': {
     selector: 6101244977088475029n,
     name: 'ethereum-testnet-goerli-arbitrum-1',