@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/solana/exec.ts

@@ -1,119 +1,52 @@
-import { type AnchorProvider, type IdlTypes, Program } from '@coral-xyz/anchor'
+import { Buffer } from 'buffer'
+
+import { type IdlTypes, Program } from '@coral-xyz/anchor'
 import {
   type AccountMeta,
-  type Transaction,
+  type Connection,
   type TransactionInstruction,
   AddressLookupTableAccount,
   AddressLookupTableProgram,
-  ComputeBudgetProgram,
   PublicKey,
-  SendTransactionError,
   SystemProgram,
-  TransactionExpiredBlockheightExceededError,
-  TransactionMessage,
-  VersionedTransaction,
 } from '@solana/web3.js'
 import BN from 'bn.js'
 import { hexlify } from 'ethers'
 
-import type { ExecutionReport } from '../types.ts'
+import { type ExecutionReport, type WithLogger, ChainFamily } from '../types.ts'
 import { IDL as CCIP_OFFRAMP_IDL } from './idl/1.6.0/CCIP_OFFRAMP.ts'
 import { encodeSolanaOffchainTokenData } from './offchain.ts'
-import type { CCIPMessage_V1_6_Solana } from './types.ts'
-import type { ChainTransaction } from '../chain.ts'
-import { getDataBytes, sleep, toLeArray } from '../utils.ts'
-import { bytesToBuffer, simulateTransaction, simulationProvider } from './utils.ts'
-import './patchBorsh.ts'
-
-type ExecStepTx = readonly [reason: string, transactions: VersionedTransaction]
+import type { CCIPMessage_V1_6_Solana, UnsignedSolanaTx } from './types.ts'
+import { getDataBytes, toLeArray } from '../utils.ts'
+import { bytesToBuffer } from './utils.ts'
 
 type ExecAlt = {
-  addressLookupTableAccount: AddressLookupTableAccount
-  initialTxs: ExecStepTx[]
-  finalTxs: ExecStepTx[]
-}
-
-export async function executeReport({
-  offrampProgram,
-  execReport,
-  ...opts
-}: {
-  offrampProgram: Program<typeof CCIP_OFFRAMP_IDL>
-  execReport: ExecutionReport<CCIPMessage_V1_6_Solana>
-  gasLimit?: number
-  forceLookupTable?: boolean
-  forceBuffer?: boolean
-  clearLeftoverAccounts?: boolean
-}): Promise<Pick<ChainTransaction, 'hash'>> {
-  const provider = offrampProgram.provider as AnchorProvider
-  const wallet = provider.wallet
-  const connection = provider.connection
-
-  const execTxs = await buildExecTxToSolana(offrampProgram, execReport, opts?.gasLimit, opts)
-
-  let execTxSignature: string, signature: string
-  for (const [i, [reason, transaction]] of execTxs.entries()) {
-    // Refresh the blockhash for each transaction, as the blockhash is only valid for a short time
-    // and we spend a lot of time waiting for finalization of the previous transactions.
-    transaction.message.recentBlockhash = (await connection.getLatestBlockhash()).blockhash
-
-    const signed = await wallet.signTransaction(transaction)
-
-    try {
-      signature = await connection.sendTransaction(signed)
-
-      if (reason === 'exec') execTxSignature = signature
-    } catch (e) {
-      if (
-        e instanceof SendTransactionError &&
-        e.logs?.some((log) =>
-          log.includes('Error Code: ExecutionReportBufferAlreadyContainsChunk.'),
-        )
-      ) {
-        console.warn(
-          `Skipping tx ${i + 1} of ${execTxs.length} because a chunk is already in the buffer.`,
-        )
-        continue
-      } else {
-        throw e
-      }
-    }
-
-    console.debug(`Confirming tx #${i + 1} of ${execTxs.length}: ${signature} (${reason})...`)
-    for (let currentAttempt = 0; ; currentAttempt++) {
-      try {
-        const latestBlockhash = await connection.getLatestBlockhash()
-        await connection.confirmTransaction(
-          {
-            signature,
-            blockhash: latestBlockhash.blockhash,
-            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
-          },
-          'confirmed',
-        )
-        break
-      } catch (e) {
-        if (currentAttempt < 5 && e instanceof TransactionExpiredBlockheightExceededError) {
-          await sleep(1000)
-        } else {
-          throw e
-        }
-      }
-    }
-  }
-
-  return { hash: execTxSignature! }
+  initialIxs: TransactionInstruction[]
+  lookupTable: AddressLookupTableAccount
+  finalIxs: TransactionInstruction[]
 }
 
