@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/dist/solana/index.js

@@ -1,18 +1,18 @@
-import util from 'util';
-import { AnchorProvider, BorshAccountsCoder, BorshCoder, Program, Wallet, eventDiscriminator, } from '@coral-xyz/anchor';
+import { Buffer } from 'buffer';
+import { BorshAccountsCoder, BorshCoder, Program } from '@coral-xyz/anchor';
 import { NATIVE_MINT } from '@solana/spl-token';
-import { Connection, Keypair, PublicKey, SYSVAR_CLOCK_PUBKEY, SystemProgram, } from '@solana/web3.js';
+import { Connection, PublicKey, SYSVAR_CLOCK_PUBKEY, SystemProgram, } from '@solana/web3.js';
 import bs58 from 'bs58';
-import { concat, dataLength, dataSlice, encodeBase58, encodeBase64, getBytes, hexlify, isHexString, toBigInt, } from 'ethers';
-import moize, {} from 'moize';
-import { Chain, ChainFamily, } from "../chain.js";
+import { concat, dataLength, dataSlice, encodeBase58, encodeBase64, hexlify, isHexString, toBigInt, } from 'ethers';
+import { memoize } from 'micro-memoize';
+import { Chain, } from "../chain.js";
 import { EVMExtraArgsV2Tag } from "../extra-args.js";
 import SELECTORS from "../selectors.js";
 import { supportedChains } from "../supported-chains.js";
-import { CCIPVersion, ExecutionState, } from "../types.js";
-import { createRateLimitedFetch, decodeAddress, decodeOnRampAddress, getDataBytes, leToBigInt, networkInfo, parseTypeAndVersion, toLeArray, } from "../utils.js";
+import { CCIPVersion, ChainFamily, ExecutionState, } from "../types.js";
+import { createRateLimitedFetch, decodeAddress, decodeOnRampAddress, getDataBytes, leToBigInt, networkInfo, parseTypeAndVersion, toLeArray, util, } from "../utils.js";
 import { cleanUpBuffers } from "./cleanup.js";
-import { executeReport } from "./exec.js";
+import { generateUnsignedExecuteReport } from "./exec.js";
 import { getV16SolanaLeafHasher } from "./hasher.js";
 import { IDL as BASE_TOKEN_POOL } from "./idl/1.6.0/BASE_TOKEN_POOL.js";
 import { IDL as BURN_MINT_TOKEN_POOL } from "./idl/1.6.0/BURN_MINT_TOKEN_POOL.js";
@@ -20,8 +20,11 @@ import { IDL as CCIP_CCTP_TOKEN_POOL } from "./idl/1.6.0/CCIP_CCTP_TOKEN_POOL.js
 import { IDL as CCIP_OFFRAMP_IDL } from "./idl/1.6.0/CCIP_OFFRAMP.js";
 import { IDL as CCIP_ROUTER_IDL } from "./idl/1.6.0/CCIP_ROUTER.js";
 import { fetchSolanaOffchainTokenData } from "./offchain.js";
