@chainlink/ccip-sdk 0.0.0 → 0.90.0

package/src/solana/types.ts

@@ -0,0 +1,6 @@
+import type { SVMExtraArgsV1 } from '../extra-args.ts'
+import type { CCIPMessage_V1_6 } from '../types.ts'
+
+// SourceTokenData adds `destGasAmount` (decoded from source's `destExecData`);
+// not sure why they kept the "gas" name in Solana, but let's just be keep consistent
+export type CCIPMessage_V1_6_Solana = CCIPMessage_V1_6 & SVMExtraArgsV1

package/src/solana/utils.ts

@@ -0,0 +1,272 @@
+import {
+  type AddressLookupTableAccount,
+  type Connection,
+  type Signer,
+  type SimulateTransactionConfig,
+  type Transaction,
+  type TransactionInstruction,
+  ComputeBudgetProgram,
+  PublicKey,
+  SendTransactionError,
+  TransactionMessage,
+  VersionedTransaction,
+} from '@solana/web3.js'
+import { type BytesLike, dataLength, dataSlice, hexlify } from 'ethers'
+
+import type { Log_ } from '../types.ts'
+import { getDataBytes, sleep } from '../utils.ts'
+
+export function bytesToBuffer(bytes: BytesLike): Buffer {
+  return Buffer.from(getDataBytes(bytes).buffer)
+}
+
+export async function waitForFinalization(
+  connection: Connection,
+  signature: string,
+  intervalMs = 500,
+  maxAttempts = 500,
+): Promise<void> {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const status = await connection.getSignatureStatuses([signature])
+    const info = status.value[0]
+
+    if (info?.confirmationStatus === 'finalized') {
+      return
+    }
+    await sleep(intervalMs)
+  }
+
+  throw new Error(`Transaction ${signature} not finalized after timeout`)
+}
+
+export function camelToSnakeCase(str: string): string {
+  return str
+    .replace(/([A-Z]+)([A-Z][a-z]|$)/g, (_, p1: string, p2: string) => {
+      if (p2) {
+        return `_${p1.slice(0, -1).toLowerCase()}_${p2.toLowerCase()}`
+      }
+      return `_${p1.toLowerCase()}`
+    })
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .toLowerCase()
+    .replace(/^_/, '')
+}
+
+type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & { data: string }
+
+/**
+ * Utility function to parse Solana logs with proper address and topic extraction.
+ *
+ * Solana logs are structured as a stack-based execution trace:
+ * - "Program <address> invoke [<depth>]" - Program call starts
+ * - "Program log: <data>" - Program emitted a log message
+ * - "Program data: <base64>" - Program emitted structured data (Anchor events)
+ * - "Program <address> success/failed" - Program call ends
+ *
+ * This function:
+ * 1. Tracks the program call stack to determine which program emitted each log
+ * 2. Extracts the first 8 bytes from base64 "Program data:" logs as topics (event discriminants)
+ * 3. Converts logs to EVM-compatible Log_ format for CCIP compatibility
+ * 4. Returns ALL logs from the transaction - filtering should be done by the caller
+ *
+ * @param logs - Array of logMessages from Solana transaction
+ * @returns Array of parsed log objects from all programs in the transaction
+ */
+export function parseSolanaLogs(logs: readonly string[]): ParsedLog[] {
+  const results: ReturnType<typeof parseSolanaLogs> = []
+  const programStack: string[] = []
+
+  for (const [i, log] of logs.entries()) {
+    // Track program calls and returns to maintain the address stack
+    let match
+    if ((match = log.match(/^Program (\w+) invoke\b/))) {
+      programStack.push(match[1])
+    } else if ((match = log.match(/^Program (\w+) (success|failed)\b/))) {
+      // Pop from stack when program returns
+      programStack.pop()
+    } else if ((match = log.match(/^Program (log|data): /))) {
+      // Extract the actual log data
+      const logData = log.slice(match[0].length)
+      const currentProgram = programStack[programStack.length - 1]
+      let topics: string[] = []
+
+      if (log.startsWith('Program data: ')) {
+        try {
+          // Try to decode base64 and extract first 8 bytes as topic/discriminant
+          const buffer = getDataBytes(logData)
+          if (dataLength(buffer) >= 8) {
+            topics = [dataSlice(buffer, 0, 8)]
+          }
+        } catch {
+          // If base64 decoding fails, leave topics empty
+        }
+      }
+      // For regular log messages, use the current program on stack
+      results.push({
+        topics,
+        index: i,
+        address: currentProgram,
+        data: logData,
+      })
+    }
+  }
+
+  return results
+}
+
+export function getErrorFromLogs(
+  logs_: readonly string[] | readonly Pick<Log_, 'address' | 'index' | 'data' | 'topics'>[] | null,
+): { program: string; [k: string]: string } | undefined {
+  if (!logs_?.length) return
+  let logs
+  if (logs_.every((l) => typeof l === 'string')) logs = parseSolanaLogs(logs_)
+  else logs = logs_
+
+  const lastLog = logs[logs.length - 1]
+  // collect all logs from the last program execution (the one which failed)
+  const lastProgramLogs = logs
+    .reduceRight(
+      (acc, l) =>
+        // if acc is empty (i.e. on last log), or it is emitted by the same program and not a Program data:
+        !acc.length || (l.address === acc[0].address && !l.topics?.length) ? [l, ...acc] : acc,
+      [] as Pick<Log_, 'address' | 'index' | 'data'>[],
+    )
+    .map(({ data }) => data as string)
+    .reduceRight(
+      (acc, l) =>
+        l.endsWith(':') && acc.length
+          ? [`${l} ${acc[0]}`, ...acc.slice(1)]
+          : l.split(': ').length > 1 && l.split('. ').length > 1
+            ? [...l.replace(/\.$/, '').split('. '), ...acc]
+            : [l, ...acc],
+      [] as string[],
+    ) // cosmetic: join lines ending in ':' with next
+    .map((l) => {
+      try {
+        // convert number[]s (common in solana logs) into slightly more readable 0x-bytearrays
+        return l.replace(/\[(\d{1,3}, ){3,}\d+\]/g, (m) =>
+          hexlify(
+            new Uint8Array(
+              m
+                .substring(1, m.length - 1)
+                .split(', ')
+                .map((x) => +x),
+            ),
+          ),
+        )
+      } catch (_) {
+        return l
+      }
+    })
+  if (lastProgramLogs.every((l) => l.indexOf(': ') >= 0)) {
+    return {
+      program: lastLog.address,
+      ...Object.fromEntries(
+        lastProgramLogs.map((l) => [
+          l.substring(0, l.indexOf(': ')),
+          l.substring(l.indexOf(': ') + 2),
+        ]),
+      ),
+    }
+  } else {
+    return {
+      program: lastLog.address,
+      error: lastProgramLogs.join('\n'),
+    }
+  }
+}
+
+export async function simulateTransaction({
+  connection,
+  payerKey,
+  computeUnitsOverride,
+  ...rest
+}: {
+  connection: Connection
+  payerKey: PublicKey
+  computeUnitsOverride?: number
+  addressLookupTableAccounts?: AddressLookupTableAccount[]
+} & ({ instructions: TransactionInstruction[] } | { tx: Transaction | VersionedTransaction })) {
+  // Add max compute units for simulation
+  const maxComputeUnits = 1_400_000
+  const recentBlockhash = '11111111111111111111111111111112'
+  const computeBudgetIx = ComputeBudgetProgram.setComputeUnitLimit({
+    units: computeUnitsOverride || maxComputeUnits,
+  })
+
+  let tx: VersionedTransaction
+  if (!('tx' in rest)) {
+    // Create message with compute budget instruction
+    const message = new TransactionMessage({
+      payerKey,
+      recentBlockhash,
+      instructions: [computeBudgetIx, ...rest.instructions],
+    })
+
+    const messageV0 = message.compileToV0Message(rest.addressLookupTableAccounts)
+    tx = new VersionedTransaction(messageV0)
+  } else if (!('version' in rest.tx)) {
+    // Create message with compute budget instruction
+    const message = new TransactionMessage({
+      payerKey,
+      recentBlockhash,
+      instructions: [computeBudgetIx, ...rest.tx.instructions],
+    })
+
+    const messageV0 = message.compileToV0Message(rest.addressLookupTableAccounts)
+    tx = new VersionedTransaction(messageV0)
+  } else {
+    tx = rest.tx
+  }
+
+  const config: SimulateTransactionConfig = {
+    commitment: 'confirmed',
+    replaceRecentBlockhash: true,
+    sigVerify: false,
+  }
+
+  const result = await connection.simulateTransaction(tx, config)
+
+  if (result.value.err) {
+    console.debug('Simulation results:', {
+      logs: result.value.logs,
+      unitsConsumed: result.value.unitsConsumed,
+      returnData: result.value.returnData,
+      err: result.value.err,
+    })
+    // same error sendTransaction sends, to be catched up
+    throw new SendTransactionError({
+      action: 'simulate',
+      signature: '',
+      transactionMessage: JSON.stringify(result.value.err),
+      logs: result.value.logs!,
+    })
+  }
+
+  return result.value
+}
+
+/**
+ * Used as `provider` in anchor's `Program` constructor, to support `.view()` simulations
+ * without * requiring a full AnchorProvider with wallet
+ * @param connection - Connection to the Solana network
+ * @param feePayer - Fee payer for the simulated transaction
+ * @returns Value returned by the simulated method
+ */
+export function simulationProvider(
+  connection: Connection,
+  feePayer: PublicKey = new PublicKey('11111111111111111111111111111112'),
+) {
+  return {
+    connection,
+    wallet: {
+      publicKey: feePayer,
+    },
+    simulate: async (tx: Transaction | VersionedTransaction, _signers?: Signer[]) =>
+      simulateTransaction({
+        connection,
+        payerKey: feePayer,
+        tx,
+      }),
+  }
+}

