@chainlink/ccip-sdk 0.0.0 → 0.90.0

package/src/solana/offchain.ts

@@ -0,0 +1,209 @@
+import { type BN, BorshCoder, EventParser } from '@coral-xyz/anchor'
+import { type Connection, PublicKey } from '@solana/web3.js'
+import { hexlify } from 'ethers'
+
+import { getUsdcAttestation } from '../offchain.ts'
+import type { CCIPMessage, CCIPRequest, OffchainTokenData } from '../types.ts'
+import { networkInfo } from '../utils.ts'
+import { IDL as BASE_TOKEN_POOL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
+import { IDL as CCTP_TOKEN_POOL } from './idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts'
+import { bytesToBuffer } from './utils.ts'
+
+interface CcipCctpMessageSentEvent {
+  originalSender: PublicKey
+  remoteChainSelector: BN
+  msgTotalNonce: BN
+  eventAddress: PublicKey
+  sourceDomain: number
+  cctpNonce: BN
+  messageSentBytes: Uint8Array
+}
+
+interface CcipCctpMessageAndAttestation {
+  message: {
+    data: Uint8Array
+  }
+  attestation: Uint8Array
+}
+const cctpTokenPoolCoder = new BorshCoder({
+  ...CCTP_TOKEN_POOL,
+  types: [...BASE_TOKEN_POOL.types, ...CCTP_TOKEN_POOL.types],
+  events: BASE_TOKEN_POOL.events,
+  errors: [...BASE_TOKEN_POOL.errors, ...CCTP_TOKEN_POOL.errors],
+})
+
+/**
+ * Analyzes a Solana transaction to extract CcipCctpMessageSentEvent, fetch Circle attestation,
+ * and encode the data in the format required by the destination chain.
+ *
+ * @param request - CCIP request containing transaction data and chain routing info
+ * @returns Array of encoded offchain token data (only one supported for Solana right now)
+ *
+ * @throws Error if transaction hash is missing or CcipCctpMessageSentEvent parsing fails
+ *
+ * @example
+ * const tokenData = await fetchSolanaOffchainTokenData({
+ *   lane: { sourceChainSelector: ..., destChainSelector: ... },
+ *   message: { ... },
+ *   log: { transactionHash: "3k81TLhJuhwB8fvurCwyMPHXR3k9Tmtqe2ZrUQ8e3rMxk9fWFJT2xVHGgKJg1785FkJcaiQkthY4m86JrESGPhMY" },
+ *   tx: { logs: [...] }
+ * })
+ */
+export async function fetchSolanaOffchainTokenData(
+  connection: Connection,
+  request: Pick<CCIPRequest, 'tx' | 'lane'> & {
+    message: CCIPMessage
+    log: Pick<CCIPRequest['log'], 'topics' | 'index' | 'transactionHash'>
+  },
+): Promise<OffchainTokenData[]> {
+  if (request.message.tokenAmounts === undefined || request.message.tokenAmounts.length === 0) {
+    return []
+  }
+
+  if (request.message.tokenAmounts.length > 1) {
+    throw new Error(
+      `Expected at most 1 token transfer, found ${request.message.tokenAmounts?.length}`,
+    )
+  }
+
+  const { isTestnet } = networkInfo(request.lane.sourceChainSelector)
+  const txSignature = request.log.transactionHash
+  if (!txSignature) {
+    throw new Error('Transaction hash not found for OffchainTokenData parsing')
+  }
+
+  // Parse Solana transaction to find CCTP event
+  const cctpEvents = await parseCcipCctpEvents(connection, txSignature)
+  const offchainTokenData: OffchainTokenData[] = request.message.tokenAmounts.map(() => undefined)
+
+  // If no CcipCctpMessageSentEvent found, return defaults so we don't block execution
+  if (cctpEvents.length === 0) {
+    console.debug('No events')
+    return offchainTokenData
+  }
+
+  // Currently, we only support ONE token per transfer
+  if (cctpEvents.length > 1) {
+    throw new Error(
+      `Expected only 1 CcipCctpMessageSentEvent, found ${cctpEvents.length} in transaction ${txSignature}.`,
+    )
+  }
+
+  // NOTE: assuming USDC token is the first (and only) token in the CCIP message, we will process the CCTP event.
+  // If later multi-token transfers support is added, we need to add more info in order to match each token with it's event and offchainTokenData.
+  const cctpEvent = cctpEvents[0]
+  if (cctpEvent) {
+    const message = hexlify(cctpEvent.messageSentBytes)
+    try {
+      // Extract message bytes to fetch circle's attestation and then encode offchainTokenData.
+      const attestation = await getUsdcAttestation(message, isTestnet)
+
+      offchainTokenData[0] = { _tag: 'usdc', message, attestation }
+    } catch (error) {
+      console.warn(
+        `❌ Solana CCTP: Failed to fetch attestation for ${txSignature}:`,
+        message,
+        error,
+      )
+    }
+  }
+
+  console.debug('Got Solana offchain token data', offchainTokenData)
+
+  return offchainTokenData
+}
+
+/**
+ * Parses CcipCctpMessageSentEvent from a Solana transaction by analyzing program logs
+ *
+ * @param txSignature - Solana transaction signature to analyze
+ * @param sourceChainSelector - Source chain selector to determine RPC endpoint
+ * @returns Array of parsed CcipCctpMessageSentEvent found in the transaction (only 1 supported though)
+ *
+ * @throws Error if transaction is not found or RPC fails
+ *
+ * @example
+ * const events = await parseSolanaCctpEvents(
+ *   '3k81TLhJuhwB8fvurCwyMPHXR3k9Tmtqe2ZrUQ8e3rMxk9fWFJT2xVHGgKJg1785FkJcaiQkthY4m86JrESGPhMY',
+ *   16423721717087811551n // Solana Devnet
+ * )
+ */
+async function parseCcipCctpEvents(
+  connection: Connection,
+  txSignature: string,
+): Promise<CcipCctpMessageSentEvent[]> {
+  // Fetch transaction details using Solana RPC
+  const tx = await connection.getTransaction(txSignature, {
+    commitment: 'finalized',
+    maxSupportedTransactionVersion: 0,
+  })
+  if (!tx || !tx.meta) {
+    throw new Error(`Transaction not found: ${txSignature}`)
+  }
+
+  if (!tx.meta.logMessages?.length) {
+    throw new Error(`Transaction has no logs: ${txSignature}`)
+  }
+
+  const cctpPoolAddress = getCctpPoolAddress(tx.meta.logMessages)
+  if (!cctpPoolAddress) {
+    return []
+  }
+
+  const eventParser = new EventParser(new PublicKey(cctpPoolAddress), cctpTokenPoolCoder)
+
+  const events: CcipCctpMessageSentEvent[] = Array.from(eventParser.parseLogs(tx.meta.logMessages))
+    .filter((event) => event.name === 'CcipCctpMessageSentEvent')
+    .map((event) => event.data as unknown as CcipCctpMessageSentEvent)
+  return events
+}
+
+function getCctpPoolAddress(logs: string[]): string | null {
+  // Example logs include lines like the following (though the indexes of the "invoke [1]" are unreliable):
+  // "Program <POOL ADDRESS HERE, THIS IS WHAT WE'RE LOOKING FOR> invoke [1]",
+  // "Program log: Instruction: LockOrBurnTokens",
+  const candidateIx = logs.indexOf('Program log: Instruction: LockOrBurnTokens')
+  if (candidateIx < 1) {
+    return null
+  }
+
+  const candidateAddress = logs[candidateIx - 1].split(' ')[1]
+
+  if (!candidateAddress.toLowerCase().startsWith('ccitp')) {
+    // The vanity address of the pool includes "ccitp" (case-insensitive) as a prefix
+    return null
+  }
+
+  // basic sanity check that we have the pool address: The pool returns a value, so the logs should show that
+  const sanityCheck = logs.find((log) => log.startsWith(`Program return: ${candidateAddress} `))
+  if (!sanityCheck) {
+    return null
+  }
+
+  return candidateAddress
+}
+
+/**
+ * Encodes CCTP message and attestation
+ *
+ * @param data - OffchainTokenData (_tag="usdc")
+ * @returns Encoded data - Borsh-encoded attestation for Solana
+ */
+export function encodeSolanaOffchainTokenData(data: OffchainTokenData): string {
+  if (data?._tag === 'usdc') {
+    const messageBuffer = bytesToBuffer(data.message)
+    const attestationBuffer = bytesToBuffer(data.attestation)
+
+    // Solana destination: use Borsh encoding
+    const messageAndAttestation: CcipCctpMessageAndAttestation = {
+      message: {
+        data: messageBuffer, // u8 array
+      },
+      attestation: attestationBuffer, // u8 array
+    }
+
+    const encoded = cctpTokenPoolCoder.types.encode('MessageAndAttestation', messageAndAttestation)
+    return hexlify(encoded)
+  }
+  return '0x'
+}

package/src/solana/patchBorsh.ts

@@ -0,0 +1,67 @@
+import { BorshInstructionCoder } from '@coral-xyz/anchor'
+import { BorshTypesCoder } from '@coral-xyz/anchor/dist/cjs/coder/borsh/types.js'
+import { sha256, toUtf8Bytes } from 'ethers'
+
+import { snakeToCamel } from '../utils.ts'
+import { camelToSnakeCase } from './utils.ts'
+
+type Layout_<T = unknown> = { encode: (type: T, buffer: Buffer) => number }
+
+// monkey patch some functions to ensure correct buffer allocation (usually, hardcoded 1000B)
+Object.assign(BorshTypesCoder.prototype, {
+  encode: function <T>(this: BorshTypesCoder, name: string, type: T): Buffer {
+    const layout = (this as unknown as { typeLayouts: Map<string, Layout_> }).typeLayouts.get(name)
+    if (!layout) {
+      throw new Error(`Unknown type: ${name}`)
+    }
+    let buffer = Buffer.alloc(512)
+    let len
+    try {
+      len = layout.encode(type, buffer)
+    } catch (err) {
+      if (err instanceof RangeError) {
+        buffer = Buffer.alloc(32000)
+        len = layout.encode(type, buffer)
+      } else {
+        throw err
+      }
+    }
+
+    return buffer.subarray(0, len)
+  },
+})
+
+function sighash(nameSpace: string, ixName: string): Buffer {
+  const name = camelToSnakeCase(ixName)
+  const preimage = `${nameSpace}:${name}`
+  return Buffer.from(sha256(toUtf8Bytes(preimage)).slice(2, 18), 'hex')
+}
+
+Object.assign(BorshInstructionCoder.prototype, {
+  _encode: function (
+    this: BorshInstructionCoder,
+    nameSpace: string,
+    ixName: string,
+    ix: any, // eslint-disable-line @typescript-eslint/no-explicit-any
+  ): Buffer {
+    const methodName = snakeToCamel(ixName)
+    const layout = (this as unknown as { ixLayout: Map<string, Layout_> }).ixLayout.get(methodName)
+    if (!layout) {
+      throw new Error(`Unknown method: ${methodName}`)
+    }
+    let buffer = Buffer.alloc(512)
+    let len
+    try {
+      len = layout.encode(ix, buffer)
+    } catch (err) {
+      if (err instanceof RangeError) {
+        buffer = Buffer.alloc(32000)
+        len = layout.encode(ix, buffer)
+      } else {
+        throw err
+      }
+    }
+    const data = buffer.subarray(0, len)
+    return Buffer.concat([sighash(nameSpace, ixName), data])
+  },
+})

package/src/solana/send.ts

@@ -0,0 +1,436 @@
+import util from 'util'
+
+import { type AnchorProvider, type IdlTypes, Program } from '@coral-xyz/anchor'
+import {
+  NATIVE_MINT,
+  createApproveInstruction,
+  getAccount,
+  getAssociatedTokenAddressSync,
+} from '@solana/spl-token'
+import {
+  type AccountMeta,
+  type AddressLookupTableAccount,
+  type Connection,
+  type TransactionInstruction,
+  ComputeBudgetProgram,
+  PublicKey,
+  TransactionMessage,
+  VersionedTransaction,
+} from '@solana/web3.js'
+import BN from 'bn.js'
+import { zeroPadValue } from 'ethers'
+
+import { SolanaChain } from './index.ts'
+import type { AnyMessage } from '../types.ts'
+import { toLeArray } from '../utils.ts'
+import { IDL as CCIP_ROUTER_IDL } from './idl/1.6.0/CCIP_ROUTER.ts'
+import { bytesToBuffer, simulateTransaction, simulationProvider } from './utils.ts'
+
+function anyToSvmMessage(message: AnyMessage): IdlTypes<typeof CCIP_ROUTER_IDL>['SVM2AnyMessage'] {
+  const feeTokenPubkey = message.feeToken ? new PublicKey(message.feeToken) : PublicKey.default
+
+  const svmMessage: IdlTypes<typeof CCIP_ROUTER_IDL>['SVM2AnyMessage'] = {
+    receiver: bytesToBuffer(zeroPadValue(message.receiver, 32)),
+    data: bytesToBuffer(message.data || '0x'),
+    tokenAmounts: (message.tokenAmounts || []).map((ta) => {
+      if (!ta.token || ta.amount < 0n) {
+        throw new Error('Invalid token amount: token address and positive amount required')
+      }
+      return {
+        token: new PublicKey(ta.token),
+        amount: new BN(ta.amount),
+      }
+    }),
+    feeToken: feeTokenPubkey,
+    extraArgs: bytesToBuffer(SolanaChain.encodeExtraArgs(message.extraArgs)),
+  }
+
+  return svmMessage
+}
+
+export async function getFee(
+  connection: Connection,
+  router: string,
+  destChainSelector: bigint,
+  message: AnyMessage,
+): Promise<bigint> {
+  const program = new Program(
+    CCIP_ROUTER_IDL,
+    new PublicKey(router),
+    simulationProvider(connection),
+  )
+
+  // Get router config to find feeQuoter
+  const [configPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], program.programId)
+  const configAccount = await connection.getAccountInfo(configPda)
+  if (!configAccount) throw new Error(`Router config not found at ${configPda.toBase58()}`)
+
+  const { feeQuoter, linkTokenMint }: { feeQuoter: PublicKey; linkTokenMint: PublicKey } =
+    program.coder.accounts.decode('config', configAccount.data)
+
+  // Derive fee-related PDAs
+  const [destChainStatePda] = PublicKey.findProgramAddressSync(
+    [Buffer.from('dest_chain_state'), toLeArray(destChainSelector, 8)],
+    program.programId,
+  )
+
+  const [feeQuoterConfigPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], feeQuoter)
+
+  const [feeQuoterDestChainPda] = PublicKey.findProgramAddressSync(
+    [Buffer.from('dest_chain'), toLeArray(destChainSelector, 8)],
+    feeQuoter,
+  )
+
+  if (
+    message.feeToken &&
+    message.feeToken !== PublicKey.default.toBase58() &&
+    message.feeToken !== linkTokenMint.toBase58()
+  ) {
+    console.warn('feeToken is not default nor link =', linkTokenMint.toBase58())
+  }
+
+  // Convert feeToken to PublicKey (default to native SOL if not specified)
+  const feeTokenPubkey =
+    message.feeToken && message.feeToken !== PublicKey.default.toBase58()
+      ? new PublicKey(message.feeToken)
+      : NATIVE_MINT
+
+  const [feeQuoterBillingTokenConfigPda] = PublicKey.findProgramAddressSync(
+    [Buffer.from('fee_billing_token_config'), feeTokenPubkey.toBuffer()],
+    feeQuoter,
+  )
+
+  // LINK token config (assuming default LINK token for now)
+  const [feeQuoterLinkTokenConfigPda] = PublicKey.findProgramAddressSync(
+    [Buffer.from('fee_billing_token_config'), linkTokenMint.toBuffer()],
+    feeQuoter,
+  )
+
+  // Convert AnyMessage to SVM2AnyMessage format
+  const svmMessage = anyToSvmMessage(message)
+
+  // 2 feeQuoter PDAs per token
+  const remainingAccounts = svmMessage.tokenAmounts
+    .map((ta) => [
+      PublicKey.findProgramAddressSync(
+        [Buffer.from('fee_billing_token_config'), ta.token.toBuffer()],
+        feeQuoter,
+      )[0],
+      PublicKey.findProgramAddressSync(
+        [
+          Buffer.from('per_chain_per_token_config'),
+          toLeArray(destChainSelector, 8),
+          ta.token.toBuffer(),
+        ],
+        feeQuoter,
+      )[0],
+    ])
+    .flat()
+    .map((pubkey) => ({ pubkey, isWritable: false, isSigner: false }))
+
+  // Call getFee method
+  const result: unknown = await program.methods
+    .getFee(new BN(destChainSelector), svmMessage)
+    .accounts({
+      config: configPda,
+      destChainState: destChainStatePda,
+      feeQuoter: feeQuoter,
+      feeQuoterConfig: feeQuoterConfigPda,
+      feeQuoterDestChain: feeQuoterDestChainPda,
+      feeQuoterBillingTokenConfig: feeQuoterBillingTokenConfigPda,
+      feeQuoterLinkTokenConfig: feeQuoterLinkTokenConfigPda,
+    })
+    .remainingAccounts(remainingAccounts)
+    .view()
+
+  if (!(result as { amount?: BN })?.amount) {
+    throw new Error(`Invalid fee result from router: ${util.inspect(result)}`)
+  }
+
+  return BigInt((result as { amount: BN }).amount.toString())
+}
+
+async function deriveAccountsCcipSend({
+  router,
+  destChainSelector,
+  message,
+  sender,
+}: {
+  router: Program<typeof CCIP_ROUTER_IDL>
+  destChainSelector: bigint
+  message: IdlTypes<typeof CCIP_ROUTER_IDL>['SVM2AnyMessage']
+  sender: PublicKey
+}) {
+  const connection = router.provider.connection
+  const derivedAccounts: AccountMeta[] = []
+  const addressLookupTableAccounts: AddressLookupTableAccount[] = []
+  const tokenIndices: number[] = []
+  let askWith: AccountMeta[] = []
+  let stage = 'Start'
+  let tokenIndex = 0
+
+  const [configPDA] = PublicKey.findProgramAddressSync([Buffer.from('config')], router.programId)
+
+  // read-only copy of router which avoids signing every simulation
+  const roProgram = new Program(
+    router.idl,
+    router.programId,
+    simulationProvider(connection, sender),
+  )
+  do {
+    // Create the transaction instruction for the deriveAccountsCcipSend method
+    const response = (await roProgram.methods
+      .deriveAccountsCcipSend(
+        {
+          destChainSelector: new BN(destChainSelector.toString()),
+          ccipSendCaller: sender,
+          message,
+        },
+        stage,
+      )
+      .accounts({
+        config: configPDA,
+      })
+      .remainingAccounts(askWith)
+      .view()) as IdlTypes<typeof CCIP_ROUTER_IDL>['DeriveAccountsResponse']
+
+    // Check if it is the start of a token transfer
+    const isStartOfToken = /^TokenTransferStaticAccounts\/\d+\/0$/.test(response.currentStage)
+    if (isStartOfToken) {
+      // From CCIP_ROUTER IDL, ccipSend has 18 static accounts before remaining_accounts
+      const numStaticCcipSendAccounts = 18
+      tokenIndices.push(tokenIndex - numStaticCcipSendAccounts)
+    }
+
+    // Update token index
+    tokenIndex += response.accountsToSave.length
+
+    // Collect the derived accounts
+    for (const meta of response.accountsToSave) {
+      derivedAccounts.push({
+        pubkey: meta.pubkey,
+        isWritable: meta.isWritable,
+        isSigner: meta.isSigner,
+      })
+    }
+
+    // Prepare askWith for next iteration
+    askWith = response.askAgainWith.map(
+      (meta: IdlTypes<typeof CCIP_ROUTER_IDL>['CcipAccountMeta']) => ({
+        pubkey: meta.pubkey,
+        isWritable: meta.isWritable,
+        isSigner: meta.isSigner,
+      }),
+    )
+
+    const lookupTableAccounts = await Promise.all(
+      response.lookUpTablesToSave.map(async (table) => {
+        const lookupTableAccountInfo = await connection.getAddressLookupTable(table)
+
+        if (!lookupTableAccountInfo.value) {
+          throw new Error(`Lookup table account not found: ${table.toBase58()}`)
+        }
+
+        return lookupTableAccountInfo.value
+      }),
+    )
+
+    // Collect lookup tables
+    addressLookupTableAccounts.push(...lookupTableAccounts)
+
+    stage = response.nextStage
+  } while (stage?.length)
+
+  return {
+    accounts: derivedAccounts,
+    addressLookupTableAccounts,
+    tokenIndexes: Buffer.from(tokenIndices),
+  }
+}
+
+export async function simulateAndSendTxs(
+  connection: Connection,
+  feePayer: AnchorProvider['wallet'],
+  instructions: TransactionInstruction[],
+  addressLookupTableAccounts?: AddressLookupTableAccount[],
+) {
+  let computeUnitLimit
+  const simulated =
+    (
+      await simulateTransaction({
+        connection,
+        payerKey: feePayer.publicKey,
+        instructions,
+        addressLookupTableAccounts,
+      })
+    ).unitsConsumed || 0
+  if (simulated > 200000) computeUnitLimit = Math.ceil(simulated * 1.1)
+
+  const txMsg = new TransactionMessage({
+    payerKey: feePayer.publicKey,
+    recentBlockhash: (await connection.getLatestBlockhash('confirmed')).blockhash,
+    instructions: [
+      ...(computeUnitLimit
+        ? [ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnitLimit })]
+        : []),
+      ...instructions,
+    ],
+  })
+  const messageV0 = txMsg.compileToV0Message(addressLookupTableAccounts)
+  const tx = new VersionedTransaction(messageV0)
+
+  const signed = await feePayer.signTransaction(tx)
+  let hash
+  for (let attempt = 0; ; attempt++) {
+    try {
+      hash = await connection.sendTransaction(signed)
+      await connection.confirmTransaction(hash, 'confirmed')
+      return hash
+    } catch (error) {
+      if (attempt >= 3) throw error
+      console.error(`sendTransaction failed attempt=${attempt + 1}/3:`, error)
+    }
+  }
+}
+
+export async function ccipSend(
+  router: Program<typeof CCIP_ROUTER_IDL>,
+  destChainSelector: bigint,
+  message: AnyMessage & { fee: bigint },
+  opts?: { approveMax?: boolean },
+) {
+  const connection = router.provider.connection
+  let wallet
+  if (!(wallet = (router.provider as AnchorProvider).wallet)) {
+    throw new Error('ccipSend called without signer wallet')
+  }
+
+  const amountsToApprove = (message.tokenAmounts ?? []).reduce(
+    (acc, { token, amount }) => ({ ...acc, [token]: (acc[token] ?? 0n) + amount }),
+    {} as Record<string, bigint>,
+  )
+  if (message.feeToken && message.feeToken !== PublicKey.default.toBase58()) {
+    amountsToApprove[message.feeToken] = (amountsToApprove[message.feeToken] ?? 0n) + message.fee
+  }
+
+  const approveIxs = []
+  for (const [token, amount] of Object.entries(amountsToApprove)) {
+    const approveIx = await approveRouterSpender(
+      connection,
+      wallet.publicKey,
+      new PublicKey(token),
+      router.programId,
+      opts?.approveMax ? undefined : amount,
+    )
+    if (approveIx) approveIxs.push(approveIx)
+  }
+
+  const svmMessage = anyToSvmMessage(message)
+  const { addressLookupTableAccounts, accounts, tokenIndexes } = await deriveAccountsCcipSend({
+    router,
+    destChainSelector,
+    sender: wallet.publicKey,
+    message: svmMessage,
+  })
+
+  const sendIx = await router.methods
+    .ccipSend(new BN(destChainSelector), svmMessage, tokenIndexes)
+    .accountsStrict({
+      config: accounts[0].pubkey,
+      destChainState: accounts[1].pubkey,
+      nonce: accounts[2].pubkey,
+      authority: accounts[3].pubkey,
+      systemProgram: accounts[4].pubkey,
+      feeTokenProgram: accounts[5].pubkey,
+      feeTokenMint: accounts[6].pubkey,
+      feeTokenUserAssociatedAccount: accounts[7].pubkey,
+      feeTokenReceiver: accounts[8].pubkey,
+      feeBillingSigner: accounts[9].pubkey,
+      feeQuoter: accounts[10].pubkey,
+      feeQuoterConfig: accounts[11].pubkey,
+      feeQuoterDestChain: accounts[12].pubkey,
+      feeQuoterBillingTokenConfig: accounts[13].pubkey,
+      feeQuoterLinkTokenConfig: accounts[14].pubkey,
+      rmnRemote: accounts[15].pubkey,
+      rmnRemoteCurses: accounts[16].pubkey,
+      rmnRemoteConfig: accounts[17].pubkey,
+    })
+    .remainingAccounts(accounts.slice(18))
+    .instruction()
+
+  let hash
+  try {
+    // first try to serialize and send a single tx containing approve and send ixs
+    hash = await simulateAndSendTxs(
+      connection,
+      wallet,
+      [...approveIxs, sendIx],
+      addressLookupTableAccounts,
+    )
+  } catch (err) {
+    if (
+      !approveIxs.length ||
+      !(err instanceof Error) ||
+      !['encoding overruns Uint8Array', 'too large'].some((e) => err.message.includes(e))
+    )
+      throw err
+    // if serialization fails, send approve txs separately
+    for (const approveIx of approveIxs) await simulateAndSendTxs(connection, wallet, [approveIx])
+    hash = await simulateAndSendTxs(connection, wallet, [sendIx], addressLookupTableAccounts)
+  }
+
+  return { hash }
+}
+
+async function approveRouterSpender(
+  connection: Connection,
+  owner: PublicKey,
+  token: PublicKey,
+  router: PublicKey,
+  amount?: bigint,
+): Promise<TransactionInstruction | undefined> {
+  // Get the current account info to check existing delegation (or create if needed)
+  const mintInfo = await connection.getAccountInfo(token)
+  if (!mintInfo) throw new Error(`Mint ${token.toBase58()} not found`)
+  const associatedTokenAccount = getAssociatedTokenAddressSync(
+    token,
+    owner,
+    undefined,
+    mintInfo.owner,
+  )
+  const accountInfo = await getAccount(
+    connection,
+    associatedTokenAccount,
+    undefined,
+    mintInfo.owner,
+  )
+
+  // spender is a Router PDA
+  const [spender] = PublicKey.findProgramAddressSync([Buffer.from('fee_billing_signer')], router)
+
+  // Check if we need to approve
+  const needsApproval =
+    !accountInfo.delegate ||
+    !accountInfo.delegate.equals(spender) ||
+    (amount != null && accountInfo.delegatedAmount < amount)
+
+  if (!needsApproval) return
+  // Approve the spender to use tokens from the user's account
+  const approveIx = createApproveInstruction(
+    accountInfo.address,
+    spender,
+    owner,
+    amount ?? BigInt(Number.MAX_SAFE_INTEGER),
+    undefined,
+    mintInfo.owner,
+  )
+  console.info(
+    'Approving',
+    amount ?? BigInt(Number.MAX_SAFE_INTEGER),
+    'of',
+    token.toBase58(),
+    'tokens to router',
+    router.toBase58(),
+  )
+  return approveIx
+}