-import { ccipSend, getFee } from "./send.js";
-import { bytesToBuffer, getErrorFromLogs, parseSolanaLogs, simulationProvider } from "./utils.js";
+import { generateUnsignedCcipSend, getFee } from "./send.js";
+import { isWallet } from "./types.js";
+import { bytesToBuffer, getErrorFromLogs, hexDiscriminator, parseSolanaLogs, simulateAndSendTxs, simulationProvider, } from "./utils.js";
+import { fetchAllMessagesInBatch, fetchCCIPRequestById, fetchCCIPRequestsInTx, } from "../requests.js";
+import { patchBorsh } from "./patchBorsh.js";
 const routerCoder = new BorshCoder(CCIP_ROUTER_IDL);
 const offrampCoder = new BorshCoder(CCIP_OFFRAMP_IDL);
 const tokenPoolCoder = new BorshCoder({
@@ -40,114 +43,106 @@ const cctpTokenPoolCoder = new BorshCoder({
 const unknownTokens = {
     '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU': 'USDC', // devnet
 };
-function hexDiscriminator(eventName) {
-    return hexlify(eventDiscriminator(eventName));
-}
+/**
+ * Solana chain implementation supporting Solana networks.
+ */
 export class SolanaChain extends Chain {
+    static {
+        patchBorsh();
+        supportedChains[ChainFamily.Solana] = SolanaChain;
+    }
     static family = ChainFamily.Solana;
     static decimals = 9;
-    network;
     connection;
     commitment = 'confirmed';
-    _getSignaturesForAddress;
-    constructor(connection, network) {
-        super();
-        if (network.family !== ChainFamily.Solana) {
-            throw new Error(`Invalid network family for SolanaChain: ${network.family}`);
-        }
-        this.network = network;
+    /**
+     * Creates a new SolanaChain instance.
+     * @param connection - Solana connection instance.
+     * @param network - Network information for this chain.
+     */
+    constructor(connection, network, ctx) {
+        super(network, ctx);
         this.connection = connection;
         // Memoize expensive operations
-        this.typeAndVersion = moize.default(this.typeAndVersion.bind(this), {
+        this.typeAndVersion = memoize(this.typeAndVersion.bind(this), {
             maxArgs: 1,
-            isPromise: true,
+            async: true,
         });
-        this.getBlockTimestamp = moize.default(this.getBlockTimestamp.bind(this), {
-            isPromise: true,
+        this.getBlockTimestamp = memoize(this.getBlockTimestamp.bind(this), {
+            async: true,
             maxSize: 100,
-            updateCacheForKey: (key) => typeof key[key.length - 1] !== 'number',
+            forceUpdate: (key) => typeof key[key.length - 1] !== 'number',
         });
-        this.getTransaction = moize.default(this.getTransaction.bind(this), {
+        this.getTransaction = memoize(this.getTransaction.bind(this), {
             maxSize: 100,
             maxArgs: 1,
         });
-        this.getWallet = moize.default(this.getWallet.bind(this), { maxSize: 1, maxArgs: 0 });
-        this.getTokenForTokenPool = moize.default(this.getTokenForTokenPool.bind(this));
-        this.getTokenInfo = moize.default(this.getTokenInfo.bind(this));
-        this._getSignaturesForAddress = moize.default((programId, before) => this.connection.getSignaturesForAddress(new PublicKey(programId), { limit: 1000, before }, 'confirmed'), {
+        this.getTokenForTokenPool = memoize(this.getTokenForTokenPool.bind(this));
+        this.getTokenInfo = memoize(this.getTokenInfo.bind(this));
+        this.connection.getSignaturesForAddress = memoize(this.connection.getSignaturesForAddress.bind(this.connection), {
             maxSize: 100,
-            maxAge: 60000,
-            maxArgs: 2,
-            isPromise: true,
-            updateExpire: true,
-            // only expire undefined before (i.e. recent getSignaturesForAddress calls)
-            onExpire: ([, before]) => !before,
+            async: true,
+            // if options.before is defined, caches for long, otherwise for short (recent signatures)
+            expires: (key) => (key[1] ? 2 ** 31 - 1 : 5e3),
+            transformKey: ([address, options, commitment]) => [
+                address.toBase58(),
+                options?.before,
+                options?.until,
+                options?.limit,
+                commitment,
+            ],
         });
         // cache account info for 30 seconds
-        this.connection.getAccountInfo = moize.default(this.connection.getAccountInfo.bind(this.connection), {
+        this.connection.getAccountInfo = memoize(this.connection.getAccountInfo.bind(this.connection), {
             maxSize: 100,
             maxArgs: 2,
-            maxAge: 30e3,
-            transformArgs: ([address, commitment]) => [address.toString(), commitment],
-        });
-        this._getRouterConfig = moize.default(this._getRouterConfig.bind(this), {
-            maxArgs: 1,
-        });
-        this.listFeeTokens = moize.default(this.listFeeTokens.bind(this), {
-            maxArgs: 1,
+            expires: 30e3,
+            transformKey: ([address, commitment]) => [address.toString(), commitment],
         });
+        this._getRouterConfig = memoize(this._getRouterConfig.bind(this), { maxArgs: 1 });
+        this.getFeeTokens = memoize(this.getFeeTokens.bind(this), { maxArgs: 1 });
+        this.getOffRampsForRouter = memoize(this.getOffRampsForRouter.bind(this), { maxArgs: 1 });
     }
-    static _getConnection(url) {
+    /**
+     * Creates a Solana connection from a URL.
+     * @param url - RPC endpoint URL (https://, http://, wss://, or ws://).
+     * @param ctx - context containing logger.
+     * @returns Solana Connection instance.
+     */
+    static _getConnection(url, ctx) {
+        const { logger = console } = ctx ?? {};
         if (!url.startsWith('http') && !url.startsWith('ws')) {
             throw new Error(`Invalid Solana RPC URL format (should be https://, http://, wss://, or ws://): ${url}`);
         }
         const config = { commitment: 'confirmed' };
         if (url.includes('.solana.com')) {
-            config.fetch = createRateLimitedFetch({
-                maxRequests: 10,
-                maxRetries: 3,
-                windowMs: 11e3,
-            }); // public nodes
-            console.warn('Using rate-limited fetch for public solana nodes, commands may be slow');
+            config.fetch = createRateLimitedFetch(undefined, ctx); // public nodes
+            logger.warn('Using rate-limited fetch for public solana nodes, commands may be slow');
         }
         return new Connection(url, config);
     }
-    static async fromConnection(connection) {
+    /**
+     * Creates a SolanaChain instance from an existing connection.
+     * @param connection - Solana Connection instance.
+     * @param ctx - context containing logger.
+     * @returns A new SolanaChain instance.
+     */
+    static async fromConnection(connection, ctx) {
         // Get genesis hash to use as chainId
-        return new SolanaChain(connection, networkInfo(await connection.getGenesisHash()));
-    }
-    static async fromUrl(url) {
-        const connection = this._getConnection(url);
-        return this.fromConnection(connection);
-    }
-    async destroy() {
-        // Solana Connection doesn't have an explicit destroy method
-        // The memoized functions will be garbage collected when the instance is destroyed
-    }
-    static getWallet(_opts) {
-        throw new Error('Wallet not implemented');
+        return new SolanaChain(connection, networkInfo(await connection.getGenesisHash()), ctx);
     }
     /**
-     * Load wallet
-     * @param opts - options to load wallet
-     * @param opts.wallet - private key as 0x or base58 string, or async getter function resolving to
-     *   Wallet instance
-     * @returns Wallet, after caching in instance
+     * Creates a SolanaChain instance from an RPC URL.
+     * @param url - RPC endpoint URL.
+     * @param ctx - context containing logger.
+     * @returns A new SolanaChain instance.
      */
-    async getWallet(opts = {}) {
-        try {
-            if (typeof opts.wallet === 'string')
-                return new Wallet(Keypair.fromSecretKey(opts.wallet.startsWith('0x') ? getBytes(opts.wallet) : bs58.decode(opts.wallet)));
-        }
-        catch (_) {
-            // pass
-        }
-        return this.constructor.getWallet(opts);
-    }
-    async getWalletAddress(opts) {
-        return (await this.getWallet(opts)).publicKey.toBase58();
+    static async fromUrl(url, ctx) {
+        const connection = this._getConnection(url, ctx);
+        return this.fromConnection(connection, ctx);
     }
     // cached
+    /** {@inheritDoc Chain.getBlockTimestamp} */
     async getBlockTimestamp(block) {
         if (block === 'finalized') {
             const slot = await this.connection.getSlot('finalized');
@@ -163,7 +158,7 @@ export class SolanaChain extends Chain {
         }
         return blockTime;
     }
-    // cached
+    /** {@inheritDoc Chain.getTransaction} */
     async getTransaction(hash) {
         const tx = await this.connection.getTransaction(hash, {
             commitment: 'confirmed',
@@ -173,7 +168,7 @@ export class SolanaChain extends Chain {
             throw new Error(`Transaction not found: ${hash}`);
         if (tx.blockTime) {
             ;
-            this.getBlockTimestamp.set([tx.slot], Promise.resolve(tx.blockTime));
+            this.getBlockTimestamp.cache.set([tx.slot], Promise.resolve(tx.blockTime));
         }
         else {
             tx.blockTime = await this.getBlockTimestamp(tx.slot);
@@ -187,7 +182,6 @@ export class SolanaChain extends Chain {
             }))
             : [];
         const chainTx = {
-            chain: this,
             hash,
             logs: [],
             blockNumber: tx.slot,
@@ -200,48 +194,54 @@ export class SolanaChain extends Chain {
         chainTx.logs = logs_.map((l) => Object.assign(l, { tx: chainTx }));
         return chainTx;
     }
-    // implements inner paging logic for this.getLogs
-    async *_getTransactionsForAddress(opts) {
+    /**
+     * Internal method to get transactions for an address with pagination.
+     * @param opts - Log filter options.
+     * @returns Async generator of Solana transactions.
+     */
+    async *getTransactionsForAddress(opts) {
         if (!opts.address)
             throw new Error('Program address is required for Solana log filtering');
         let allSignatures;
+        const limit = Math.min(opts?.page || 1000, 1000);
         if (opts.startBlock || opts.startTime) {
             // forward collect all matching sigs in array
-            const allSigs = [];
-            let batch, popped = false;
-            while (!popped && (batch?.length ?? true)) {
-                batch = await this._getSignaturesForAddress(opts.address, allSigs[allSigs.length - 1]?.signature);
+            allSignatures = [];
+            let batch;
+            do {
+                batch = await this.connection.getSignaturesForAddress(new PublicKey(opts.address), { limit, before: allSignatures[allSignatures.length - 1]?.signature }, 'confirmed');
                 while (batch.length > 0 &&
                     (batch[batch.length - 1].slot < (opts.startBlock || 0) ||
                         (batch[batch.length - 1].blockTime || -1) < (opts.startTime || 0))) {
-                    batch.pop(); // pop tail of txs which are older than requested start
-                    popped = true;
+                    batch.length--; // truncate tail of txs which are older than requested start
                 }
-                allSigs.push(...batch);
-            }
-            allSigs.reverse();
+                allSignatures.push(...batch); // concat in descending order
+            } while (batch.length >= limit);
+            allSignatures.reverse();
             while (opts.endBlock &&
-                allSigs.length > 0 &&
-                allSigs[allSigs.length - 1].slot > opts.endBlock) {
-                allSigs.pop(); // pop head (after reverse) of txs which are newer than requested end
+                allSignatures.length > 0 &&
+                allSignatures[allSignatures.length - 1].slot > opts.endBlock) {
+                allSignatures.length--; // truncate head (after reverse) of txs newer than requested end
             }
-            allSignatures = allSigs;
         }
         else {
             allSignatures = async function* () {
                 let batch;
-                while (batch?.length ?? true) {
-                    batch = await this._getSignaturesForAddress(opts.address, batch?.length
-                        ? batch[batch.length - 1].signature
-                        : opts.endBefore
-                            ? opts.endBefore
-                            : undefined);
+                do {
+                    batch = await this.connection.getSignaturesForAddress(new PublicKey(opts.address), {
+                        limit,
+                        before: batch?.length
+                            ? batch[batch.length - 1].signature
+                            : opts.endBefore
+                                ? opts.endBefore
+                                : undefined,
+                    }, 'confirmed');
                     for (const sig of batch) {
                         if (opts.endBlock && sig.slot > opts.endBlock)
                             continue;
                         yield sig;
                     }
-                }
+                } while (batch.length >= limit);
             }.call(this); // generate backwards until depleting getSignaturesForAddress
         }
         // Process signatures
@@ -263,17 +263,16 @@ export class SolanaChain extends Chain {
      *   * Fetches signatures in reverse chronological order (newest first)
      *   * Returns logs in reverse chronological order (newest first)
      *
-     * @param opts - Log filter options
-     * @param opts.startBlock - Starting slot number (inclusive)
-     * @param opts.startTime - Starting Unix timestamp (inclusive)
-     * @param opts.endBlock - Ending slot number (inclusive)
-     * @param opts.address - Program address to filter logs by (required for Solana)
-     * @param opts.topics - Array of topics to filter logs by (optional);
-     *   either 0x-8B discriminants or event names
-     * @param.opts.programs - a special option to allow querying by address of interest, but
-     *   yielding matching logs from specific (string address) program or any (true)
-     * @param opts.commit - Special param for fetching ExecutionReceipts, to narrow down the search
-     * @returns AsyncIterableIterator of parsed Log_ objects
+     * @param opts - Log filter options containing:
+     *   - `startBlock`: Starting slot number (inclusive)
+     *   - `startTime`: Starting Unix timestamp (inclusive)
+     *   - `endBlock`: Ending slot number (inclusive)
+     *   - `address`: Program address to filter logs by (required for Solana)
+     *   - `topics`: Array of topics to filter logs by (optional); either 0x-8B discriminants or event names
+     *   - `programs`: Special option to allow querying by address of interest, but yielding matching
+     *     logs from specific (string address) program or any (true)
+     *   - `commit`: Special param for fetching ExecutionReceipts, to narrow down the search
+     * @returns AsyncIterableIterator of parsed Log_ objects.
      */
     async *getLogs(opts) {
         let programs;
@@ -298,20 +297,43 @@ export class SolanaChain extends Chain {
             opts.topics.push(...opts.topics.filter((t) => !isHexString(t, 8)).map((t) => hexDiscriminator(t)));
         }
         // Process signatures and yield logs
-        for await (const tx of this._getTransactionsForAddress(opts)) {
+        for await (const tx of this.getTransactionsForAddress(opts)) {
             for (const log of tx.logs) {
                 // Filter and yield logs from the specified program, and which match event discriminant or log prefix
                 if ((programs !== true && !programs.includes(log.address)) ||
                     (opts.topics?.length &&
                         !opts.topics.some((t) => t === log.topics[0] || (typeof log.data === 'string' && log.data.startsWith(t)))))
                     continue;
-                yield Object.assign(log, { timestamp: new Date(tx.timestamp * 1000) });
+                yield log;
             }
         }
     }
+    /** {@inheritDoc Chain.fetchRequestsInTx} */
+    async fetchRequestsInTx(tx) {
+        return fetchCCIPRequestsInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx);
+    }
+    /** {@inheritDoc Chain.fetchRequestById} */
+    fetchRequestById(messageId, onRamp, opts) {
+        if (!onRamp)
+            throw new Error('onRamp is required');
+        return fetchCCIPRequestById(this, messageId, { address: onRamp, ...opts });
+    }
+    /** {@inheritDoc Chain.fetchAllMessagesInBatch} */
+    async fetchAllMessagesInBatch(request, commit, opts) {
+        const [destChainStatePda] = PublicKey.findProgramAddressSync([Buffer.from('dest_chain_state'), toLeArray(request.lane.destChainSelector, 8)], new PublicKey(request.log.address));
+        // fetchAllMessagesInBatch pass opts back to getLogs; use it to narrow getLogs filter only to
+        // txs touching destChainStatePda
+        const opts_ = {
+            ...opts,
+            programs: [request.log.address],
+            address: destChainStatePda.toBase58(),
+        };
+        return fetchAllMessagesInBatch(this, request, commit, opts_);
+    }
+    /** {@inheritDoc Chain.typeAndVersion} */
     async typeAndVersion(address) {
         const program = new Program(CCIP_OFFRAMP_IDL, // `typeVersion` schema should be the same
-        new PublicKey(address), simulationProvider(this.connection));
+        new PublicKey(address), simulationProvider(this));
         // Create the typeVersion instruction
         const returnDataString = (await program.methods
             .typeVersion()
@@ -322,9 +344,11 @@ export class SolanaChain extends Chain {
             res[1] = CCIPVersion.V1_6;
         return res;
     }
+    /** {@inheritDoc Chain.getRouterForOnRamp} */
     getRouterForOnRamp(onRamp, _destChainSelector) {
         return Promise.resolve(onRamp); // Solana's router is also the onRamp
     }
+    /** {@inheritDoc Chain.getRouterForOffRamp} */
     async getRouterForOffRamp(offRamp, _sourceChainSelector) {
         const offRamp_ = new PublicKey(offRamp);
         const program = new Program(CCIP_OFFRAMP_IDL, offRamp_, {
@@ -338,9 +362,11 @@ export class SolanaChain extends Chain {
         const { router } = program.coder.accounts.decode('referenceAddresses', referenceAddressesPda.data);
         return router.toBase58();
     }
+    /** {@inheritDoc Chain.getNativeTokenForRouter} */
     getNativeTokenForRouter(_router) {
         return Promise.resolve(NATIVE_MINT.toBase58());
     }
+    /** {@inheritDoc Chain.getOffRampsForRouter} */
     async getOffRampsForRouter(router, sourceChainSelector) {
         // feeQuoter is present in router's config, and has a DestChainState account which is updated by
         // the offramps, so we can use it to narrow the search for the offramp
@@ -355,9 +381,11 @@ export class SolanaChain extends Chain {
         }
         throw new Error(`Could not find OffRamp events in feeQuoter=${feeQuoter.toString()} txs`);
     }
+    /** {@inheritDoc Chain.getOnRampForRouter} */
     getOnRampForRouter(router, _destChainSelector) {
         return Promise.resolve(router); // solana's Router is also the OnRamp
     }
+    /** {@inheritDoc Chain.getOnRampForOffRamp} */
     async getOnRampForOffRamp(offRamp, sourceChainSelector) {
         const program = new Program(CCIP_OFFRAMP_IDL, new PublicKey(offRamp), {
             connection: this.connection,
@@ -367,9 +395,11 @@ export class SolanaChain extends Chain {
         const { config: { onRamp }, } = await program.account.sourceChain.fetch(statePda);
         return decodeAddress(new Uint8Array(onRamp.bytes.slice(0, onRamp.len)), networkInfo(sourceChainSelector).family);
     }
+    /** {@inheritDoc Chain.getCommitStoreForOffRamp} */
     getCommitStoreForOffRamp(offRamp) {
         return Promise.resolve(offRamp); // Solana supports only CCIP>=1.6, for which OffRamp and CommitStore are the same
     }
+    /** {@inheritDoc Chain.getTokenForTokenPool} */
     async getTokenForTokenPool(tokenPool) {
         const tokenPoolInfo = await this.connection.getAccountInfo(new PublicKey(tokenPool));
         if (!tokenPoolInfo)
@@ -377,6 +407,7 @@ export class SolanaChain extends Chain {
         const { config } = tokenPoolCoder.accounts.decode('state', tokenPoolInfo.data);
         return config.mint.toString();
     }
+    /** {@inheritDoc Chain.getTokenInfo} */
     async getTokenInfo(token) {
         const mint = new PublicKey(token);
         const mintInfo = await this.connection.getParsedAccountInfo(mint);
@@ -408,7 +439,7 @@ export class SolanaChain extends Chain {
                 }
                 catch (error) {
                     // Metaplex metadata fetch failed, keep the default values
-                    console.debug(`Failed to fetch Metaplex metadata for token ${token}:`, error);
+                    this.logger.debug(`Failed to fetch Metaplex metadata for token ${token}:`, error);
                 }
             }
             return {
@@ -421,6 +452,11 @@ export class SolanaChain extends Chain {
             throw new Error(`Unable to parse token data for ${token}`);
         }
     }
+    /**
+     * Fetches token metadata from Metaplex.
+     * @param mintPublicKey - Token mint public key.
+     * @returns Token name and symbol, or null if not found.
+     */
     async _fetchTokenMetadata(mintPublicKey) {
         try {
             // Token Metadata Program ID
@@ -467,34 +503,30 @@ export class SolanaChain extends Chain {
             return name || symbol ? { name, symbol } : null;
         }
         catch (error) {
-            console.debug('Error fetching token metadata:', error);
+            this.logger.debug('Error fetching token metadata:', error);
             return null;
         }
     }
+    /**
+     * Decodes a CCIP message from a Solana log event.
+     * @param log - Log with data field.
+     * @returns Decoded CCIPMessage or undefined if not valid.
+     */
     static decodeMessage({ data }) {
         if (!data || typeof data !== 'string')
             return undefined;
-        let eventDataBuffer;
+        // Verify the discriminant matches CCIPMessageSent
         try {
-            eventDataBuffer = bytesToBuffer(data);
+            if (dataSlice(getDataBytes(data), 0, 8) !== hexDiscriminator('CCIPMessageSent'))
+                return;
         }
         catch (_) {
             return;
         }
-        const disc = dataSlice(eventDataBuffer, 0, 8);
-        if (disc !== hexDiscriminator('CCIPMessageSent'))
+        const decoded = routerCoder.events.decode(data);
+        if (decoded?.name !== 'CCIPMessageSent')
             return;
-        // Use module-level BorshCoder for decoding structs
-        // Manually parse event header (discriminator + event-level fields)
-        let offset = 8;
-        // Parse event-level fields
-        const _destChainSelector = eventDataBuffer.readBigUInt64LE(offset);
-        offset += 8;
-        const _sequenceNumber = eventDataBuffer.readBigUInt64LE(offset);
-        offset += 8;
-        // Now decode the SVM2AnyRampMessage struct using BorshCoder
-        const messageBytes = eventDataBuffer.subarray(offset);
-        const message = routerCoder.types.decode('SVM2AnyRampMessage', messageBytes);
+        const message = decoded.data.message;
         // Convert BN/number types to bigints
         const sourceChainSelector = BigInt(message.header.sourceChainSelector.toString());
         const destChainSelector = BigInt(message.header.destChainSelector.toString());
@@ -547,6 +579,11 @@ export class SolanaChain extends Chain {
             ...rest,
         };
     }
+    /**
+     * Decodes extra arguments from Solana CCIP messages.
+     * @param extraArgs - Encoded extra arguments bytes.
+     * @returns Decoded EVMExtraArgsV2 or undefined if unknown format.
+     */
     static decodeExtraArgs(extraArgs) {
         const data = getDataBytes(extraArgs), tag = dataSlice(data, 0, 4);
         switch (tag) {
@@ -565,6 +602,11 @@ export class SolanaChain extends Chain {
                 return;
         }
     }
+    /**
+     * Encodes extra arguments for Solana CCIP messages.
+     * @param args - Extra arguments to encode.
+     * @returns Encoded extra arguments as hex string.
+     */
     static encodeExtraArgs(args) {
         if ('computeUnits' in args)
             throw new Error('Solana can only encode EVMExtraArgsV2');
@@ -575,35 +617,33 @@ export class SolanaChain extends Chain {
             'allowOutOfOrderExecution' in args && args.allowOutOfOrderExecution ? '0x01' : '0x00',
         ]);
     }
+    /**
+     * Decodes commit reports from a Solana log event.
+     * @param log - Log with data field.
+     * @param lane - Lane info for filtering.
+     * @returns Array of CommitReport or undefined if not valid.
+     */
     static decodeCommits(log, lane) {
         // Check if this is a CommitReportAccepted event by looking at the discriminant
         if (!log.data || typeof log.data !== 'string') {
             throw new Error('Log data is missing or not a string');
         }
-        const eventDataBuffer = bytesToBuffer(log.data);
-        // Verify the discriminant matches CommitReportAccepted
-        const expectedDiscriminant = hexDiscriminator('CommitReportAccepted');
-        const actualDiscriminant = hexlify(eventDataBuffer.subarray(0, 8));
-        if (actualDiscriminant !== expectedDiscriminant)
+        try {
+            // Verify the discriminant matches CommitReportAccepted
+            if (dataSlice(getDataBytes(log.data), 0, 8) !== hexDiscriminator('CommitReportAccepted'))
+                return;
+        }
+        catch (_) {
             return;
-        // Skip the 8-byte discriminant and decode the event data manually
-        let offset = 8;
-        // Decode Option<MerkleRoot> - first byte indicates Some(1) or None(0)
-        const hasValue = eventDataBuffer.readUInt8(offset);
-        offset += 1;
-        if (!hasValue)
-            return [];
-        // Decode MerkleRoot struct using the types decoder
-        // We need to read the remaining bytes as a MerkleRoot struct
-        const merkleRootBytes = eventDataBuffer.subarray(offset);
-        const merkleRootData = offrampCoder.types.decode('MerkleRoot', merkleRootBytes);
-        if (!merkleRootData) {
-            throw new Error('Failed to decode MerkleRoot data');
         }
+        const decoded = offrampCoder.events.decode(log.data);
+        if (decoded?.name !== 'CommitReportAccepted' || !decoded.data?.merkleRoot)
+            return;
+        const merkleRoot = decoded.data.merkleRoot;
         // Verify the source chain selector matches our lane
-        const sourceChainSelector = BigInt(merkleRootData.sourceChainSelector.toString());
+        const sourceChainSelector = BigInt(merkleRoot.sourceChainSelector.toString());
         // Convert the onRampAddress from bytes to the proper format
-        const onRampAddress = decodeOnRampAddress(merkleRootData.onRampAddress, networkInfo(sourceChainSelector).family);
+        const onRampAddress = decodeOnRampAddress(merkleRoot.onRampAddress, networkInfo(sourceChainSelector).family);
         if (lane) {
             if (sourceChainSelector !== lane.sourceChainSelector)
                 return;
@@ -615,40 +655,48 @@ export class SolanaChain extends Chain {
             {
                 sourceChainSelector,
                 onRampAddress,
-                minSeqNr: BigInt(merkleRootData.minSeqNr.toString()),
-                maxSeqNr: BigInt(merkleRootData.maxSeqNr.toString()),
-                merkleRoot: hexlify(new Uint8Array(merkleRootData.merkleRoot)),
+                minSeqNr: BigInt(merkleRoot.minSeqNr.toString()),
+                maxSeqNr: BigInt(merkleRoot.maxSeqNr.toString()),
+                merkleRoot: hexlify(getDataBytes(merkleRoot.merkleRoot)),
             },
         ];
     }
+    /**
+     * Decodes an execution receipt from a Solana log event.
+     * @param log - Log with data, tx, and index fields.
+     * @returns ExecutionReceipt or undefined if not valid.
+     */
     static decodeReceipt(log) {
         // Check if this is a ExecutionStateChanged event by looking at the discriminant
         if (!log.data || typeof log.data !== 'string') {
             throw new Error('Log data is missing or not a string');
         }
-        // Verify the discriminant matches ExecutionStateChanged
-        if (dataSlice(getDataBytes(log.data), 0, 8) !== hexDiscriminator('ExecutionStateChanged'))
+        try {
+            // Verify the discriminant matches ExecutionStateChanged
+            if (dataSlice(getDataBytes(log.data), 0, 8) !== hexDiscriminator('ExecutionStateChanged'))
+                return;
+        }
+        catch (_) {
+            return;
+        }
+        const decoded = offrampCoder.events.decode(log.data);
+        if (decoded?.name !== 'ExecutionStateChanged')
             return;
-        const eventDataBuffer = bytesToBuffer(log.data);
-        // Note: We manually decode the event fields rather than using BorshCoder
-        // since ExecutionStateChanged is an event, not a defined type
-        // Skip the 8-byte discriminant and manually decode the event fields
-        let offset = 8;
-        // Decode sourceChainSelector (u64)
-        const sourceChainSelector = eventDataBuffer.readBigUInt64LE(offset);
-        offset += 8;
-        // Decode sequenceNumber (u64)
-        const sequenceNumber = eventDataBuffer.readBigUInt64LE(offset);
-        offset += 8;
-        // Decode messageId ([u8; 32])
-        const messageId = hexlify(eventDataBuffer.subarray(offset, offset + 32));
-        offset += 32;
-        // Decode messageHash ([u8; 32])
-        const messageHash = hexlify(eventDataBuffer.subarray(offset, offset + 32));
-        offset += 32;
+        const messageId = hexlify(getDataBytes(decoded.data.messageId));
         // Decode state enum (MessageExecutionState)
         // Enum discriminant is a single byte: Untouched=0, InProgress=1, Success=2, Failure=3
-        let state = eventDataBuffer.readUInt8(offset);
+        let state;
+        if (decoded.data.state.inProgress) {
+            state = ExecutionState.InProgress;
+        }
+        else if (decoded.data.state.success) {
+            state = ExecutionState.Success;
+        }
+        else if (decoded.data.state.failure) {
+            state = ExecutionState.Failed;
+        }
+        else
+            throw new Error(`Invalid ExecutionState: ${util.inspect(decoded.data.state)}`);
         let returnData;
         if (log.tx) {
             // use only last receipt per tx+message (i.e. skip intermediary InProgress=1 states for Solana)
@@ -670,14 +718,19 @@ export class SolanaChain extends Chain {
             }
         }
         return {
-            sourceChainSelector,
-            sequenceNumber,
+            sourceChainSelector: BigInt(decoded.data.sourceChainSelector.toString()),
+            sequenceNumber: BigInt(decoded.data.sequenceNumber.toString()),
             messageId,
-            messageHash,
+            messageHash: hexlify(getDataBytes(decoded.data.messageHash)),
             state,
             returnData,
         };
     }
+    /**
+     * Converts bytes to a Solana address (Base58).
+     * @param bytes - Bytes to convert.
+     * @returns Base58-encoded Solana address.
+     */
     static getAddress(bytes) {
         try {
             if (typeof bytes === 'string' && bs58.decode(bytes).length === 32)
@@ -688,9 +741,15 @@ export class SolanaChain extends Chain {
         }
         return encodeBase58(getDataBytes(bytes));
     }
-    static getDestLeafHasher(lane) {
-        return getV16SolanaLeafHasher(lane);
+    /**
+     * Gets the leaf hasher for Solana destination chains.
+     * @param lane - Lane configuration.
+     * @returns Leaf hasher function.
+     */
+    static getDestLeafHasher(lane, ctx) {
+        return getV16SolanaLeafHasher(lane, ctx);
     }
+    /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
     async getTokenAdminRegistryFor(address) {
         const [type] = await this.typeAndVersion(address);
         if (!type.includes('Router'))
@@ -698,52 +757,114 @@ export class SolanaChain extends Chain {
         // Solana implements TokenAdminRegistry in the Router/OnRamp program
         return address;
     }
+    /** {@inheritDoc Chain.getFee} */
+    getFee(router, destChainSelector, message) {
+        return getFee(this, router, destChainSelector, message);
+    }
     /**
-     * Get the fee required to send a CCIP message from the Solana router.
+     * Raw/unsigned version of [[sendMessage]]
+     *
+     * @param sender - sender/feePayer address
+     * @param router - router address
+     * @param destChainSelector - destination chain selector
+     * @param message - AnyMessage to send (with or without fee)
+     * @param approveMax - approve max amount of tokens if needed, instead of only what's needed
+     * @returns instructions - array of instructions; `ccipSend` is last, after any approval
+     *   lookupTables - array of lookup tables for `ccipSend` call
+     *   mainIndex - instructions.length - 1
      */
-    getFee(router, destChainSelector, message) {
-        return getFee(this.connection, router, destChainSelector, message);
+    async generateUnsignedSendMessage(sender, router, destChainSelector, message, opts) {
+        if (!message.fee)
+            message.fee = await this.getFee(router, destChainSelector, message);
+        return generateUnsignedCcipSend(this, new PublicKey(sender), new PublicKey(router), destChainSelector, message, opts);
     }
-    async sendMessage(router_, destChainSelector, message, opts) {
-        const wallet = await this.getWallet(opts);
-        const router = new Program(CCIP_ROUTER_IDL, new PublicKey(router_), new AnchorProvider(this.connection, wallet, { commitment: this.commitment }));
-        const { hash } = await ccipSend(router, destChainSelector, message, opts);
-        return this.getTransaction(hash);
+    /** {@inheritDoc Chain.sendMessage} */
+    async sendMessage(router, destChainSelector, message, opts) {
+        const wallet = opts.wallet;
+        if (!isWallet(wallet))
+            throw new Error(`Expected Wallet, got=${util.inspect(wallet)}`);
+        const unsigned = await this.generateUnsignedSendMessage(wallet.publicKey.toBase58(), router, destChainSelector, message, opts);
+        const hash = await simulateAndSendTxs(this, wallet, unsigned);
+        return (await this.fetchRequestsInTx(await this.getTransaction(hash)))[0];
     }
+    /** {@inheritDoc Chain.fetchOffchainTokenData} */
     async fetchOffchainTokenData(request) {
-        return fetchSolanaOffchainTokenData(this.connection, request);
+        return fetchSolanaOffchainTokenData(request, this);
     }
-    async executeReport(offRamp, execReport_, opts) {
+    /**
+     * Raw/unsigned version of [[executeReport]]
+     * @param payer - payer address of the execution transaction
+     * @param offRamp - OffRamp contract address
+     * @param execReport_ - ExecutionReport of a dest=Solana message
+     * @param opts - execute report options
+     *   - forceBuffer - Whether to force the use of a buffer account
+     *   - forceLookupTable - Whether to force creation of a lookup table for the call
+     * @returns instructions - array of instructions to execute the report
+     *   lookupTables - array of lookup tables for `manuallyExecute` call
+     *   mainIndex - index of the `manuallyExecute` instruction in the array; last unless
+     *   forceLookupTable is set, in which case last is ALT deactivation tx, and manuallyExecute is
+     *   second to last
+     */
+    async generateUnsignedExecuteReport(payer, offRamp, execReport_, opts) {
         if (!('computeUnits' in execReport_.message))
             throw new Error("ExecutionReport's message not for Solana");
         const execReport = execReport_;
-        const wallet = await this.getWallet(opts);
-        const provider = new AnchorProvider(this.connection, wallet, { commitment: this.commitment });
-        const offrampProgram = new Program(CCIP_OFFRAMP_IDL, new PublicKey(offRamp), provider);
-        const rep = await executeReport({ offrampProgram, execReport, ...opts });
-        if (opts?.clearLeftoverAccounts) {
+        const offRamp_ = new PublicKey(offRamp);
+        return generateUnsignedExecuteReport(this, new PublicKey(payer), offRamp_, execReport, opts);
+    }
+    /** {@inheritDoc Chain.executeReport} */
+    async executeReport(offRamp, execReport, opts) {
+        const wallet = opts.wallet;
+        if (!isWallet(wallet))
+            throw new Error(`Expected Wallet, got=${util.inspect(wallet)}`);
+        let hash;
+        do {
             try {
-                await this.cleanUpBuffers(opts);
+                const unsigned = await this.generateUnsignedExecuteReport(wallet.publicKey.toBase58(), offRamp, execReport, opts);
+                hash = await simulateAndSendTxs(this, wallet, unsigned, opts?.gasLimit);
             }
             catch (err) {
-                console.warn('Error while trying to clean up buffers:', err);
+                if (!(err instanceof Error) ||
+                    !['encoding overruns Uint8Array', 'too large'].some((e) => err.message.includes(e)))
+                    throw err;
+                // in case of failure to serialize a report, first try buffering (because it gets
+                // auto-closed upon successful execution), then ALTs (need a grace period ~3min after
+                // deactivation before they can be closed/recycled)
+                if (!opts?.forceBuffer)
+                    opts = { ...opts, forceBuffer: true };
+                else if (!opts?.forceLookupTable)
+                    opts = { ...opts, forceLookupTable: true };
+                else
+                    throw err;
             }
+        } while (!hash);
+        try {
+            await this.cleanUpBuffers(opts);
         }
-        return this.getTransaction(rep.hash);
+        catch (err) {
+            this.logger.warn('Error while trying to clean up buffers:', err);
+        }
+        return this.getTransaction(hash);
     }
     /**
      * Clean up and recycle buffers and address lookup tables owned by wallet
-     * CAUTION: this will close ANY lookup table owned by this wallet
-     * @param wallet - wallet options
-     * @param 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
+     * @param opts - cleanUp options
+     *   - wallet - wallet instance to sign txs
+     *   - waitDeactivation - Whether to wait for lookup table deactivation cool down period
+     *       (513 slots) to pass before closing; by default, we deactivate (if needed) and move on, to
+     *       close other ready ALTs
      */
     async cleanUpBuffers(opts) {
-        const wallet = await this.getWallet(opts);
-        const provider = new AnchorProvider(this.connection, wallet, { commitment: this.commitment });
-        await cleanUpBuffers(provider, this.getLogs.bind(this), opts);
+        const wallet = opts.wallet;
+        if (!isWallet(wallet))
+            throw new Error(`Expected Wallet, got=${util.inspect(wallet)}`);
+        await cleanUpBuffers(this, wallet, this.getLogs.bind(this), opts);
     }
+    /**
+     * Parses raw Solana data into typed structures.
+     * @param data - Raw data to parse.
+     * @returns Parsed data or undefined.
+     */
     static parse(data) {
         if (!data)
             return;
@@ -794,8 +915,8 @@ export class SolanaChain extends Chain {
                         bytes: encodeBase58(toLeArray(request.lane.sourceChainSelector, 8)),
                     },
                 },
-                // dirty trick: memcmp report.min with msg.sequenceNumber's without least-significant byte;
-                // this should be ~256 around seqNum, i.e. big chance of a match
+                // hack: memcmp report.min with msg.sequenceNumber's without least-significant byte;
+                // this should be ~256 around seqNum, i.e. big chance of a match; requires PDAs to be alive
                 {
                     memcmp: {
                         offset: 8 + 1 + 8 + 32 + 8 + 1,
@@ -827,38 +948,25 @@ export class SolanaChain extends Chain {
         // in case we can't find it, fallback to generic iterating txs
         return super.fetchCommitReport(commitStore, request, hints);
     }
-    // specialized override with stricter address-of-interest
-    async *fetchExecutionReceipts(offRamp, messageIds, hints) {
-        if (!hints?.commit) {
-            // if no commit, fall back to generic implementation
-            yield* super.fetchExecutionReceipts(offRamp, messageIds, hints);
-            return;
-        }
-        // otherwise, use `commit_report` PDA as more specialized address
-        const [commitReportPda] = PublicKey.findProgramAddressSync([
-            Buffer.from('commit_report'),
-            toLeArray(hints.commit.sourceChainSelector, 8),
-            bytesToBuffer(hints.commit.merkleRoot),
-        ], new PublicKey(offRamp));
-        // rest is similar to generic implemenetation
-        const onlyLast = !hints?.startBlock && !hints?.startTime; // backwards
-        for await (const log of this.getLogs({
-            ...hints,
-            programs: [offRamp],
-            address: commitReportPda.toBase58(),
-            topics: ['ExecutionStateChanged'],
-        })) {
-            const receipt = this.constructor.decodeReceipt(log);
-            if (!receipt || !messageIds.has(receipt.messageId))
-                continue;
-            if (onlyLast || receipt.state === ExecutionState.Success)
-                messageIds.delete(receipt.messageId);
-            const timestamp = await this.getBlockTimestamp(log.blockNumber);
-            yield { receipt, log, timestamp };
-            if (!messageIds.size)
-                break;
+    /** {@inheritDoc Chain.fetchExecutionReceipts} */
+    async *fetchExecutionReceipts(offRamp, request, commit, opts) {
+        let opts_ = opts;
+        if (commit) {
+            // if we know of commit, use `commit_report` PDA as more specialized address
+            const [commitReportPda] = PublicKey.findProgramAddressSync([
+                Buffer.from('commit_report'),
+                toLeArray(request.lane.sourceChainSelector, 8),
+                bytesToBuffer(commit.report.merkleRoot),
+            ], new PublicKey(offRamp));
+            opts_ = {
+                ...opts,
+                programs: [offRamp],
+                address: commitReportPda.toBase58(),
+            };
         }
+        yield* super.fetchExecutionReceipts(offRamp, request, commit, opts_);
     }
+    /** {@inheritDoc Chain.getRegistryTokenConfig} */
     async getRegistryTokenConfig(registry, token) {
         const registry_ = new PublicKey(registry);
         const tokenMint = new PublicKey(token);
@@ -893,6 +1001,7 @@ export class SolanaChain extends Chain {
         }
         return config;
     }
+    /** {@inheritDoc Chain.getTokenPoolConfigs} */
     async getTokenPoolConfigs(tokenPool) {
         // `tokenPool` is actually a State PDA in the tokenPoolProgram
         const tokenPoolState = await this.connection.getAccountInfo(new PublicKey(tokenPool));
@@ -915,6 +1024,7 @@ export class SolanaChain extends Chain {
             typeAndVersion,
         };
     }
+    /** {@inheritDoc Chain.getTokenPoolRemotes} */
     async getTokenPoolRemotes(tokenPool, remoteChainSelector) {
         // `tokenPool` is actually a State PDA in the tokenPoolProgram
         const tokenPoolState = await this.connection.getAccountInfo(new PublicKey(tokenPool));
@@ -1023,11 +1133,12 @@ export class SolanaChain extends Chain {
                 };
             }
             catch (err) {
-                console.warn('Failed to decode ChainConfig account:', err);
+                this.logger.warn('Failed to decode ChainConfig account:', err);
             }
         }
         return remotes;
     }
+    /** {@inheritDoc Chain.getSupportedTokens} */
     async getSupportedTokens(router) {
         // `mint` offset in TokenAdminRegistry account data; more robust against changes in layout
         const mintOffset = 8 + 1 + 32 + 32 + 32 + 16 * 2; // = 137
@@ -1053,7 +1164,8 @@ export class SolanaChain extends Chain {
         }
         return res;
     }
-    async listFeeTokens(router) {
+    /** {@inheritDoc Chain.getFeeTokens} */
+    async getFeeTokens(router) {
         const { feeQuoter } = await this._getRouterConfig(router);
         const tokenConfigs = await this.connection.getProgramAccounts(feeQuoter, {
             filters: [
@@ -1066,11 +1178,15 @@ export class SolanaChain extends Chain {
             ],
         });
         return Object.fromEntries(await Promise.all(tokenConfigs.map(async (acc) => {
-            const token = new PublicKey(acc.account.data.subarray(10, 10 + 32));
-            return [token.toBase58(), await this.getTokenInfo(token.toBase58())];
+            const token = new PublicKey(acc.account.data.subarray(10, 10 + 32)).toBase58();
+            return [token, await this.getTokenInfo(token)];
         })));
     }
-    // cached
+    /**
+     * Gets the router configuration from the Config PDA.
+     * @param router - Router program address.
+     * @returns Router configuration including feeQuoter.
+     */
     async _getRouterConfig(router) {
         const program = new Program(CCIP_ROUTER_IDL, new PublicKey(router), {
             connection: this.connection,
@@ -1081,5 +1197,4 @@ export class SolanaChain extends Chain {
         return program.account.config.fetch(configPda);
     }
 }
-supportedChains[ChainFamily.Solana] = SolanaChain;
 //# sourceMappingURL=index.js.map