package/src/sui/hasher.ts

@@ -0,0 +1,90 @@
+import { concat, id, keccak256, zeroPadValue } from 'ethers'
+
+import { encodeNumber, encodeRawBytes } from '../aptos/utils.ts'
+import { decodeExtraArgs } from '../extra-args.ts'
+import { type LeafHasher, LEAF_DOMAIN_SEPARATOR } from '../hasher/common.ts'
+import { type CCIPMessage, type CCIPMessage_V1_6, CCIPVersion } from '../types.ts'
+import type { CCIPMessage_V1_6_Sui } from './types.ts'
+
+export function getSuiLeafHasher<V extends CCIPVersion = CCIPVersion>({
+  sourceChainSelector,
+  destChainSelector,
+  onRamp,
+  version,
+}: {
+  sourceChainSelector: bigint
+  destChainSelector: bigint
+  onRamp: string
+  version: V
+}): LeafHasher<V> {
+  let metadataHash: string
+  switch (version) {
+    case CCIPVersion.V1_6:
+      metadataHash = hashSuiMetadata(sourceChainSelector, destChainSelector, onRamp)
+      return ((message: CCIPMessage<typeof CCIPVersion.V1_6>): string =>
+        hashV16SuiMessage(message, metadataHash)) as LeafHasher<V>
+    default:
+      throw new Error(`Unsupported hasher version for Sui: ${version as string}`)
+  }
+}
+
+export function hashV16SuiMessage(
+  message: CCIPMessage_V1_6 | CCIPMessage_V1_6_Sui,
+  metadataHash: string,
+): string {
+  let tokenReceiver, gasLimit
+  if ('tokenReceiver' in message) {
+    ;({ tokenReceiver, gasLimit } = message)
+  } else {
+    const parsedArgs = decodeExtraArgs(message.extraArgs)
+    if (!parsedArgs || parsedArgs._tag !== 'SuiExtraArgsV1')
+      throw new Error('Invalid extraArgs for Sui message, must be SUIExtraArgsV1')
+    ;({ tokenReceiver, gasLimit } = parsedArgs)
+  }
+
+  const innerHash = concat([
+    encodeNumber(message.header.messageId),
+    zeroPadValue(message.receiver, 32),
+    encodeNumber(message.header.sequenceNumber),
+    encodeNumber(gasLimit),
+    zeroPadValue(tokenReceiver, 32),
+    encodeNumber(message.header.nonce),
+  ])
+
+  const tokenHash = concat([
+    encodeNumber(message.tokenAmounts.length),
+    ...message.tokenAmounts.map((token) =>
+      concat([
+        encodeRawBytes(token.sourcePoolAddress),
+        zeroPadValue(token.destTokenAddress, 32),
+        encodeNumber(token.destGasAmount),
+        encodeRawBytes(token.extraData),
+        encodeNumber(token.amount),
+      ]),
+    ),
+  ])
+
+  const outerHash = concat([
+    zeroPadValue(LEAF_DOMAIN_SEPARATOR, 32),
+    metadataHash,
+    keccak256(innerHash),
+    keccak256(message.sender),
+    keccak256(message.data),
+    keccak256(tokenHash),
+  ])
+
+  return keccak256(outerHash)
+}
+
+export const hashSuiMetadata = (
+  sourceChainSelector: bigint,
+  destChainSelector: bigint,
+  onRamp: string,
+): string => {
+  const versionHash = id('Any2SuiMessageHashV1')
+  const encodedSource = encodeNumber(sourceChainSelector)
+  const encodedDest = encodeNumber(destChainSelector)
+  const onrampHash = keccak256(onRamp)
+
+  return keccak256(concat([versionHash, encodedSource, encodedDest, onrampHash]))
+}

