@atomiqlabs/chain-solana 11.0.0 → 12.0.6

package/dist/solana/SolanaChainType.d.ts

@@ -7,4 +7,5 @@ import { SolanaSwapData } from "./swaps/SolanaSwapData";
 import { SolanaChainEventsBrowser } from "./events/SolanaChainEventsBrowser";
 import { SolanaBtcRelay } from "./btcrelay/SolanaBtcRelay";
 import { SolanaChainInterface } from "./chain/SolanaChainInterface";
-export type SolanaChainType = ChainType<"SOLANA", SolanaPreFetchData, SolanaPreFetchVerification, SolanaTx, SolanaSigner, SolanaSwapData, SolanaSwapProgram, SolanaChainInterface, SolanaChainEventsBrowser, SolanaBtcRelay<any>, never, never, never>;
+import { Wallet } from "@coral-xyz/anchor/dist/cjs/provider";
+export type SolanaChainType = ChainType<"SOLANA", SolanaPreFetchData, SolanaPreFetchVerification, SolanaTx, SolanaSigner, Wallet, SolanaSwapData, SolanaSwapProgram, SolanaChainInterface, SolanaChainEventsBrowser, SolanaBtcRelay<any>, never, never, never>;

package/dist/solana/chain/SolanaChainInterface.d.ts

@@ -10,13 +10,14 @@ import { SolanaEvents } from "./modules/SolanaEvents";
 import { ChainInterface, TransactionConfirmationOptions } from "@atomiqlabs/base";
 import { SolanaSigner } from "../wallet/SolanaSigner";
 import { Buffer } from "buffer";
+import { Wallet } from "@coral-xyz/anchor/dist/cjs/provider";
 export type SolanaRetryPolicy = {
     maxRetries?: number;
     delay?: number;
     exponential?: boolean;
     transactionResendInterval?: number;
 };
