@atomiqlabs/chain-solana 13.0.9 → 13.0.11

package/dist/solana/btcrelay/SolanaBtcRelay.d.ts

@@ -76,7 +76,7 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
      */
     private _saveHeaders;
     /**
-     * Returns data about current main chain tip stored in the btc relay
+     * @inheritDoc
      */
     getTipData(): Promise<{
         commitHash: string;
@@ -85,11 +85,7 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
         blockheight: number;
     } | null>;
     /**
-     * Retrieves blockheader with a specific blockhash, returns null if requiredBlockheight is provided and
-     *  btc relay contract is not synced up to the desired blockheight
-     *
-     * @param blockData
-     * @param requiredBlockheight
+     * @inheritDoc
      */
     retrieveLogAndBlockheight(blockData: {
         blockhash: string;
@@ -98,41 +94,27 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
         height: number;
     } | null>;
     /**
-     * Retrieves blockheader data by blockheader's commit hash,
-     *
-     * @param commitmentHashStr
-     * @param blockData
+     * @inheritDoc
      */
     retrieveLogByCommitHash(commitmentHashStr: string, blockData: {
         blockhash: string;
     }): Promise<SolanaBtcStoredHeader | null>;
     /**
-     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     * @inheritDoc
      */
     retrieveLatestKnownBlockLog(): Promise<{
         resultStoredHeader: SolanaBtcStoredHeader;
         resultBitcoinHeader: B;
     } | null>;
     /**
-     * Saves initial block header when the btc relay is in uninitialized state
-     *
-     * @param signer
-     * @param header a bitcoin blockheader to submit
-     * @param epochStart timestamp of the start of the epoch (block timestamp at blockheight-(blockheight%2016))
-     * @param pastBlocksTimestamps timestamp of the past 10 blocks
-     * @param feeRate fee rate to use for the transaction
+     * @inheritDoc
      */
     saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<{
         tx: Transaction;
         signers: Signer[];
     }>;
     /**
-     * Saves blockheaders as a bitcoin main chain to the btc relay
-     *
-     * @param signer
-     * @param mainHeaders
-     * @param storedHeader
-     * @param feeRate
+     * @inheritDoc
      */
     saveMainHeaders(signer: string, mainHeaders: BtcBlock[], storedHeader: SolanaBtcStoredHeader, feeRate?: string): Promise<{
         forkId: number;
@@ -144,13 +126,7 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
         computedCommitedHeaders: SolanaBtcStoredHeader[];
     }>;
     /**
-     * Creates a new long fork and submits the headers to it
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     saveNewForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: SolanaBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
         forkId: number;
@@ -162,14 +138,7 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
         computedCommitedHeaders: SolanaBtcStoredHeader[];
     }>;
     /**
-     * Continues submitting blockheaders to a given fork
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param forkId
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     saveForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: SolanaBtcStoredHeader, forkId: number, tipWork: Buffer, feeRate?: string): Promise<{
         forkId: number;
@@ -181,13 +150,7 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
         computedCommitedHeaders: SolanaBtcStoredHeader[];
     }>;
     /**
-     * Submits short fork with given blockheaders
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     saveShortForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: SolanaBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
         forkId: number;
@@ -199,32 +162,23 @@ export declare class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBas
         computedCommitedHeaders: SolanaBtcStoredHeader[];
     }>;
     /**
-     * Sweeps fork data PDAs back to self
-     *
-     * @param signer
-     * @param lastSweepId lastCheckedId returned from the previous sweepForkData() call
-     * @returns {number} lastCheckedId that should be passed to the next call of sweepForkData()
+     * @inheritDoc
      */
     sweepForkData(signer: SolanaSigner, lastSweepId?: number): Promise<number | null>;
     /**
-     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
-     *
-     * @param requiredBlockheight
-     * @param feeRate
+     * @inheritDoc
      */
     estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
     /**
-     * Returns fee required (in SOL) to synchronize a single block to btc relay
-     *
-     * @param feeRate
+     * @inheritDoc
      */
     getFeePerBlock(feeRate?: string): Promise<bigint>;
     /**
-     * Gets fee rate required for submitting blockheaders to the main chain
+     * @inheritDoc
      */
     getMainFeeRate(signer: string | null): Promise<string>;
     /**
-     * Gets fee rate required for submitting blockheaders to the specific fork
+     * @inheritDoc
      */
     getForkFeeRate(signer: string, forkId: number): Promise<string>;
 }

