@chainlink/ccip-sdk 0.93.0 → 0.95.0

package/src/utils.ts

@@ -1,3 +1,5 @@
+import { Buffer } from 'buffer'
+
 import bs58 from 'bs58'
 import {
   type BigNumberish,
@@ -10,6 +12,7 @@ import {
   toBigInt,
 } from 'ethers'
 import { memoize } from 'micro-memoize'
+import yaml from 'yaml'
 
 import type { Chain, ChainStatic } from './chain.ts'
 import {
@@ -22,6 +25,7 @@ import {
   CCIPTypeVersionInvalidError,
   HttpStatus,
 } from './errors/index.ts'
+import { getRetryDelay, shouldRetry } from './errors/utils.ts'
 import SELECTORS from './selectors.ts'
 import { supportedChains } from './supported-chains.ts'
 import { type NetworkInfo, type WithLogger, ChainFamily } from './types.ts'
@@ -101,6 +105,9 @@ export async function getSomeBlockNumberBefore(
   return beforeBlockNumber
 }
 
+/**
+ * Checks if a chain is a testnet
+ */
 // memoized so we always output the same object for a given chainId
 const networkInfoFromChainId = memoize((chainId: NetworkInfo['chainId']): NetworkInfo => {
   const sel = SELECTORS[chainId]
@@ -110,7 +117,7 @@ const networkInfoFromChainId = memoize((chainId: NetworkInfo['chainId']): Networ
     chainSelector: sel.selector,
     name: sel.name,
     family: sel.family,
-    isTestnet: !sel.name.includes('-mainnet'),
+    networkType: sel.network_type,
   } as NetworkInfo
 })
 
@@ -218,13 +225,23 @@ export function bigIntReviver(_key: string, value: unknown): unknown {
   return value
 }
 
+/**
+ * Parses JSON text with BigInt support for large integers.
+ * Uses yaml parser which handles integers as BigInt when they exceed safe integer range.
+ * @param text - JSON string to parse
+ * @returns Parsed object with large integers as BigInt
+ */
+export function parseJson<T = unknown>(text: string): T {
+  return yaml.parse(text, { intAsBigInt: true }) as T
+}
+
 /**
  * Decode address from a 32-byte hex string
  **/
 export function decodeAddress(address: BytesLike, family: ChainFamily = ChainFamily.EVM): string {
   const chain = supportedChains[family]
   if (!chain) throw new CCIPChainFamilyUnsupportedError(family)
-  return chain.getAddress(getAddressBytes(address))
+  return chain.getAddress(address)
 }
 
 /**
@@ -253,7 +270,7 @@ export function decodeOnRampAddress(
   family: ChainFamily = ChainFamily.EVM,
 ): string {
   let decoded = decodeAddress(address, family)
-  if (family === ChainFamily.Aptos) decoded += '::onramp'
+  if (family === ChainFamily.Aptos || family === ChainFamily.Sui) decoded += '::onramp'
   return decoded
 }
 
@@ -297,6 +314,8 @@ export function getDataBytes(data: BytesLike | readonly number[]): Uint8Array {
   if (Array.isArray(data)) return new Uint8Array(data)
   if (typeof data === 'string' && data.match(/^[0-9a-f]+[a-f][0-9a-f]+$/i)) data = '0x' + data
   else if (typeof data === 'string' && data.match(/^0X[0-9a-fA-F]+$/)) data = data.toLowerCase()
+  if (typeof data === 'string' && data.startsWith('0x') && data.length % 2)
+    data = '0x0' + data.slice(2)
   if (isBytesLike(data)) {
     return getBytes(data)
   } else if (isBase64(data)) {
@@ -320,20 +339,33 @@ export function bytesToBuffer(bytes: BytesLike | readonly number[]): Buffer {
  * @param address - Address in hex or Base58 format.
  * @returns Address bytes as Uint8Array.
  */
-export function getAddressBytes(address: BytesLike): Uint8Array {
-  let bytes: Uint8Array
-  if (isBytesLike(address)) {
-    bytes = getBytes(address)
+export function getAddressBytes(address: BytesLike | readonly number[]): Uint8Array {
+  let bytes
+  if (address instanceof Uint8Array) {
+    bytes = address
+  } else if (Array.isArray(address)) {
+    bytes = new Uint8Array(address)
+  } else if (
+    typeof address === 'string' &&
+    address.match(/^((0x[0-9a-f]*)|[0-9a-f]{40,})(::.*)?$/i)
+  ) {
+    address = address.split('::')[0]! // discard possible Aptos/Sui module suffix
+    // supports with or without (long>=20B) 0x-prefix, odd or even length
+    bytes = getBytes(
+      address.length % 2
+        ? '0x0' + (address.toLowerCase().startsWith('0x') ? address.slice(2) : address)
+        : !address.toLowerCase().startsWith('0x')
+          ? '0x' + address
+          : address,
+    )
   } else {
-    bytes = bs58.decode(address)
-  }
-  if (bytes.length > 20) {
-    if (
-      bytes.slice(0, bytes.length - 20).every((b) => b === 0) &&
-      bytes.slice(-20).some((b) => b !== 0)
-    ) {
-      bytes = bytes.slice(-20)
+    try {
+      const bytes_ = bs58.decode(address as string)
+      if (bytes_.length % 32 === 0) bytes = bytes_
+    } catch (_) {
+      // pass
     }
+    if (!bytes) bytes = decodeBase64(address as string)
   }
   return bytes
 }
@@ -354,7 +386,9 @@ export function convertKeysToCamelCase(
   mapValues?: (value: unknown, key?: string) => unknown,
   key?: string,
 ): unknown {
-  if (Array.isArray(obj)) {
+  if (Array.isArray(obj) && obj.every((v) => typeof v === 'number')) {
+    return mapValues ? mapValues(obj, key) : obj
+  } else if (Array.isArray(obj)) {
     return obj.map((v) => convertKeysToCamelCase(v, mapValues, key))
   }
 
@@ -377,6 +411,109 @@ export function convertKeysToCamelCase(
  */
 export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms).unref())
 
+/**
+ * Configuration for the withRetry utility.
+ */
+export type WithRetryConfig = {
+  /** Maximum number of retry attempts */
+  maxRetries: number
+  /** Initial delay in milliseconds before the first retry */
+  initialDelayMs: number
+  /** Multiplier applied to delay after each retry */
+  backoffMultiplier: number
+  /** Maximum delay in milliseconds between retries */
+  maxDelayMs: number
+  /** Whether to respect the error's retryAfterMs hint */
+  respectRetryAfterHint: boolean
+  /** Optional logger for retry attempts */
+  logger?: { debug: (...args: unknown[]) => void; warn: (...args: unknown[]) => void }
+}
+
+/**
+ * Executes an async operation with retry logic and exponential backoff.
+ * Only retries on transient errors (as determined by shouldRetry from errors/utils).
+ *
+ * @param operation - Async function to execute
+ * @param config - Retry configuration
+ * @returns Promise resolving to the operation result
+ * @throws The last error encountered after all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => apiClient.getMessageById(id),
+ *   {
+ *     maxRetries: 3,
+ *     initialDelayMs: 1000,
+ *     backoffMultiplier: 2,
+ *     maxDelayMs: 30000,
+ *     respectRetryAfterHint: true,
+ *   }
+ * )
+ * ```
+ */
+export async function withRetry<T>(
+  operation: () => Promise<T>,
+  config: WithRetryConfig,
+): Promise<T> {
+  const {
+    maxRetries,
+    initialDelayMs,
+    backoffMultiplier,
+    maxDelayMs,
+    respectRetryAfterHint,
+    logger,
+  } = config
+
+  let lastError: CCIPError | undefined
+  let delay = initialDelayMs
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation()
+    } catch (err) {
+      lastError = CCIPError.isCCIPError(err) ? err : CCIPError.from(err, 'UNKNOWN')
+
+      // Only retry on transient errors
+      if (!shouldRetry(lastError)) {
+        throw lastError
+      }
+
+      // Don't sleep after the last attempt
+      if (attempt >= maxRetries) {
+        logger?.warn(`All ${maxRetries} retries exhausted:`, lastError.message)
+        break
+      }
+
+      // Calculate delay for next retry
+      let nextDelay = delay
+
+      // Respect error's retryAfterMs hint if configured
+      if (respectRetryAfterHint) {
+        const hintDelay = getRetryDelay(lastError)
+        if (hintDelay !== null) {
+          nextDelay = Math.max(delay, hintDelay)
+        }
+      }
+
+      // Cap at maxDelayMs
+      nextDelay = Math.min(nextDelay, maxDelayMs)
+
+      logger?.debug(
+        `Retry attempt ${attempt + 1}/${maxRetries} after ${nextDelay}ms:`,
+        lastError.message,
+      )
+
+      await sleep(nextDelay)
+
+      // Apply exponential backoff for next iteration
+      delay = Math.min(delay * backoffMultiplier, maxDelayMs)
+    }
+  }
+
+  throw lastError!
+}
+
 /**
  * Parses a typeAndVersion string into its components.
  * @param typeAndVersion - String in format "TypeName vX.Y.Z".