@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/hasher/hasher.ts

@@ -1,12 +1,20 @@
 import { supportedChains } from '../supported-chains.ts'
-import type { CCIPVersion, Lane } from '../types.ts'
+import type { CCIPVersion, Lane, WithLogger } from '../types.ts'
 import { networkInfo } from '../utils.ts'
 import type { LeafHasher } from './common.ts'
 
-// Factory function that returns the right encoder based on the version of the lane
-export function getLeafHasher<V extends CCIPVersion = CCIPVersion>(lane: Lane<V>): LeafHasher<V> {
+/**
+ * Factory function that returns the right encoder based on the version of the lane.
+ * @param lane - Lane configuration.
+ * @param ctx - Context object containing logger.
+ * @returns Leaf hasher function for the destination chain.
+ */
+export function getLeafHasher<V extends CCIPVersion = CCIPVersion>(
+  lane: Lane<V>,
+  ctx?: WithLogger,
+): LeafHasher<V> {
   const destFamily = networkInfo(lane.destChainSelector).family
   const chain = supportedChains[destFamily]
   if (!chain) throw new Error(`Unsupported chain family: ${destFamily}`)
-  return chain.getDestLeafHasher(lane) as LeafHasher<V>
+  return chain.getDestLeafHasher(lane, ctx) as LeafHasher<V>
 }

package/src/hasher/merklemulti.ts

@@ -13,12 +13,16 @@ interface SingleLayerProof {
 
 /**
  * Proof represents a proof data structure with hashes and source flags.
- * @template Hash The hash type.
  */
 export class Proof {
   hashes: Hash[] = []
   sourceFlags: boolean[] = []
 
+  /**
+   * Creates a new Proof instance.
+   * @param hashes - Proof hashes.
+   * @param sourceFlags - Source flags indicating leaf vs internal nodes.
+   */
   constructor(hashes: Hash[] = [], sourceFlags: boolean[] = []) {
     this.hashes = hashes
     this.sourceFlags = sourceFlags
@@ -26,7 +30,7 @@ export class Proof {
 
   /**
    * Counts the number of source flags that match the given boolean value.
-   * @param b The boolean value to count.
+   * @param b - The boolean value to count.
    * @returns The count of source flags matching the provided boolean value.
    */
   countSourceFlags(b: boolean): number {
@@ -41,9 +45,8 @@ export class Proof {
  * It processes the `layer` to generate the next layer of hash values, pairing adjacent values
  * and applying the hashing function provided by the context.
  *
- * @template Hash - Generic type parameter representing the hash type.
- * @param {Hash[]} layer - An array of hash values representing the current layer of the binary tree.
- * @returns {[Hash[], Hash[]]} A tuple containing two arrays:
+ * @param layer - An array of hash values representing the current layer of the binary tree.
+ * @returns A tuple containing two arrays:
  *   - The first array contains the original input layer.
  *   - The second array contains the next layer of hash values generated by combining pairs of hashes.
  */
@@ -65,7 +68,7 @@ function computeNextLayer(layer: Hash[]): readonly [Hash[], Hash[]] {
 
 /**
  * Calculates the parent index of a given index in a binary tree.
- * @param idx The index for which to calculate the parent index.
+ * @param idx - The index for which to calculate the parent index.
  * @returns The parent index.
  */
 function parentIndex(idx: number): number {
@@ -74,7 +77,7 @@ function parentIndex(idx: number): number {
 
 /**
  * Calculates the sibling index of a given index in a binary tree.
- * @param idx The index for which to calculate the sibling index.
+ * @param idx - The index for which to calculate the sibling index.
  * @returns The sibling index.
  */
 function siblingIndex(idx: number): number {
@@ -83,8 +86,8 @@ function siblingIndex(idx: number): number {
 
 /**
  * Generates a single-layer Merkle proof for a given set of indices within a layer.
- * @param layer The layer of data for which to generate the proof.
- * @param indices The indices within the layer for which to generate the proof.
+ * @param layer - The layer of data for which to generate the proof.
+ * @param indices - The indices within the layer for which to generate the proof.
  * @returns A single-layer proof object containing nextIndices, subProof, and sourceFlags.
  */
 function proveSingleLayer(layer: Hash[], indices: number[]): SingleLayerProof {
@@ -131,14 +134,13 @@ function proveSingleLayer(layer: Hash[], indices: number[]): SingleLayerProof {
 
 /**
  * Represents a Merkle Tree data structure.
- * @typeparam Hash The type of hash used in the tree.
  */
 export class Tree {
   layers: Hash[][]
 
   /**
    * Creates a new Merkle Tree using the provided context and leaf hashes.
-   * @param leafHashes An array of leaf hashes to construct the tree.
+   * @param leafHashes - An array of leaf hashes to construct the tree.
    * @returns A new Merkle Tree instance.
    * @throws Error if there are no leaf hashes provided.
    */
@@ -177,7 +179,7 @@ export class Tree {
 
   /**
    * Generates a Merkle proof for a set of indices in the tree.
-   * @param indices The indices for which to generate the proof.
+   * @param indices - The indices for which to generate the proof.
    * @returns A proof object containing hashes and source flags.
    */
   prove(indices: number[]): Proof {
@@ -197,7 +199,7 @@ export class Tree {
 
 /**
  * Converts an array of boolean proof flags to a BigNumber where each flag represents a bit.
- * @param proofFlags An array of boolean proof flags.
+ * @param proofFlags - An array of boolean proof flags.
  * @returns A BigNumber representing the encoded flags.
  */
 export function proofFlagsToBits(proofFlags: boolean[]): bigint {
@@ -216,9 +218,8 @@ export function proofFlagsToBits(proofFlags: boolean[]): bigint {
 
 /**
  * Verifies and computes the Merkle root hash based on provided leaf hashes and a Merkle proof.
- * @param ctx The Merkle context.
- * @param leafHashes An array of leaf hashes.
- * @param proof The Merkle proof containing hashes and source flags.
+ * @param leafHashes - An array of leaf hashes.
+ * @param proof - The Merkle proof containing hashes and source flags.
  * @returns The computed Merkle root hash.
  */
 export function verifyComputeRoot(leafHashes: Hash[], proof: Proof): Hash {

package/src/index.ts

@@ -1,16 +1,12 @@
-export { AptosChain } from './aptos/index.ts'
-export {
-  type Chain,
-  type ChainGetter,
-  type ChainStatic,
-  type ChainTransaction,
-  type LogFilter,
-  type RateLimiterState,
-  type TokenInfo,
-  type TokenPoolRemote,
-  ChainFamily,
+export type {
+  Chain,
+  ChainGetter,
+  ChainStatic,
+  LogFilter,
+  RateLimiterState,
+  TokenInfo,
+  TokenPoolRemote,
 } from './chain.ts'
-export { EVMChain } from './evm/index.ts'
 export { calculateManualExecProof, discoverOffRamp } from './execution.ts'
 export {
   type EVMExtraArgsV1,
@@ -22,30 +18,40 @@ export {
   encodeExtraArgs,
 } from './extra-args.ts'
 export { estimateExecGasForRequest } from './gas.ts'
-export {
-  decodeMessage,
-  fetchAllMessagesInBatch,
-  fetchCCIPMessageById,
-  fetchCCIPRequestsInTx,
-  fetchRequestsForSender,
-  sourceToDestTokenAmounts,
-} from './requests.ts'
-export { SolanaChain } from './solana/index.ts'
-export { SuiChain } from './sui/index.ts'
-export { supportedChains } from './supported-chains.ts'
+export { decodeMessage, fetchRequestsForSender, sourceToDestTokenAmounts } from './requests.ts'
 export {
   type AnyMessage,
   type CCIPCommit,
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
+  type ChainTransaction,
   type CommitReport,
   type ExecutionReceipt,
   type ExecutionReport,
   type Lane,
+  type Logger,
   type NetworkInfo,
   type OffchainTokenData,
+  type WithLogger,
   CCIPVersion,
   ExecutionState,
 } from './types.ts'
 export { bigIntReplacer, bigIntReviver, decodeAddress, getDataBytes, networkInfo } from './utils.ts'
+
+// chains
+import { AptosChain } from './aptos/index.ts'
+import { EVMChain } from './evm/index.ts'
+import { SolanaChain } from './solana/index.ts'
+import { SuiChain } from './sui/index.ts'
+import { ChainFamily } from './types.ts'
+export { AptosChain, ChainFamily, EVMChain, SolanaChain, SuiChain }
+// 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,
+}

package/src/requests.ts

@@ -1,20 +1,20 @@
-import util from 'util'
-
 import { isBytesLike, toBigInt } from 'ethers'
+import type { PickDeep } from 'type-fest'
 import yaml from 'yaml'
 
-import {
-  type Chain,
-  type ChainStatic,
-  type ChainTransaction,
-  type LogFilter,
-  ChainFamily,
-} from './chain.ts'
+import type { Chain, ChainStatic, LogFilter } from './chain.ts'
 import type { EVMChain } from './evm/index.ts'
 import { decodeExtraArgs } from './extra-args.ts'
 import { supportedChains } from './supported-chains.ts'
-import type { CCIPMessage, CCIPRequest, CCIPVersion, Log_ } from './types.ts'
-import { convertKeysToCamelCase, decodeAddress, leToBigInt, networkInfo } from './utils.ts'
+import {
+  type CCIPMessage,
+  type CCIPRequest,
+  type CCIPVersion,
+  type ChainTransaction,
+  type Log_,
+  ChainFamily,
+} from './types.ts'
+import { convertKeysToCamelCase, decodeAddress, leToBigInt, networkInfo, util } from './utils.ts'
 
 function decodeJsonMessage(data: Record<string, unknown>) {
   if (!data || typeof data != 'object') throw new Error(`invalid msg: ${util.inspect(data)}`)
@@ -113,13 +113,15 @@ export function decodeMessage(data: string | Uint8Array | Record<string, unknown
 
 /**
  * Fetch all CCIP messages in a transaction
- * @param tx - TransactionReceipt to search in
- * @returns CCIP messages in the transaction (at least one)
+ * @param source - Chain
+ * @param tx - ChainTransaction to search in
+ * @returns CCIP requests (messages) in the transaction (at least one)
  **/
-export async function fetchCCIPRequestsInTx(tx: ChainTransaction): Promise<CCIPRequest[]> {
-  const source = tx.chain
+export async function fetchCCIPRequestsInTx(
+  source: Chain,
+  tx: ChainTransaction,
+): Promise<CCIPRequest[]> {
   const txHash = tx.hash
-  const timestamp = tx.timestamp
 
   const requests: CCIPRequest[] = []
   for (const log of tx.logs) {
@@ -139,7 +141,7 @@ export async function fetchCCIPRequestsInTx(tx: ChainTransaction): Promise<CCIPR
     } else {
       lane = await (source as EVMChain).getLaneForOnRamp(log.address)
     }
-    requests.push({ lane, message, log, tx, timestamp })
+    requests.push({ lane, message, log, tx })
   }
   if (!requests.length) {
     throw new Error(`Could not find any CCIPSendRequested message in tx: ${txHash}`)
@@ -149,23 +151,21 @@ export async function fetchCCIPRequestsInTx(tx: ChainTransaction): Promise<CCIPR
 }
 
 /**
- * Fetch a CCIP message by its messageId
- * Can be slow due to having to paginate backwards through logs
- *
- * @param source - Provider to fetch logs from
- * @param messageId - messageId to search for
- * @param hints - Optional hints for pagination
- * @returns CCIPRequest with given messageId
- **/
-export async function fetchCCIPMessageById(
+ * Fetch a CCIP message by its messageId.
+ * Can be slow due to having to paginate backwards through logs.
+ * @param source - Provider to fetch logs from.
+ * @param messageId - MessageId to search for.
+ * @param hints - Optional hints for pagination (e.g., `address` for onRamp, `page` for pagination size).
+ * @returns CCIPRequest with given messageId.
+ */
+export async function fetchCCIPRequestById(
   source: Chain,
   messageId: string,
-  hints?: { page?: number; onRamp?: string },
+  hints?: { page?: number; address?: string },
 ): Promise<CCIPRequest> {
   for await (const log of source.getLogs({
-    ...hints,
-    ...(hints?.onRamp ? { address: hints.onRamp } : {}),
     topics: ['CCIPSendRequested', 'CCIPMessageSent'],
+    ...hints,
   })) {
     const message = (source.constructor as ChainStatic).decodeMessage(log)
     if (message?.header.messageId !== messageId) continue
@@ -173,12 +173,10 @@ export async function fetchCCIPMessageById(
     if ('destChainSelector' in message.header) {
       destChainSelector = message.header.destChainSelector
       ;[, version] = await source.typeAndVersion(log.address)
-    } else if (source.network.family !== ChainFamily.EVM) {
-      throw new Error(`Unsupported network family: ${source.network.family}`)
     } else {
       ;({ destChainSelector, version } = await (source as EVMChain).getLaneForOnRamp(log.address))
     }
-    const tx = await source.getTransaction(log.transactionHash)
+    const tx = log.tx ?? (await source.getTransaction(log.transactionHash))
     return {
       lane: {
         sourceChainSelector: source.network.chainSelector,
@@ -189,7 +187,6 @@ export async function fetchCCIPMessageById(
       message,
       log,
       tx,
-      timestamp: tx.timestamp,
     }
   }
   throw new Error('Could not find a CCIPSendRequested message with messageId: ' + messageId)
@@ -198,19 +195,33 @@ export async function fetchCCIPMessageById(
 // Number of blocks to expand the search window for logs
 const BLOCK_LOG_WINDOW_SIZE = 5000
 
-// Helper function to find the sequence number from CCIPSendRequested event logs
-export async function fetchAllMessagesInBatch<R extends Omit<CCIPRequest, 'tx' | 'timestamp'>>(
-  source: Chain,
+/**
+ * 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 opts - Optional log filtering parameters.
+ * @returns Array of messages in the batch.
+ */
+export async function fetchAllMessagesInBatch<
+  C extends Chain,
+  R extends PickDeep<
+    CCIPRequest,
+    'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.header.sequenceNumber'
+  >,
+>(
+  source: C,
   request: R,
   { minSeqNr, maxSeqNr }: { minSeqNr: bigint; maxSeqNr: bigint },
-  { page: eventsBatchSize = BLOCK_LOG_WINDOW_SIZE }: { page?: number } = {},
+  opts: Parameters<C['getLogs']>[0] = { page: BLOCK_LOG_WINDOW_SIZE },
 ): Promise<R['message'][]> {
   if (minSeqNr === maxSeqNr) return [request.message]
 
-  const filter: LogFilter = {
-    page: eventsBatchSize,
+  const filter = {
+    page: BLOCK_LOG_WINDOW_SIZE,
     topics: [request.log.topics[0]],
     address: request.log.address,
+    ...opts,
   }
   if (request.message.header.sequenceNumber === maxSeqNr) filter.endBlock = request.log.blockNumber
   else
@@ -219,7 +230,7 @@ export async function fetchAllMessagesInBatch<R extends Omit<CCIPRequest, 'tx' |
       request.log.blockNumber -
       Math.ceil(
         (Number(request.message.header.sequenceNumber - minSeqNr) / Number(maxSeqNr - minSeqNr)) *
-          eventsBatchSize,
+          filter.page,
       )
 
   const messages: R['message'][] = []
@@ -270,6 +281,13 @@ export async function fetchAllMessagesInBatch<R extends Omit<CCIPRequest, 'tx' |
   return messages
 }
 
+/**
+ * Fetches CCIP requests originated by a specific sender.
+ * @param source - Source chain instance.
+ * @param sender - Sender address.
+ * @param filter - Log filter options.
+ * @returns Async generator of CCIP requests.
+ */
 export async function* fetchRequestsForSender(
   source: Chain,
   sender: string,
@@ -306,12 +324,12 @@ export async function* fetchRequestsForSender(
 }
 
 /**
- * Map source `token` to `sourcePoolAddress + destTokenAddress`
- * @param source - source chain
- * @param destChainSelector - dest network
- * @param onRamp - contract address
- * @param sourceTokenAmounts - usually `{ token, amount }`
- * @returns - { sourcePoolAddress, destTokenAddress, ...rest } objects
+ * Map source `token` to `sourcePoolAddress + destTokenAddress`.
+ * @param source - Source chain.
+ * @param destChainSelector - Destination network selector.
+ * @param onRamp - Contract address.
+ * @param sourceTokenAmounts - Array of token amounts, usually containing `token` and `amount` properties.
+ * @returns Array of objects with `sourcePoolAddress`, `destTokenAddress`, and remaining properties.
  */
 export async function sourceToDestTokenAmounts<S extends { token: string }>(
   source: Chain,

package/src/selectors.ts

@@ -1,4 +1,4 @@
-import type { ChainFamily } from './chain.ts'
+import type { ChainFamily } from './types.ts'
 
 type Selectors = Record<
   string,

package/src/solana/cleanup.ts

@@ -1,37 +1,46 @@
-import { type AnchorProvider, Program } from '@coral-xyz/anchor'
-import { AddressLookupTableProgram, PublicKey, SystemProgram } from '@solana/web3.js'
+import { Buffer } from 'buffer'
+
+import { type Wallet as AnchorWallet, AnchorProvider, Program } from '@coral-xyz/anchor'
+import {
+  type Connection,
+  AddressLookupTableProgram,
+  PublicKey,
+  SystemProgram,
+} from '@solana/web3.js'
 import { dataSlice, hexlify } from 'ethers'
-import moize from 'moize'
+import { memoize } from 'micro-memoize'
 
 import { sleep } from '../utils.ts'
 import { IDL as CCIP_OFFRAMP_IDL } from './idl/1.6.0/CCIP_OFFRAMP.ts'
 import type { SolanaChain } from './index.ts'
-import { simulateAndSendTxs } from './send.ts'
+import type { Wallet } from './types.ts'
+import { simulateAndSendTxs } from './utils.ts'
+import type { WithLogger } from '../types.ts'
 
 /**
- * Clean up and recycle buffers and address lookup tables owned by wallet
- * CAUTION: this will close ANY lookup table owned by this wallet
- * @param provider - AnchorProvider with connection and wallet
- * @param getLogs - SolanaChain-compatible getLogs function (to scan for Buffers and ALTs)
- * @param opts.dontWait - Whether to skip waiting for lookup table deactivation cool down period
- *   (513 slots) to pass before closing; by default, we deactivate (if needed) and wait to close
- *   before returning from this method
+ * Clean up and recycle buffers and Address Lookup Tables owned by wallet.
+ * @param ctx - Context object containing the Solana connection instance and logger.
+ * @param wallet - Wallet instance to sign txs.
+ * @param getLogs - SolanaChain-compatible getLogs function (to scan for Buffers and ALTs).
+ * @param opts - Optional parameters. Set `waitDeactivation` to wait for lookup table deactivation
+ *   cool down period (513 slots) to pass before closing; by default, we deactivate (if needed)
+ *   and leave close to be done in the future.
  */
 export async function cleanUpBuffers(
-  provider: AnchorProvider,
+  ctx: { connection: Connection } & WithLogger,
+  wallet: Wallet,
   getLogs: SolanaChain['getLogs'],
-  opts?: { dontWait?: boolean },
+  opts?: { waitDeactivation?: boolean },
 ): Promise<void> {
-  const connection = provider.connection
-  const wallet = provider.wallet
-  console.debug(
+  const { connection, logger = console } = ctx
+  logger.debug(
     'Starting cleaning up buffers and lookup tables for account',
     wallet.publicKey.toString(),
   )
 
   const seenAccs = new Set<string>()
   const pendingPromises = []
-  const getCurrentSlot = moize.default(
+  const getCurrentSlot = memoize(
     async () => {
       let lastErr
       for (let i = 0; i < 10; i++) {
@@ -39,13 +48,13 @@ export async function cleanUpBuffers(
           return await connection.getSlot()
         } catch (err) {
           lastErr = err
-          console.warn('Failed to get current slot', i, err)
+          logger.warn('Failed to get current slot', i, err)
           await sleep(500)
         }
       }
       throw lastErr
     },
-    { maxAge: 1000, isPromise: true },
+    { maxAge: 1000, async: true },
   )
 
   const closeAlt = async (lookupTable: PublicKey, deactivationSlot: number) => {
@@ -54,8 +63,8 @@ export async function cleanUpBuffers(
     while (!sig) {
       const delta = deactivationSlot + 513 - (await getCurrentSlot())
       if (delta > 0) {
-        if (opts?.dontWait) {
-          console.warn(
+        if (!opts?.waitDeactivation) {
+          logger.warn(
             'Skipping: lookup table',
             altAddr,
             'not yet ready for close until',
@@ -64,7 +73,7 @@ export async function cleanUpBuffers(
           )
           return
         }
-        console.debug(
+        logger.debug(
           'Waiting for slot',
           deactivationSlot + 513,
           'to be reached in',
@@ -81,14 +90,14 @@ export async function cleanUpBuffers(
         lookupTable,
       })
       try {
-        sig = await simulateAndSendTxs(connection, wallet, [closeIx])
-        console.info('🗑️  Closed lookup table', altAddr, ': tx =>', sig)
+        sig = await simulateAndSendTxs(ctx, wallet, { instructions: [closeIx] })
+        logger.info('🗑️  Closed lookup table', altAddr, ': tx =>', sig)
       } catch (err) {
         const info = await connection.getAddressLookupTable(lookupTable)
         if (!info?.value) break
         else if (info.value.state.deactivationSlot < 2n ** 63n)
           deactivationSlot = Number(info.value.state.deactivationSlot)
-        console.warn('Failed to close lookup table', altAddr, err)
+        logger.warn('Failed to close lookup table', altAddr, err)
       }
     }
   }
@@ -114,7 +123,11 @@ export async function cleanUpBuffers(
           .map(({ data }) => Buffer.from(data.subarray(8 + 4, 8 + 4 + 32)))
 
         for (const bufferId of bufferIds) {
-          const offrampProgram = new Program(CCIP_OFFRAMP_IDL, new PublicKey(log.address), provider)
+          const offrampProgram = new Program(
+            CCIP_OFFRAMP_IDL,
+            new PublicKey(log.address),
+            new AnchorProvider(connection, wallet as AnchorWallet, { commitment: 'confirmed' }),
+          )
 
           const [executionReportBuffer] = PublicKey.findProgramAddressSync(
             [Buffer.from('execution_report_buffer'), bufferId, wallet.publicKey.toBuffer()],
@@ -125,7 +138,7 @@ export async function cleanUpBuffers(
 
           const accInfo = await connection.getAccountInfo(executionReportBuffer)
           if (!accInfo) {
-            console.debug(
+            logger.debug(
               'Buffer with bufferId',
               hexlify(bufferId),
               'at',
@@ -148,7 +161,7 @@ export async function cleanUpBuffers(
               .closeExecutionReportBuffer(bufferId)
               .accounts(bufferingAccounts)
               .rpc()
-            console.info(
+            logger.info(
               '🗑️  Closed bufferId',
               hexlify(bufferId),
               'at',
@@ -157,7 +170,7 @@ export async function cleanUpBuffers(
               sig,
             )
           } catch (err) {
-            console.warn(
+            logger.warn(
               'Failed to close bufferId',
               hexlify(bufferId),
               'at',
@@ -177,9 +190,9 @@ export async function cleanUpBuffers(
         const info = await connection.getAddressLookupTable(lookupTable)
         if (!info?.value) {
           alreadyClosed++ // assume we're done when we hit Nth closed ALT; maybe add an option to keep going?
-          console.debug('Lookup table', lookupTable.toBase58(), 'already closed')
+          logger.debug('Lookup table', lookupTable.toBase58(), 'already closed')
         } else if (info.value.state.authority?.toBase58() !== wallet.publicKey.toBase58()) {
-          console.debug(
+          logger.debug(
             'Lookup table',
             lookupTable.toBase58(),
             'not owned by us, but by',
@@ -199,11 +212,13 @@ export async function cleanUpBuffers(
           })
 
           try {
-            const sig = await simulateAndSendTxs(connection, wallet, [deactivateIx])
-            console.info('⤵️  Deactivated lookup table', lookupTable.toBase58(), ': tx =>', sig)
+            const sig = await simulateAndSendTxs(ctx, wallet, {
+              instructions: [deactivateIx],
+            })
+            logger.info('⤵️  Deactivated lookup table', lookupTable.toBase58(), ': tx =>', sig)
             pendingPromises.push(closeAlt(lookupTable, await getCurrentSlot()))
           } catch (err) {
-            console.warn('Failed to deactivate lookup table', lookupTable.toBase58(), err)
+            logger.warn('Failed to deactivate lookup table', lookupTable.toBase58(), err)
           }
         }
         break // case