package/src/sui/index.ts

@@ -0,0 +1,198 @@
+import { type BytesLike, isBytesLike } from 'ethers'
+
+import { AptosChain } from '../aptos/index.ts'
+import { type ChainTransaction, type LogFilter, Chain, ChainFamily } from '../chain.ts'
+import type { EVMExtraArgsV2, ExtraArgs, SVMExtraArgsV1 } from '../extra-args.ts'
+import type { LeafHasher } from '../hasher/common.ts'
+import { supportedChains } from '../supported-chains.ts'
+import type {
+  AnyMessage,
+  CCIPRequest,
+  CommitReport,
+  ExecutionReceipt,
+  ExecutionReport,
+  Lane,
+  Log_,
+  NetworkInfo,
+  OffchainTokenData,
+} from '../types.ts'
+import type { CCIPMessage_V1_6_Sui } from './types.ts'
+
+export class SuiChain extends Chain<typeof ChainFamily.Sui> {
+  static readonly family = ChainFamily.Sui
+  static readonly decimals = 8
+
+  readonly network: NetworkInfo<typeof ChainFamily.Sui>
+
+  constructor() {
+    super()
+    throw new Error('Not implemented')
+  }
+
+  static async fromUrl(_url: string): Promise<SuiChain> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async destroy(): Promise<void> {
+    // Nothing to cleanup for Aptos implementation
+  }
+
+  async getBlockTimestamp(_version: number | 'finalized'): Promise<number> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getTransaction(_hash: string | number): Promise<ChainTransaction> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  // eslint-disable-next-line require-yield
+  async *getLogs(_opts: LogFilter & { versionAsHash?: boolean }) {
+    await Promise.resolve()
+    throw new Error('Not implemented')
+  }
+
+  async typeAndVersion(
+    _address: string,
+  ): Promise<
+    | [type_: string, version: string, typeAndVersion: string]
+    | [type_: string, version: string, typeAndVersion: string, suffix: string]
+  > {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getRouterForOnRamp(_onRamp: string, _destChainSelector: bigint): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getRouterForOffRamp(_offRamp: string, _sourceChainSelector: bigint): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getNativeTokenForRouter(_router: string): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getOffRampsForRouter(_router: string, _sourceChainSelector: bigint): Promise<string[]> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getOnRampForRouter(_router: string, _destChainSelector: bigint): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getOnRampForOffRamp(_offRamp: string, _sourceChainSelector: bigint): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getCommitStoreForOffRamp(_offRamp: string): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getTokenForTokenPool(_tokenPool: string): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getTokenInfo(_token: string): Promise<{ symbol: string; decimals: number }> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  getTokenAdminRegistryFor(_address: string): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getWalletAddress(_opts?: { wallet?: unknown }): Promise<string> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  // Static methods for decoding
+  static decodeMessage(_log: Log_): CCIPMessage_V1_6_Sui | undefined {
+    throw new Error('Not implemented')
+  }
+
+  static decodeExtraArgs(
+    extraArgs: BytesLike,
+  ):
+    | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
+    | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
+    | undefined {
+    return AptosChain.decodeExtraArgs(extraArgs)
+  }
+
+  static encodeExtraArgs(extraArgs: ExtraArgs): string {
+    return AptosChain.encodeExtraArgs(extraArgs)
+  }
+
+  static decodeCommits(_log: Log_, _lane?: Lane): CommitReport[] | undefined {
+    throw new Error('Not implemented')
+  }
+
+  static decodeReceipt(_log: Log_): ExecutionReceipt | undefined {
+    throw new Error('Not implemented')
+  }
+
+  static getAddress(bytes: BytesLike): string {
+    return AptosChain.getAddress(bytes)
+  }
+
+  static getDestLeafHasher(_lane: Lane): LeafHasher {
+    throw new Error('Not implemented')
+  }
+
+  async getFee(_router: string, _destChainSelector: bigint, _message: AnyMessage): Promise<bigint> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async sendMessage(
+    _router: string,
+    _destChainSelector: bigint,
+    _message: AnyMessage & { fee: bigint },
+    _opts?: { wallet?: unknown; approveMax?: boolean },
+  ): Promise<ChainTransaction> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  fetchOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
+    if (!('receiverObjectIds' in request.message)) {
+      throw new Error('Invalid message, not v1.6 Sui')
+    }
+    // default offchain token data
+    return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
+  }
+
+  async executeReport(
+    _offRamp: string,
+    _execReport: ExecutionReport,
+    _opts?: { wallet?: unknown; gasLimit?: number },
+  ): Promise<ChainTransaction> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  static parse(data: unknown) {
+    if (isBytesLike(data)) {
+      const parsedExtraArgs = this.decodeExtraArgs(data)
+      if (parsedExtraArgs) return parsedExtraArgs
+    }
+  }
+
+  async getSupportedTokens(_address: string): Promise<string[]> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getRegistryTokenConfig(_address: string, _tokenName: string): Promise<never> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getTokenPoolConfigs(_tokenPool: string): Promise<never> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async getTokenPoolRemotes(_tokenPool: string): Promise<never> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  async listFeeTokens(_router: string): Promise<never> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+}
+
+supportedChains[ChainFamily.Sui] = SuiChain