package/dist/solana/btcrelay/SolanaBtcRelay.js

@@ -155,7 +155,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         };
     }
     /**
-     * Returns data about current main chain tip stored in the btc relay
+     * @inheritDoc
      */
     async getTipData() {
         const data = await this.program.account.mainState.fetchNullable(this.BtcRelayMainState);
@@ -169,11 +169,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         };
     }
     /**
-     * Retrieves blockheader with a specific blockhash, returns null if requiredBlockheight is provided and
-     *  btc relay contract is not synced up to the desired blockheight
-     *
-     * @param blockData
-     * @param requiredBlockheight
+     * @inheritDoc
      */
     async retrieveLogAndBlockheight(blockData, requiredBlockheight) {
         const mainState = await this.program.account.mainState.fetch(this.BtcRelayMainState);
@@ -201,10 +197,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return data;
     }
     /**
-     * Retrieves blockheader data by blockheader's commit hash,
-     *
-     * @param commitmentHashStr
-     * @param blockData
+     * @inheritDoc
      */
     async retrieveLogByCommitHash(commitmentHashStr, blockData) {
         const blockHashBuffer = buffer_1.Buffer.from(blockData.blockhash, "hex").reverse();
@@ -223,7 +216,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return data;
     }
     /**
-     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     * @inheritDoc
      */
     async retrieveLatestKnownBlockLog() {
         const mainState = await this.program.account.mainState.fetch(this.BtcRelayMainState);
@@ -254,13 +247,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return data;
     }
     /**
-     * Saves initial block header when the btc relay is in uninitialized state
-     *
-     * @param signer
-     * @param header a bitcoin blockheader to submit
-     * @param epochStart timestamp of the start of the epoch (block timestamp at blockheight-(blockheight%2016))
-     * @param pastBlocksTimestamps timestamp of the past 10 blocks
-     * @param feeRate fee rate to use for the transaction
+     * @inheritDoc
      */
     async saveInitialHeader(signer, header, epochStart, pastBlocksTimestamps, feeRate) {
         if (pastBlocksTimestamps.length !== 10)
@@ -271,12 +258,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return await action.tx(feeRate);
     }
     /**
-     * Saves blockheaders as a bitcoin main chain to the btc relay
-     *
-     * @param signer
-     * @param mainHeaders
-     * @param storedHeader
-     * @param feeRate
+     * @inheritDoc
      */
     async saveMainHeaders(signer, mainHeaders, storedHeader, feeRate) {
         feeRate ?? (feeRate = await this.getMainFeeRate(signer));
@@ -290,13 +272,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         }));
     }
     /**
-     * Creates a new long fork and submits the headers to it
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     async saveNewForkHeaders(signer, forkHeaders, storedHeader, tipWork, feeRate) {
         const mainState = await this.program.account.mainState.fetch(this.BtcRelayMainState);
@@ -320,14 +296,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return result;
     }
     /**
-     * Continues submitting blockheaders to a given fork
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param forkId
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     async saveForkHeaders(signer, forkHeaders, storedHeader, forkId, tipWork, feeRate) {
         feeRate ?? (feeRate = await this.getForkFeeRate(signer, forkId));
@@ -349,13 +318,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return result;
     }
     /**
-     * Submits short fork with given blockheaders
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     async saveShortForkHeaders(signer, forkHeaders, storedHeader, tipWork, feeRate) {
         feeRate ?? (feeRate = await this.getMainFeeRate(signer));
@@ -375,11 +338,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return result;
     }
     /**
-     * Sweeps fork data PDAs back to self
-     *
-     * @param signer
-     * @param lastSweepId lastCheckedId returned from the previous sweepForkData() call
-     * @returns {number} lastCheckedId that should be passed to the next call of sweepForkData()
+     * @inheritDoc
      */
     async sweepForkData(signer, lastSweepId) {
         const mainState = await this.program.account.mainState.fetch(this.BtcRelayMainState);
@@ -410,10 +369,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return lastCheckedId ?? null;
     }
     /**
-     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
-     *
-     * @param requiredBlockheight
-     * @param feeRate
+     * @inheritDoc
      */
     async estimateSynchronizeFee(requiredBlockheight, feeRate) {
         const tipData = await this.getTipData();
@@ -429,9 +385,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return synchronizationFee;
     }
     /**
-     * Returns fee required (in SOL) to synchronize a single block to btc relay
-     *
-     * @param feeRate
+     * @inheritDoc
      */
     async getFeePerBlock(feeRate) {
         // feeRate = feeRate || await this.getMainFeeRate(null);
@@ -439,7 +393,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         return 50000n;
     }
     /**
-     * Gets fee rate required for submitting blockheaders to the main chain
+     * @inheritDoc
      */
     getMainFeeRate(signer) {
         const _signer = signer == null ? null : new web3_js_1.PublicKey(signer);
@@ -449,7 +403,7 @@ class SolanaBtcRelay extends SolanaProgramBase_1.SolanaProgramBase {
         ]);
     }
     /**
-     * Gets fee rate required for submitting blockheaders to the specific fork
+     * @inheritDoc
      */
     getForkFeeRate(signer, forkId) {
         const _signer = new web3_js_1.PublicKey(signer);

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

@@ -46,32 +46,101 @@ export declare class SolanaChainInterface implements ChainInterface<SolanaTx, Si
         error: (msg: string, ...args: any[]) => false | void;
     };
     constructor(connection: Connection, retryPolicy?: SolanaRetryPolicy, solanaFeeEstimator?: SolanaFees);