-export declare class SolanaChainInterface implements ChainInterface<SolanaTx, SolanaSigner, "SOLANA"> {
+export declare class SolanaChainInterface implements ChainInterface<SolanaTx, SolanaSigner, "SOLANA", Wallet> {
     readonly chainId = "SOLANA";
     readonly SLOT_TIME = 400;
     readonly TX_SLOT_VALIDITY = 151;
@@ -38,6 +39,7 @@ export declare class SolanaChainInterface implements ChainInterface<SolanaTx, So
     constructor(connection: Connection, retryPolicy?: SolanaRetryPolicy, solanaFeeEstimator?: SolanaFees);
     getBalance(signer: string, tokenAddress: string): Promise<bigint>;
     isValidAddress(address: string): boolean;
+    normalizeAddress(address: string): string;
     getNativeCurrencyAddress(): string;
     txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<SolanaTx[]>;
     transfer(signer: SolanaSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
@@ -46,6 +48,10 @@ export declare class SolanaChainInterface implements ChainInterface<SolanaTx, So
     deserializeTx(txData: string): Promise<SolanaTx>;
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
     getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    getFinalizedBlock(): Promise<{
+        height: number;
+        blockHash: string;
+    }>;
     offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
     onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
     onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void;
@@ -55,4 +61,5 @@ export declare class SolanaChainInterface implements ChainInterface<SolanaTx, So
     isValidToken(tokenIdentifier: string): boolean;
     randomAddress(): string;
     randomSigner(): SolanaSigner;
+    wrapSigner(signer: Wallet): Promise<SolanaSigner>;
 }

package/dist/solana/chain/SolanaChainInterface.js

@@ -45,6 +45,9 @@ class SolanaChainInterface {
     isValidAddress(address) {
         return SolanaAddresses_1.SolanaAddresses.isValidAddress(address);
     }
+    normalizeAddress(address) {
+        return address;
+    }
     getNativeCurrencyAddress() {
         return this.Tokens.getNativeCurrencyAddress().toString();
     }
@@ -73,6 +76,13 @@ class SolanaChainInterface {
     getTxStatus(tx) {
         return this.Transactions.getTxStatus(tx);
     }
+    async getFinalizedBlock() {
+        const { block } = await this.Blocks.findLatestParsedBlock("finalized");
+        return {
+            height: block.blockHeight,
+            blockHash: block.blockhash
+        };
+    }
     ///////////////////////////////////
     //// Callbacks & handlers
     offBeforeTxReplace(callback) {
@@ -108,5 +118,8 @@ class SolanaChainInterface {
         const wallet = new SolanaKeypairWallet_1.SolanaKeypairWallet(keypair);
         return new SolanaSigner_1.SolanaSigner(wallet, keypair);
     }
+    wrapSigner(signer) {
+        return Promise.resolve(new SolanaSigner_1.SolanaSigner(signer));
+    }
 }
 exports.SolanaChainInterface = SolanaChainInterface;

package/dist/solana/chain/modules/SolanaEvents.d.ts

@@ -1,7 +1,8 @@
 import { SolanaModule } from "../SolanaModule";
-import { ConfirmedSignatureInfo, PublicKey } from "@solana/web3.js";
+import { ConfirmedSignatureInfo, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
 export declare class SolanaEvents extends SolanaModule {
     readonly LOG_FETCH_LIMIT = 500;
+    private usingHeliusTFA;
     /**
      * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
      *  the signatures before this signature
@@ -12,6 +13,43 @@ export declare class SolanaEvents extends SolanaModule {
      * @private
      */
     private getSignatures;
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    getTransactionsForAddress(account: PublicKey, options?: {
+        paginationToken?: string;
+        filters?: {
+            slot?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+            };
+            blockTime?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+                eq?: number;
+            };
+            signature?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+                eq?: number;
+            };
+            status?: "succeeded" | "failed" | "any";
+        };
+    }, commitment?: "finalized" | "confirmed" | "processed"): Promise<{
+        data: ParsedTransactionWithMeta[];
+        paginationToken?: string;
+    }>;
+    private _findInTxsTFA;
     /**
      * Runs a search backwards in time, processing transaction signatures for a specific topic public key
      *
@@ -20,6 +58,11 @@ export declare class SolanaEvents extends SolanaModule {
      *  was found, or null if the search should continue
      * @param abortSignal
      * @param logFetchLimit
+     * @param startBlockheight
      */
-    findInSignatures<T>(topicKey: PublicKey, processor: (signatures: ConfirmedSignatureInfo[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
+    private _findInSignatures;
+    findInSignatures<T>(topicKey: PublicKey, processor: (data: {
+        signatures?: ConfirmedSignatureInfo[];
+        txs?: ParsedTransactionWithMeta[];
+    }) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number, startBlockheight?: number): Promise<T>;
 }

package/dist/solana/chain/modules/SolanaEvents.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaEvents = void 0;
 const SolanaModule_1 = require("../SolanaModule");
+const web3_js_1 = require("@solana/web3.js");
 class SolanaEvents extends SolanaModule_1.SolanaModule {
     constructor() {
         super(...arguments);
         this.LOG_FETCH_LIMIT = 500;
+        this.usingHeliusTFA = "auto";
     }
     /**
      * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
@@ -29,6 +31,147 @@ class SolanaEvents extends SolanaModule_1.SolanaModule {
             }, "confirmed");
         }
     }
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    async getTransactionsForAddress(account, options, commitment) {
+        //Try to use getPriorityFeeEstimate api of Helius
+        const response = await this.connection._rpcRequest("getTransactionsForAddress", [
+            account.toString(),
+            {
+                ...options,
+                transactionDetails: "full",
+                sortOrder: "desc",
+                limit: 100,
+                commitment: commitment ?? "confirmed",
+                encoding: "jsonParsed",
+                maxSupportedTransactionVersion: 0
+            }
+        ]).catch(e => {
+            //Catching not supported errors
+            if (e.message != null && (e.message.includes("-32601") || e.message.includes("-32600"))) {
+                return {
+                    error: {
+                        code: -32601,
+                        message: e.message
+                    }
+                };
+            }
+            throw e;
+        });
+        if (response.error != null) {
+            //Catching not supported errors
+            if (response.error.code !== -32601 && response.error.code !== -32600)
+                throw new Error(response.error.message);
+            return null;
+        }
+        return {
+            data: response.result.data.map(val => {
+                return {
+                    ...val,
+                    meta: val.meta == null ? undefined : {
+                        //ParsedTransactionMeta
+                        ...val.meta,
+                        innerInstructions: val.meta.innerInstructions == null ? undefined : val.meta.innerInstructions.map(innerIx => ({
+                            //ParsedInnerInstruction
+                            ...innerIx,
+                            instructions: innerIx.instructions.map(ix => {
+                                if (ix.program != null && ix.programId != null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new web3_js_1.PublicKey(ix.programId)
+                                    };
+                                }
+                                else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new web3_js_1.PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new web3_js_1.PublicKey(pubkey))
+                                    };
+                                }
+                            })
+                        })),
+                        loadedAddresses: val.meta.loadedAddresses == null ? undefined : {
+                            writable: val.meta.loadedAddresses.writable.map(pubkey => new web3_js_1.PublicKey(pubkey)),
+                            readonly: val.meta.loadedAddresses.readonly.map(pubkey => new web3_js_1.PublicKey(pubkey)),
+                        }
+                    },
+                    transaction: {
+                        //ParsedTransaction
+                        ...val.transaction,
+                        message: {
+                            //ParsedMessage
+                            ...val.transaction.message,
+                            accountKeys: val.transaction.message.accountKeys.map(accountKey => ({
+                                //ParsedMessageAccount
+                                ...accountKey,
+                                pubkey: new web3_js_1.PublicKey(accountKey.pubkey)
+                            })),
+                            instructions: val.transaction.message.instructions.map(ix => {
+                                if (ix.program != null && ix.programId != null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new web3_js_1.PublicKey(ix.programId)
+                                    };
+                                }
+                                else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new web3_js_1.PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new web3_js_1.PublicKey(pubkey))
+                                    };
+                                }
+                            }),
+                            addressTableLookups: val.transaction.message.addressTableLookups == null ? undefined : val.transaction.message.addressTableLookups.map(addressTableLookup => ({
+                                //ParsedAddressTableLookup
+                                ...addressTableLookup,
+                                accountKey: new web3_js_1.PublicKey(addressTableLookup.accountKey)
+                            }))
+                        }
+                    }
+                };
+            }),
+            paginationToken: response.result.paginationToken
+        };
+    }
+    async _findInTxsTFA(topicKey, processor, abortSignal, startBlockheight) {
+        let paginationToken;
+        let txs = null;
+        while (txs == null || txs.length > 0) {
+            let filters = startBlockheight != null ? {
+                slot: { gte: startBlockheight }
+            } : {};
+            const tfaResult = await this.getTransactionsForAddress(topicKey, {
+                paginationToken,
+                filters: {
+                    ...filters,
+                    status: "succeeded"
+                }
+            }, "confirmed");
+            if (tfaResult == null) {
+                //Not supported
+                return undefined;
+            }
+            txs = tfaResult.data;
+            paginationToken = tfaResult.paginationToken;
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            const result = await processor({ txs });
+            if (result != null)
+                return result;
+            if (paginationToken == null)
+                break;
+        }
+        return null;
+    }
     /**
      * Runs a search backwards in time, processing transaction signatures for a specific topic public key
      *
@@ -37,16 +180,24 @@ class SolanaEvents extends SolanaModule_1.SolanaModule {
      *  was found, or null if the search should continue
      * @param abortSignal
      * @param logFetchLimit
+     * @param startBlockheight
      */
-    async findInSignatures(topicKey, processor, abortSignal, logFetchLimit) {
+    async _findInSignatures(topicKey, processor, abortSignal, logFetchLimit, startBlockheight) {
         if (logFetchLimit == null || logFetchLimit > this.LOG_FETCH_LIMIT)
             logFetchLimit = this.LOG_FETCH_LIMIT;
         let signatures = null;
         while (signatures == null || signatures.length > 0) {
             signatures = await this.getSignatures(topicKey, logFetchLimit, signatures != null ? signatures[signatures.length - 1].signature : null);
+            if (startBlockheight != null) {
+                const endIndex = signatures.findIndex(val => val.slot < startBlockheight);
+                if (endIndex === 0)
+                    return null;
+                if (endIndex !== -1)
+                    signatures = signatures.slice(0, endIndex - 1);
+            }
             if (abortSignal != null)
                 abortSignal.throwIfAborted();
-            const result = await processor(signatures);
+            const result = await processor({ signatures });
             if (result != null)
                 return result;
             if (signatures.length < logFetchLimit)
@@ -54,5 +205,19 @@ class SolanaEvents extends SolanaModule_1.SolanaModule {
         }
         return null;
     }
+    async findInSignatures(topicKey, processor, abortSignal, logFetchLimit, startBlockheight) {
+        if (this.usingHeliusTFA !== "no") {
+            //Attempt to use Helius's gTFA
+            const result = await this._findInTxsTFA(topicKey, processor, abortSignal, startBlockheight);
+            if (result !== undefined)
+                return result;
+            //Not supported
+            if (this.usingHeliusTFA === "yes")
+                throw new Error("Helius gTFA is not supported with current provider!");
+            //If set to auto, we can manually set to "no"
+            this.usingHeliusTFA = "no";
+        }
+        return await this._findInSignatures(topicKey, processor, abortSignal, logFetchLimit, startBlockheight);
+    }
 }
 exports.SolanaEvents = SolanaEvents;

package/dist/solana/chain/modules/SolanaTransactions.js

@@ -6,6 +6,7 @@ const SolanaModule_1 = require("../SolanaModule");
 const bs58 = require("bs58");
 const Utils_1 = require("../../../utils/Utils");
 const buffer_1 = require("buffer");
+const base_1 = require("@atomiqlabs/base");
 class SolanaTransactions extends SolanaModule_1.SolanaModule {
     /**
      * Sends raw solana transaction, first through the cbkSendTransaction callback (for e.g. sending the transaction
@@ -54,7 +55,7 @@ class SolanaTransactions extends SolanaModule_1.SolanaModule {
                     resolve(signature);
                 }
                 if (status === "reverted")
-                    reject(new Error("Transaction reverted!"));
+                    reject(new base_1.TransactionRevertedError("Transaction reverted!"));
                 clearInterval(watchdogInterval);
             }, this.retryPolicy?.transactionResendInterval || 3000);
             if (abortSignal != null)
@@ -95,7 +96,7 @@ class SolanaTransactions extends SolanaModule_1.SolanaModule {
             if (status === "success")
                 return signature;
             if (status === "reverted")
-                throw new Error("Transaction reverted!");
+                throw new base_1.TransactionRevertedError("Transaction reverted!");
             if (err instanceof web3_js_1.TransactionExpiredBlockheightExceededError || err.toString().startsWith("TransactionExpiredBlockheightExceededError")) {
                 throw new Error("Transaction expired before confirmation, please try again!");
             }
@@ -104,7 +105,7 @@ class SolanaTransactions extends SolanaModule_1.SolanaModule {
             }
         }
         if (result.value.err != null)
-            throw new Error("Transaction reverted!");
+            throw new base_1.TransactionRevertedError("Transaction reverted!");
         return signature;
     }
     /**
@@ -209,9 +210,10 @@ class SolanaTransactions extends SolanaModule_1.SolanaModule {
         };
         this.logger.debug("sendAndConfirm(): sending transactions, count: " + _txs.length +
             " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);
+        const BATCH_SIZE = 50;
         const signatures = [];
-        for (let e = 0; e < _txs.length; e += 50) {
-            const txs = _txs.slice(e, e + 50);
+        for (let e = 0; e < _txs.length; e += BATCH_SIZE) {
+            const txs = _txs.slice(e, e + BATCH_SIZE);
             await this.prepareTransactions(signer, txs);
             const signedTxs = await signer.wallet.signAllTransactions(txs.map(e => e.tx));
             signedTxs.forEach((tx, index) => {
@@ -220,27 +222,16 @@ class SolanaTransactions extends SolanaModule_1.SolanaModule {
                 solTx.tx = tx;
             });
             this.logger.debug("sendAndConfirm(): sending transaction batch (" + e + ".." + (e + 50) + "), count: " + txs.length);
-            if (parallel) {
-                const promises = [];
-                for (let solTx of txs) {
-                    const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
-                    if (waitForConfirmation)
-                        promises.push(this.confirmTransaction(solTx, abortSignal, "confirmed"));
-                    signatures.push(signature);
-                }
-                if (promises.length > 0)
-                    await Promise.all(promises);
-            }
-            else {
-                for (let i = 0; i < txs.length; i++) {
-                    const solTx = txs[i];
-                    const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
-                    const confirmPromise = this.confirmTransaction(solTx, abortSignal, "confirmed");
-                    //Don't await the last promise when !waitForConfirmation
-                    if (i < txs.length - 1 || e + 50 < _txs.length || waitForConfirmation)
-                        await confirmPromise;
-                    signatures.push(signature);
-                }
+            //For solana we are forced to send txs one-by-one even with parallel, as we cannot determine their order upfront,
+            // however e.g. Jito could possibly handle sending a single package of up to 5 txns in order.
+            for (let i = 0; i < txs.length; i++) {
+                const solTx = txs[i];
+                const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
+                const confirmPromise = this.confirmTransaction(solTx, abortSignal, "confirmed");
+                //Don't await the last promise when !waitForConfirmation
+                if (i < txs.length - 1 || e + 50 < _txs.length || waitForConfirmation)
+                    await confirmPromise;
+                signatures.push(signature);
             }
         }
         this.logger.info("sendAndConfirm(): sent transactions, count: " + _txs.length +

package/dist/solana/events/SolanaChainEventsBrowser.d.ts

@@ -3,7 +3,7 @@ import { SolanaSwapData } from "../swaps/SolanaSwapData";
 import { IdlEvents } from "@coral-xyz/anchor";
 import { SolanaSwapProgram } from "../swaps/SolanaSwapProgram";
 import { Connection } from "@solana/web3.js";
-import { InstructionWithAccounts, ProgramEvent, SingleInstructionWithAccounts } from "../program/modules/SolanaProgramEvents";
+import { InstructionWithAccounts, ProgramEvent } from "../program/modules/SolanaProgramEvents";
 import { SwapProgram } from "../swaps/programTypes";
 export type EventObject = {
     events: ProgramEvent<SwapProgram>[];
@@ -11,7 +11,6 @@ export type EventObject = {
     blockTime: number;
     signature: string;
 };
-export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3], SwapProgram>;
 /**
  * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
  *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
@@ -36,15 +35,6 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      * @returns {Promise<InstructionWithAccounts<SwapProgram>[]>} array of parsed instructions
      */
     private getTransactionInstructions;
-    /**
-     * Converts initialize instruction data into {SolanaSwapData}
-     *
-     * @param initIx
-     * @param txoHash
-     * @private
-     * @returns {SolanaSwapData} converted and parsed swap data
-     */
-    private instructionToSwapData;
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *

package/dist/solana/events/SolanaChainEventsBrowser.js

@@ -4,8 +4,6 @@ exports.SolanaChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
 const SolanaSwapData_1 = require("../swaps/SolanaSwapData");
 const Utils_1 = require("../../utils/Utils");
-const web3_js_1 = require("@solana/web3.js");
-const BN = require("bn.js");
 const SwapTypeEnum_1 = require("../swaps/SwapTypeEnum");
 const buffer_1 = require("buffer");
 /**
@@ -43,26 +41,6 @@ class SolanaChainEventsBrowser {
             return null;
         return this.solanaSwapProgram.Events.decodeInstructions(transaction.transaction.message);
     }
-    /**
-     * Converts initialize instruction data into {SolanaSwapData}
-     *
-     * @param initIx
-     * @param txoHash
-     * @private
-     * @returns {SolanaSwapData} converted and parsed swap data
-     */
-    instructionToSwapData(initIx, txoHash) {
-        const paymentHash = buffer_1.Buffer.from(initIx.data.swapData.hash);
-        let securityDeposit = new BN(0);
-        let claimerBounty = new BN(0);
-        let payIn = true;
-        if (initIx.name === "offererInitialize") {
-            payIn = false;
-            securityDeposit = initIx.data.securityDeposit;
-            claimerBounty = initIx.data.claimerBounty;
-        }
-        return new SolanaSwapData_1.SolanaSwapData(initIx.accounts.offerer, initIx.accounts.claimer, initIx.accounts.mint, initIx.data.swapData.amount, paymentHash.toString("hex"), initIx.data.swapData.sequence, initIx.data.swapData.expiry, initIx.data.swapData.nonce, initIx.data.swapData.confirmations, initIx.data.swapData.payOut, SwapTypeEnum_1.SwapTypeEnum.toNumber(initIx.data.swapData.kind), payIn, initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : web3_js_1.PublicKey.default, initIx.data.swapData.payOut ? initIx.accounts.claimerAta : web3_js_1.PublicKey.default, securityDeposit, claimerBounty, txoHash);
-    }
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *
@@ -80,7 +58,7 @@ class SolanaChainEventsBrowser {
             const initIx = eventObject.instructions.find(ix => ix != null && (ix.name === "offererInitializePayIn" || ix.name === "offererInitialize"));
             if (initIx == null)
                 return null;
-            return this.instructionToSwapData(initIx, txoHash);
+            return SolanaSwapData_1.SolanaSwapData.fromInstruction(initIx, txoHash);
         };
     }
     parseInitializeEvent(data, eventObject) {

package/dist/solana/program/modules/SolanaProgramEvents.d.ts

@@ -1,7 +1,7 @@
 import { SolanaEvents } from "../../chain/modules/SolanaEvents";
 import { DecodeType, Event, Idl, IdlTypes } from "@coral-xyz/anchor";
 import { IdlField, IdlInstruction } from "@coral-xyz/anchor/dist/cjs/idl";
-import { ConfirmedSignatureInfo, ParsedMessage, PublicKey } from "@solana/web3.js";
+import { ParsedMessage, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
 import { SolanaProgramBase } from "../SolanaProgramBase";
 import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
 type DecodedFieldOrNull<D, Defined> = D extends IdlField ? DecodeType<D["type"], Defined> : unknown;
@@ -25,13 +25,6 @@ export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
     private readonly program;
     private readonly nameMappedInstructions;
     constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>);
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    private getEvents;
     /**
      * Runs a search backwards in time, processing the events for a specific topic public key
      *
@@ -40,8 +33,9 @@ export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
      *  if the search should continue
      * @param abortSignal
      * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
+     * @param startBlockheight
      */
-    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>, abortSignal?: AbortSignal, logBatchSize?: number): Promise<T>;
+    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, tx: ParsedTransactionWithMeta) => Promise<T>, abortSignal?: AbortSignal, logBatchSize?: number, startBlockheight?: number): Promise<T>;
     /**
      * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array
      *  for every instruction that doesn't correspond to this program (as those are impossible to parse)

package/dist/solana/program/modules/SolanaProgramEvents.js

@@ -14,23 +14,6 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
             this.nameMappedInstructions[ix.name] = ix;
         }
     }
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    async getEvents(signature) {
-        const tx = await this.connection.getTransaction(signature, {
-            commitment: "confirmed",
-            maxSupportedTransactionVersion: 0
-        });
-        if (tx.meta.err)
-            return [];
-        const events = this.parseLogs(tx.meta.logMessages);
-        events.reverse();
-        return events;
-    }
     /**
      * Runs a search backwards in time, processing the events for a specific topic public key
      *
@@ -39,19 +22,47 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
      *  if the search should continue
      * @param abortSignal
      * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
+     * @param startBlockheight
      */
-    findInEvents(topicKey, processor, abortSignal, logBatchSize) {
-        return this.findInSignatures(topicKey, async (signatures) => {
-            for (let data of signatures) {
-                for (let event of await this.getEvents(data.signature)) {
-                    if (abortSignal != null)
-                        abortSignal.throwIfAborted();
-                    const result = await processor(event, data);
-                    if (result != null)
-                        return result;
+    findInEvents(topicKey, processor, abortSignal, logBatchSize, startBlockheight) {
+        return this.findInSignatures(topicKey, async (data) => {
+            if (data.signatures) {
+                for (let info of data.signatures) {
+                    if (info.err == null)
+                        continue;
+                    const tx = await this.connection.getParsedTransaction(info.signature, {
+                        commitment: "confirmed",
+                        maxSupportedTransactionVersion: 0
+                    });
+                    if (tx.meta.err)
+                        continue;
+                    const events = this.parseLogs(tx.meta.logMessages);
+                    events.reverse();
+                    for (let event of events) {
+                        if (abortSignal != null)
+                            abortSignal.throwIfAborted();
+                        const result = await processor(event, tx);
+                        if (result != null)
+                            return result;
+                    }
+                }
+            }
+            else {
+                for (let tx of data.txs) {
+                    if (tx.meta.err)
+                        continue;
+                    const events = this.parseLogs(tx.meta.logMessages);
+                    events.reverse();
+                    for (let event of events) {
+                        if (abortSignal != null)
+                            abortSignal.throwIfAborted();
+                        const result = await processor(event, tx);
+                        if (result != null)
+                            return result;
+                    }
                 }
             }
-        }, abortSignal, logBatchSize);
+        }, abortSignal, logBatchSize, startBlockheight);
     }
     /**
      * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array