package/src/sui/types.ts

@@ -0,0 +1,22 @@
+import { bcs } from '@mysten/sui/bcs'
+import { concat } from 'ethers'
+
+import { type SuiExtraArgsV1, SuiExtraArgsV1Tag } from '../extra-args.ts'
+import type { CCIPMessage_V1_6 } from '../types.ts'
+import { getAddressBytes, getDataBytes } from '../utils.ts'
+
+export type CCIPMessage_V1_6_Sui = CCIPMessage_V1_6 & SuiExtraArgsV1
+
+export const SuiExtraArgsV1Codec = bcs.struct('SuiExtraArgsV1', {
+  gasLimit: bcs.u64(),
+  allowOutOfOrderExecution: bcs.bool(),
+  tokenReceiver: bcs.vector(bcs.u8()),
+  receiverObjectIds: bcs.vector(bcs.vector(bcs.u8())),
+})
+
+export function encodeSuiExtraArgsV1(args: SuiExtraArgsV1): string {
+  const tokenReceiver = getAddressBytes(args.tokenReceiver)
+  const receiverObjectIds = args.receiverObjectIds.map((id) => getDataBytes(id))
+  const bcsData = SuiExtraArgsV1Codec.serialize({ ...args, tokenReceiver, receiverObjectIds })
+  return concat([SuiExtraArgsV1Tag, bcsData.toBytes()])
+}

package/src/supported-chains.ts

@@ -0,0 +1,4 @@
+import type { ChainFamily, ChainStatic } from './chain.ts'
+
+// global record; can be mutated when implementing or extending a Chain family support
+export const supportedChains: Partial<{ [F in ChainFamily]: ChainStatic<F> }> = {}