-async function buildExecTxToSolana(
-  offrampProgram: Program<typeof CCIP_OFFRAMP_IDL>,
+/**
+ * Generate unsigned tx to execute a CCIP report on Solana.
+ * @param ctx - Context containing connection and logger
+ * @param payer - Payer of the transaction.
+ * @param offramp - Address of the OffRamp contract.
+ * @param execReport - Execution report.
+ * @param opts - Options for txs to be generated
+ *   - forceBuffer - Sends report in chunks for buffering in offRamp before execution
+ *   - forceLookupTable - Creates lookup table for execution transaction, and deactivates in the end
+ *   - clearLeftoverAccounts - Resets buffer before filling it in
+ * @returns Transaction hash of the execution.
+ */
+export async function generateUnsignedExecuteReport(
+  ctx: { connection: Connection } & WithLogger,
+  payer: PublicKey,
+  offramp: PublicKey,
   execReport: ExecutionReport<CCIPMessage_V1_6_Solana>,
-  computeUnitsOverride: number | undefined,
   opts?: { forceLookupTable?: boolean; forceBuffer?: boolean; clearLeftoverAccounts?: boolean },
-): Promise<ExecStepTx[]> {
-  const provider = offrampProgram.provider as AnchorProvider
-  offrampProgram = new Program(CCIP_OFFRAMP_IDL, offrampProgram.programId, provider)
-  const payerAddress = provider.wallet.publicKey
+): Promise<UnsignedSolanaTx> {
+  const { connection, logger = console } = ctx
+  const program = new Program(CCIP_OFFRAMP_IDL, offramp, ctx)
 
   let bufferId
   if (opts?.forceBuffer) {
@@ -127,15 +60,16 @@ async function buildExecTxToSolana(
     accounts,
     addressLookupTables,
   } = await getManuallyExecuteInputs({
+    payer,
+    offramp: program,
     execReport,
-    offrampProgram,
-    transmitter: payerAddress.toBase58(),
     bufferId,
+    logger,
   })
 
   const addressLookupTableAccounts = await Promise.all(
     addressLookupTables.map(async (acc) => {
-      const lookupTableAccountInfo = await provider.connection.getAddressLookupTable(acc)
+      const lookupTableAccountInfo = await connection.getAddressLookupTable(acc)
 
       if (!lookupTableAccountInfo.value) {
         throw new Error(`Lookup table account not found: ${acc.toBase58()}`)
@@ -145,35 +79,30 @@ async function buildExecTxToSolana(
     }),
   )
 
-  let serializedReport = offrampProgram.coder.types.encode(
-    'ExecutionReportSingleChain',
-    preparedReport,
-  )
-
-  const { blockhash: recentBlockhash } = await provider.connection.getLatestBlockhash()
+  let serializedReport = program.coder.types.encode('ExecutionReportSingleChain', preparedReport)
 
   let alt
   if (opts?.forceLookupTable) {
-    alt = await buildLookupTableTxs(provider, accounts)
-    addressLookupTableAccounts.push(alt.addressLookupTableAccount)
+    alt = await buildLookupTableIxs(
+      ctx,
+      payer,
+      accounts.map((acc) => acc.pubkey),
+    )
+    addressLookupTableAccounts.push(alt.lookupTable)
   }
 
-  const transactions: ExecStepTx[] = []
+  const instructions: TransactionInstruction[] = []
   if (bufferId) {
-    console.log(`Execute report will be pre-buffered through the offramp. This may take some time.`)
-    transactions.push(
-      ...(await bufferedTransactionData(
-        offrampProgram,
-        serializedReport,
-        recentBlockhash,
-        bufferId,
-        opts,
-      )),
-    )
+    logger.info(`Execute report will be pre-buffered through the offramp. This may take some time.`)
+    const bufferingIxs = await bufferedTransactionData(payer, program, serializedReport, bufferId, {
+      logger,
+      ...opts,
+    })
+    instructions.push(...bufferingIxs)
     serializedReport = Buffer.from([]) // clear 1st param to manuallyExecute method if buffered
   }
 
-  const execTx = await offrampProgram.methods
+  const execIx = await program.methods
     .manuallyExecute(serializedReport, tokenIndexes)
     .accounts({
       config: accounts[0].pubkey,
@@ -190,61 +119,40 @@ async function buildExecTxToSolana(
       rmnRemoteConfig: accounts[11].pubkey,
     })
     .remainingAccounts(accounts.slice(12))
-    .transaction()
-
-  computeUnitsOverride ||= Math.ceil(
-    1.1 *
-      ((
-        await simulateTransaction({
-          instructions: execTx.instructions,
-          connection: provider.connection,
-          payerKey: provider.wallet.publicKey,
-          addressLookupTableAccounts,
-          computeUnitsOverride,
-        })
-      ).unitsConsumed || 0),
-  )
-
-  // Add compute budget instruction at the beginning of instructions
-  execTx.instructions.unshift(
-    ComputeBudgetProgram.setComputeUnitLimit({
-      units: computeUnitsOverride,
-    }),
-  )
+    .instruction()
 
   // actual exec tx
-  transactions.push([
-    'exec',
-    toVersionedTransaction(
-      execTx.instructions,
-      provider.wallet.publicKey,
-      recentBlockhash,
-      addressLookupTableAccounts,
-    ),
-  ])
+  let execIndex = instructions.length
+  instructions.push(execIx)
 
+  // "sandwich" instructions with ALT create+extend, then deactivate
   if (alt) {
-    transactions.unshift(...alt.initialTxs)
-    transactions.push(...alt.finalTxs)
+    instructions.unshift(...alt.initialIxs)
+    execIndex += alt.initialIxs.length
+    instructions.push(...alt.finalIxs)
   }
 
-  return transactions
+  return {
+    family: ChainFamily.Solana,
+    instructions,
+    lookupTables: addressLookupTableAccounts,
+    mainIndex: execIndex,
+  }
 }
 
-async function buildLookupTableTxs(
-  provider: AnchorProvider,
-  accounts: readonly AccountMeta[],
+async function buildLookupTableIxs(
+  { connection, logger = console }: { connection: Connection } & WithLogger,
+  authority: PublicKey,
+  addresses: PublicKey[],
 ): Promise<ExecAlt> {
-  const recentSlot = await provider.connection.getSlot('finalized')
+  const recentSlot = await connection.getSlot('confirmed')
 
   const [createIx, altAddr] = AddressLookupTableProgram.createLookupTable({
-    authority: provider.wallet.publicKey,
-    payer: provider.wallet.publicKey,
+    authority,
+    payer: authority,
     recentSlot,
   })
-  console.log('Using Address Lookup Table', altAddr.toBase58())
-
-  const addresses = accounts.map((a) => a.pubkey)
+  logger.info('Using Address Lookup Table', altAddr.toBase58())
 
   if (addresses.length > 256) {
     throw new Error(
@@ -257,7 +165,6 @@ async function buildLookupTableTxs(
   const firstChunkLength = 28
   const maxAddressesPerTx = 35
   const extendIxs: TransactionInstruction[] = []
-  const ranges: [number, number][] = []
   for (
     let [start, end] = [0, firstChunkLength];
     start < addresses.length;
@@ -265,18 +172,17 @@ async function buildLookupTableTxs(
   ) {
     const addressesChunk = addresses.slice(start, end)
     const extendIx = AddressLookupTableProgram.extendLookupTable({
-      payer: provider.wallet.publicKey,
-      authority: provider.wallet.publicKey,
+      authority,
+      payer: authority,
       lookupTable: altAddr,
       addresses: addressesChunk,
     })
     extendIxs.push(extendIx)
-    ranges.push([start, start + addressesChunk.length - 1])
   }
 
   const deactivateIx = AddressLookupTableProgram.deactivateLookupTable({
     lookupTable: altAddr,
-    authority: provider.wallet.publicKey,
+    authority,
   })
 
   // disable closeTx, to be cleaned in SolanaChain.cleanUpBuffers
@@ -286,87 +192,59 @@ async function buildLookupTableTxs(
   //   lookupTable: altAddr,
   // })
 
-  const { blockhash: recentBlockhash } = await provider.connection.getLatestBlockhash()
-
   return {
-    addressLookupTableAccount: new AddressLookupTableAccount({
+    lookupTable: new AddressLookupTableAccount({
       key: altAddr,
       state: {
-        deactivationSlot: BigInt(0),
+        deactivationSlot: 2n ** 64n - 1n,
         lastExtendedSlot: recentSlot,
         lastExtendedSlotStartIndex: 0,
         addresses,
       },
     }),
-    initialTxs: [
-      // first extendIx fits in create tx
-      [
-        `lookup[create + 0..${ranges[0][1]}]`,
-        toVersionedTransaction(
-          [createIx, extendIxs[0]],
-          provider.wallet.publicKey,
-          recentBlockhash,
-        ),
-      ],
-      ...extendIxs
-        .slice(1)
-        .map<ExecStepTx>((ix, i) => [
-          `lookup[${ranges[i + 1][0]}..${ranges[i + 1][1]}]`,
-          toVersionedTransaction([ix], provider.wallet.publicKey, recentBlockhash),
-        ]),
-    ],
-    finalTxs: [
-      [
-        `lookup[deactivate]`,
-        toVersionedTransaction([deactivateIx], provider.wallet.publicKey, recentBlockhash),
-      ],
-    ],
+    initialIxs: [createIx, ...extendIxs],
+    finalIxs: [deactivateIx],
   }
 }
 
 async function bufferedTransactionData(
-  offrampProgram: Program<typeof CCIP_OFFRAMP_IDL>,
+  payer: PublicKey,
+  offramp: Program<typeof CCIP_OFFRAMP_IDL>,
   serializedReport: Buffer,
-  recentBlockhash: string,
   bufferId: Buffer,
-  opts?: { clearLeftoverAccounts?: boolean },
-): Promise<ExecStepTx[]> {
-  const provider = offrampProgram.provider as AnchorProvider
-
+  {
+    logger = console,
+    clearLeftoverAccounts,
+  }: { clearLeftoverAccounts?: boolean } & WithLogger = {},
+): Promise<TransactionInstruction[]> {
   const [bufferAddress] = PublicKey.findProgramAddressSync(
-    [Buffer.from('execution_report_buffer'), bufferId, provider.wallet.publicKey.toBuffer()],
-    offrampProgram.programId,
+    [Buffer.from('execution_report_buffer'), bufferId, payer.toBuffer()],
+    offramp.programId,
   )
 
-  const [configPDA] = PublicKey.findProgramAddressSync(
-    [Buffer.from('config')],
-    offrampProgram.programId,
-  )
+  const [configPDA] = PublicKey.findProgramAddressSync([Buffer.from('config')], offramp.programId)
 
-  console.log(
+  logger.info(
     `The bufferID is ${hexlify(bufferId)}, and the PDA address for the buffer is ${bufferAddress.toString()}\nIf this buffering process is aborted, remember to cleanUp the account to recover locked rent.`,
   )
 
   const chunkSize = 800
-  const bufferedExecTxs: ExecStepTx[] = []
+  const bufferedExecIxs: TransactionInstruction[] = []
 
   const bufferingAccounts = {
     executionReportBuffer: bufferAddress,
     config: configPDA,
-    authority: provider.wallet.publicKey,
+    authority: payer,
     systemProgram: SystemProgram.programId,
   }
 
-  if (opts?.clearLeftoverAccounts) {
-    const clearTx = await offrampProgram.methods
-      .closeExecutionReportBuffer(bufferId)
-      .accounts(bufferingAccounts)
-      .transaction()
-
-    bufferedExecTxs.push([
-      'buffering[clear]',
-      toVersionedTransaction(clearTx, provider.wallet.publicKey, recentBlockhash),
-    ])
+  if (clearLeftoverAccounts) {
+    bufferedExecIxs.push(
+      await offramp.methods
+        .closeExecutionReportBuffer(bufferId)
+        .accounts(bufferingAccounts)
+        .instruction(),
+    )
   }
 
   const numChunks = Math.ceil(serializedReport.length / chunkSize)
@@ -374,42 +252,29 @@ async function bufferedTransactionData(
     const end = Math.min(i + chunkSize, serializedReport.length)
     const chunk: Buffer = serializedReport.subarray(i, end)
 
-    const appendTx = await offrampProgram.methods
-      .bufferExecutionReport(bufferId, serializedReport.length, chunk, i / chunkSize, numChunks)
-      .accounts(bufferingAccounts)
-      .transaction()
-    bufferedExecTxs.push([
-      `buffering[${i / chunkSize}=${end - i}B]`,
-      toVersionedTransaction(appendTx, provider.wallet.publicKey, recentBlockhash),
-    ])
+    bufferedExecIxs.push(
+      await offramp.methods
+        .bufferExecutionReport(bufferId, serializedReport.length, chunk, i / chunkSize, numChunks)
+        .accounts(bufferingAccounts)
+        .instruction(),
+    )
   }
 
-  return bufferedExecTxs
-}
-
-function toVersionedTransaction(
-  input: Transaction | TransactionInstruction[],
-  payerKey: PublicKey,
-  recentBlockhash: string,
-  addressLookupTableAccounts?: AddressLookupTableAccount[],
-): VersionedTransaction {
-  const instructions: TransactionInstruction[] = Array.isArray(input) ? input : input.instructions
-
-  const message = new TransactionMessage({ payerKey, recentBlockhash, instructions })
-  return new VersionedTransaction(message.compileToV0Message(addressLookupTableAccounts))
+  return bufferedExecIxs
 }
 
 async function getManuallyExecuteInputs({
+  payer,
+  offramp,
   execReport,
-  offrampProgram,
-  transmitter,
   bufferId,
+  ...ctx
 }: {
+  payer: PublicKey
+  offramp: Program<typeof CCIP_OFFRAMP_IDL>
   execReport: ExecutionReport<CCIPMessage_V1_6_Solana>
-  offrampProgram: Program<typeof CCIP_OFFRAMP_IDL>
-  transmitter: string
   bufferId?: Buffer
-}) {
+} & WithLogger) {
   const executionReport = prepareExecutionReport(execReport)
 
   const messageAccountMetas = execReport.message.accounts.map((acc, index) => {
@@ -430,8 +295,6 @@ async function getManuallyExecuteInputs({
     isWritable: false,
   }
 
-  console.debug('Message receiver:', execReport.message.receiver)
-
   // Prepend receiver to messaging accounts
   const messagingAccounts: AccountMeta[] =
     execReport.message.receiver !== PublicKey.default.toBase58()
@@ -457,15 +320,16 @@ async function getManuallyExecuteInputs({
     addressLookupTableAccounts: addressLookupTables,
     tokenIndexes,
   } = await autoDeriveExecutionAccounts({
-    offrampProgram,
+    offramp,
     originalSender: bytesToBuffer(execReport.message.sender),
-    transmitter: new PublicKey(transmitter),
+    payer,
     messagingAccounts,
     sourceChainSelector: execReport.message.header.sourceChainSelector,
     tokenTransferAndOffchainData,
     merkleRoot: bytesToBuffer(execReport.merkleRoot),
     bufferId,
     tokenReceiver: new PublicKey(execReport.message.tokenReceiver),
+    ...ctx,
   })
 
   return {
@@ -518,19 +382,20 @@ function prepareExecutionReport({
 }
 
 async function autoDeriveExecutionAccounts({
-  offrampProgram,
+  offramp,
   originalSender,
-  transmitter,
+  payer,
   messagingAccounts,
   sourceChainSelector,
   tokenTransferAndOffchainData,
   merkleRoot,
   tokenReceiver,
   bufferId,
+  logger = console,
 }: {
-  offrampProgram: Program<typeof CCIP_OFFRAMP_IDL>
+  offramp: Program<typeof CCIP_OFFRAMP_IDL>
   originalSender: Buffer
-  transmitter: PublicKey
+  payer: PublicKey
   messagingAccounts: IdlTypes<typeof CCIP_OFFRAMP_IDL>['CcipAccountMeta'][]
   sourceChainSelector: bigint
   tokenTransferAndOffchainData: Array<
@@ -539,7 +404,7 @@ async function autoDeriveExecutionAccounts({
   merkleRoot: Buffer
   tokenReceiver: PublicKey
   bufferId?: Buffer
-}) {
+} & WithLogger) {
   const derivedAccounts: AccountMeta[] = []
   const lookupTables: PublicKey[] = []
   const tokenIndices: number[] = []
@@ -547,14 +412,11 @@ async function autoDeriveExecutionAccounts({
   let stage = 'Start'
   let tokenIndex = 0
 
-  const [configPDA] = PublicKey.findProgramAddressSync(
-    [Buffer.from('config')],
-    offrampProgram.programId,
-  )
+  const [configPDA] = PublicKey.findProgramAddressSync([Buffer.from('config')], offramp.programId)
 
   while (true) {
     const params: IdlTypes<typeof CCIP_OFFRAMP_IDL>['DeriveAccountsExecuteParams'] = {
-      executeCaller: transmitter,
+      executeCaller: payer,
       messageAccounts: messagingAccounts,
       sourceChainSelector: new BN(sourceChainSelector.toString()),
       originalSender: originalSender,
@@ -574,14 +436,8 @@ async function autoDeriveExecutionAccounts({
       }))
     }
 
-    // copy of Program which avoids signing every simulation
-    const readOnlyProgram = new Program(
-      offrampProgram.idl,
-      offrampProgram.programId,
-      simulationProvider(offrampProgram.provider.connection, transmitter),
-    )
     // Execute as a view call to get the response
-    const response = (await readOnlyProgram.methods
+    const response = (await offramp.methods
       .deriveAccountsExecute(params, stage)
       .accounts({
         config: configPDA,
@@ -589,8 +445,8 @@ async function autoDeriveExecutionAccounts({
       .remainingAccounts(askWith)
       .view()
       .catch((error: unknown) => {
-        console.error('Error deriving accounts:', error)
-        console.error('Params:', params)
+        logger.error('Error deriving accounts:', error)
+        logger.error('Params:', params)
         throw error as Error
       })) as IdlTypes<typeof CCIP_OFFRAMP_IDL>['DeriveAccountsResponse']
 
@@ -604,7 +460,7 @@ async function autoDeriveExecutionAccounts({
     // Update token index
     tokenIndex += response.accountsToSave.length
 
-    console.debug('After stage', stage, 'tokenIndices', tokenIndices, 'nextTokenIndex', tokenIndex)
+    logger.debug('After stage', stage, 'tokenIndices', tokenIndices, 'nextTokenIndex', tokenIndex)
 
     // Collect the derived accounts
     for (const meta of response.accountsToSave) {
@@ -633,9 +489,9 @@ async function autoDeriveExecutionAccounts({
     stage = response.nextStage
   }
 
-  console.debug('Resulting derived accounts:', derivedAccounts)
-  console.debug('Resulting derived address lookup tables:', lookupTables)
-  console.debug('Resulting derived token indexes:', tokenIndices)
+  logger.debug('Resulting derived accounts:', derivedAccounts)
+  logger.debug('Resulting derived address lookup tables:', lookupTables)
+  logger.debug('Resulting derived token indexes:', tokenIndices)
 
   return {
     accounts: derivedAccounts,

package/src/solana/hasher.ts

@@ -10,10 +10,11 @@ import {
   toUtf8Bytes,
   zeroPadValue,
 } from 'ethers'
+import type { ReadonlyDeep } from 'type-fest'
 
 import { decodeExtraArgs } from '../extra-args.ts'
 import type { LeafHasher } from '../hasher/index.ts'
-import { type CCIPMessage, type DeepReadonly, type Lane, CCIPVersion } from '../types.ts'
+import { type CCIPMessage, type Lane, type WithLogger, CCIPVersion } from '../types.ts'
 import { getAddressBytes, getDataBytes, networkInfo, toLeArray } from '../utils.ts'
 
 const SvmExtraArgsSchema = {
@@ -37,11 +38,19 @@ const SvmTokenAmountsSchema = {
   },
 } as const
 
-export function getV16SolanaLeafHasher(lane: Lane): LeafHasher<typeof CCIPVersion.V1_6> {
+/**
+ * Creates a leaf hasher for Solana v1.6 CCIP messages.
+ * @param lane - Lane configuration.
+ * @returns Leaf hasher function for Solana messages.
+ */
+export function getV16SolanaLeafHasher(
+  lane: Lane,
+  { logger = console }: WithLogger = {},
+): LeafHasher<typeof CCIPVersion.V1_6> {
   if (lane.version !== CCIPVersion.V1_6)
     throw new Error(`Unsupported lane version: ${lane.version}`)
 
-  return (message: DeepReadonly<CCIPMessage<typeof CCIPVersion.V1_6>>): string => {
+  return (message: ReadonlyDeep<CCIPMessage<typeof CCIPVersion.V1_6>>): string => {
     let parsedArgs
     if ('accountIsWritableBitmap' in message) {
       parsedArgs = {
@@ -95,7 +104,7 @@ export function getV16SolanaLeafHasher(lane: Lane): LeafHasher<typeof CCIPVersio
       ...[receiver].filter((a) => hexlify(a) !== ZeroHash),
       ...parsedArgs.accounts.map((a) => zeroPadValue(bs58.decode(a), 32)),
     ]
-    console.debug(
+    logger.debug(
       'v1.6 solana leafHasher',
       packedValues.map((o) => (o instanceof Uint8Array ? `[${o.length}]:${hexlify(o)}` : o)),
     )