+    /**
+     * @inheritDoc
+     */
     getBalance(signer: string, tokenAddress: string): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     isValidAddress(address: string): boolean;
+    /**
+     * @inheritDoc
+     */
     normalizeAddress(address: string): string;
+    /**
+     * @inheritDoc
+     */
     getNativeCurrencyAddress(): string;
+    /**
+     * @inheritDoc
+     */
     txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<SolanaTx[]>;
+    /**
+     * @inheritDoc
+     */
     transfer(signer: SolanaSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     sendAndConfirm(signer: SolanaSigner, txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
     sendSignedAndConfirm(txs: SignedSolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
     serializeTx(tx: SolanaTx): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     deserializeTx(txData: string): Promise<SolanaTx>;
+    /**
+     * @inheritDoc
+     */
     serializeSignedTx(tx: Transaction): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     deserializeSignedTx(txData: string): Promise<Transaction>;
+    /**
+     * @inheritDoc
+     */
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    /**
+     * @inheritDoc
+     */
     getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    /**
+     * @inheritDoc
+     */
     getFinalizedBlock(): Promise<{
         height: number;
         blockHash: string;
     }>;
+    /**
+     * @inheritDoc
+     */
     offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
+    /**
+     * @inheritDoc
+     */
     onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
+    /**
+     * @inheritDoc
+     */
     onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void;
+    /**
+     * @inheritDoc
+     */
     offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean;
     onSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): void;
     offSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): boolean;
+    /**
+     * @inheritDoc
+     */
     isValidToken(tokenIdentifier: string): boolean;
+    /**
+     * @inheritDoc
+     */
     randomAddress(): string;
+    /**
+     * @inheritDoc
+     */
     randomSigner(): SolanaSigner;
+    /**
+     * @inheritDoc
+     */
     wrapSigner(signer: Wallet): Promise<SolanaSigner>;
 }

package/dist/solana/chain/SolanaChainInterface.js

@@ -33,6 +33,9 @@ class SolanaChainInterface {
         this.Signatures = new SolanaSignatures_1.SolanaSignatures(this);
         this.Events = new SolanaEvents_1.SolanaEvents(this);
     }
+    /**
+     * @inheritDoc
+     */
     async getBalance(signer, tokenAddress) {
         const token = new web3_js_1.PublicKey(tokenAddress);
         const publicKey = new web3_js_1.PublicKey(signer);
@@ -46,18 +49,33 @@ class SolanaChainInterface {
         this.logger.debug("getBalance(): token balance, token: " + token.toBase58() + " balance: " + balance.toString(10));
         return balance;
     }
+    /**
+     * @inheritDoc
+     */
     isValidAddress(address) {
         return SolanaAddresses_1.SolanaAddresses.isValidAddress(address);
     }
+    /**
+     * @inheritDoc
+     */
     normalizeAddress(address) {
         return address;
     }
+    /**
+     * @inheritDoc
+     */
     getNativeCurrencyAddress() {
         return this.Tokens.getNativeCurrencyAddress().toString();
     }
+    /**
+     * @inheritDoc
+     */
     txsTransfer(signer, token, amount, dstAddress, feeRate) {
         return this.Tokens.txsTransfer(new web3_js_1.PublicKey(signer), new web3_js_1.PublicKey(token), amount, new web3_js_1.PublicKey(dstAddress), feeRate);
     }
+    /**
+     * @inheritDoc
+     */
     async transfer(signer, token, amount, dstAddress, txOptions) {
         const txs = await this.Tokens.txsTransfer(signer.getPublicKey(), new web3_js_1.PublicKey(token), amount, new web3_js_1.PublicKey(dstAddress), txOptions?.feeRate);
         const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
@@ -65,30 +83,57 @@ class SolanaChainInterface {
     }
     ////////////////////////////////////////////
     //// Transactions
+    /**
+     * @inheritDoc
+     */
     sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
+    /**
+     * @inheritDoc
+     */
     sendSignedAndConfirm(txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         return this.Transactions.sendSignedAndConfirm(txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
+    /**
+     * @inheritDoc
+     */
     serializeTx(tx) {
         return Promise.resolve(this.Transactions.serializeUnsignedTx(tx));
     }
+    /**
+     * @inheritDoc
+     */
     deserializeTx(txData) {
         return Promise.resolve(this.Transactions.deserializeUnsignedTx(txData));
     }
+    /**
+     * @inheritDoc
+     */
     serializeSignedTx(tx) {
         return Promise.resolve(this.Transactions.serializeSignedTx(tx));
     }
+    /**
+     * @inheritDoc
+     */
     deserializeSignedTx(txData) {
         return Promise.resolve(this.Transactions.deserializeSignedTransaction(txData));
     }
+    /**
+     * @inheritDoc
+     */
     getTxIdStatus(txId) {
         return this.Transactions.getTxIdStatus(txId);
     }
+    /**
+     * @inheritDoc
+     */
     getTxStatus(tx) {
         return this.Transactions.getTxStatus(tx);
     }
+    /**
+     * @inheritDoc
+     */
     async getFinalizedBlock() {
         const { block } = await this.Blocks.findLatestParsedBlock("finalized");
         return {
@@ -98,13 +143,25 @@ class SolanaChainInterface {
     }
     ///////////////////////////////////
     //// Callbacks & handlers
+    /**
+     * @inheritDoc
+     */
     offBeforeTxReplace(callback) {
         return true;
     }
+    /**
+     * @inheritDoc
+     */
     onBeforeTxReplace(callback) { }
+    /**
+     * @inheritDoc
+     */
     onBeforeTxSigned(callback) {
         this.Transactions.onBeforeTxSigned(callback);
     }
+    /**
+     * @inheritDoc
+     */
     offBeforeTxSigned(callback) {
         return this.Transactions.offBeforeTxSigned(callback);
     }
@@ -114,6 +171,9 @@ class SolanaChainInterface {
     offSendTransaction(callback) {
         return this.Transactions.offSendTransaction(callback);
     }
+    /**
+     * @inheritDoc
+     */
     isValidToken(tokenIdentifier) {
         try {
             new web3_js_1.PublicKey(tokenIdentifier);
@@ -123,14 +183,23 @@ class SolanaChainInterface {
             return false;
         }
     }
+    /**
+     * @inheritDoc
+     */
     randomAddress() {
         return web3_js_1.Keypair.generate().publicKey.toString();
     }
+    /**
+     * @inheritDoc
+     */
     randomSigner() {
         const keypair = web3_js_1.Keypair.generate();
         const wallet = new SolanaKeypairWallet_1.SolanaKeypairWallet(keypair);
         return new SolanaSigner_1.SolanaSigner(wallet, keypair);
     }
+    /**
+     * @inheritDoc
+     */
     wrapSigner(signer) {
         return Promise.resolve(new SolanaSigner_1.SolanaSigner(signer));
     }

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

@@ -24,10 +24,9 @@ class SolanaBlocks extends SolanaModule_1.SolanaModule {
             return val;
         });
         this.blockCache.set(slot, blockCacheData);
-        blockCacheData.catch(e => {
+        blockCacheData.catch(() => {
             if (this.blockCache.get(slot) == blockCacheData)
                 this.blockCache.delete(slot);
-            throw e;
         });
         return blockCacheData;
     }
@@ -43,7 +42,10 @@ class SolanaBlocks extends SolanaModule_1.SolanaModule {
         let slot = await this.root.Slots.getSlot(commitment);
         for (let i = 0; i < 10; i++) {
             const block = await this.getParsedBlock(slot).catch(e => {
-                if (e.toString().startsWith("SolanaJSONRPCError: failed to get block: Block not available for slot")) {
+                const errorStr = e.toString();
+                if (errorStr.startsWith("SolanaJSONRPCError: failed to get block:") && (errorStr.includes("Block not available for slot") ||
+                    errorStr.includes("was skipped") ||
+                    errorStr.includes("missing in long-term storage"))) {
                     return null;
                 }
                 throw e;

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

@@ -22,11 +22,10 @@ class SolanaSlots extends SolanaModule_1.SolanaModule {
             slot: slotPromise,
             timestamp
         };
-        slotPromise.catch(e => {
+        slotPromise.catch(() => {
             const slotCache = this.slotCache[commitment];
             if (slotCache != null && slotCache.slot === slotPromise)
                 delete this.slotCache[commitment];
-            throw e;
         });
         return {
             slot: slotPromise,

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

@@ -116,13 +116,23 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      */
     private processSignatures;
     /**
-     * Polls for new events & processes them
-     *
-     * @private
+     * @inheritDoc
      */
     poll(lastSignature?: SolanaEventListenerState): Promise<SolanaEventListenerState | null>;
+    /**
+     * @inheritDoc
+     */
     init(noAutomaticPoll?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     stop(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     registerListener(cbk: EventListener<SolanaSwapData>): void;
+    /**
+     * @inheritDoc
+     */
     unregisterListener(cbk: EventListener<SolanaSwapData>): boolean;
 }

package/dist/solana/events/SolanaChainEventsBrowser.js

@@ -297,9 +297,7 @@ class SolanaChainEventsBrowser {
         return lastSuccessfulSignature;
     }
     /**
-     * Polls for new events & processes them
-     *
-     * @private
+     * @inheritDoc
      */
     async poll(lastSignature) {
         let signatures = lastSignature == null
@@ -310,21 +308,33 @@ class SolanaChainEventsBrowser {
         let lastSuccessfulSignature = await this.processSignatures(signatures);
         return lastSuccessfulSignature ?? lastSignature ?? null;
     }
+    /**
+     * @inheritDoc
+     */
     init(noAutomaticPoll) {
         if (noAutomaticPoll)
             return Promise.resolve();
         this.setupWebsocket();
         return Promise.resolve();
     }
+    /**
+     * @inheritDoc
+     */
     async stop() {
         for (let num of this.eventListeners) {
             await this.solanaSwapProgram.program.removeEventListener(num);
         }
         this.eventListeners = [];
     }
+    /**
+     * @inheritDoc
+     */
     registerListener(cbk) {
         this.listeners.push(cbk);
     }
+    /**
+     * @inheritDoc
+     */
     unregisterListener(cbk) {
         const index = this.listeners.indexOf(cbk);
         if (index >= 0) {