@atomiqlabs/chain-solana 11.0.0 → 12.0.6

package/src/solana/chain/modules/SolanaEvents.ts

@@ -1,10 +1,14 @@
 import {SolanaModule} from "../SolanaModule";
-import {ConfirmedSignatureInfo, PublicKey} from "@solana/web3.js";
+import {ConfirmedSignatureInfo, ParsedTransactionWithMeta, PublicKey} from "@solana/web3.js";
+import {sign} from "tweetnacl";
+import {ProgramEvent} from "../../program/modules/SolanaProgramEvents";
 
 export class SolanaEvents extends SolanaModule {
 
     public readonly LOG_FETCH_LIMIT = 500;
 
+    private usingHeliusTFA: "yes" | "no" | "auto" = "auto";
+
     /**
      * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
      *  the signatures before this signature
@@ -27,6 +31,169 @@ export class SolanaEvents extends SolanaModule {
         }
     }
 
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    async 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
+    }> {
+        //Try to use getPriorityFeeEstimate api of Helius
+        const response = await (this.connection as any)._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, //slot, blockTime, version
+                    meta: val.meta==null ? undefined : {
+                        //ParsedTransactionMeta
+                        ...val.meta,
+                        innerInstructions: val.meta.innerInstructions==null ? undefined : val.meta.innerInstructions.map(innerIx => ({
+                            //ParsedInnerInstruction
+                            ...innerIx, //index
+                            instructions: innerIx.instructions.map(ix => {
+                                if(ix.program!=null && ix.programId!=null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new PublicKey(ix.programId)
+                                    }
+                                } else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new PublicKey(pubkey))
+                                    }
+                                }
+                            })
+                        })),
+                        loadedAddresses: val.meta.loadedAddresses==null ? undefined : {
+                            writable: val.meta.loadedAddresses.writable.map(pubkey => new PublicKey(pubkey)),
+                            readonly: val.meta.loadedAddresses.readonly.map(pubkey => new PublicKey(pubkey)),
+                        }
+                    },
+                    transaction: {
+                        //ParsedTransaction
+                        ...val.transaction, //signatures
+                        message: {
+                            //ParsedMessage
+                            ...val.transaction.message, //recentBlockhash
+                            accountKeys: val.transaction.message.accountKeys.map(accountKey => ({
+                                //ParsedMessageAccount
+                                ...accountKey,
+                                pubkey: new PublicKey(accountKey.pubkey)
+                            })),
+                            instructions: val.transaction.message.instructions.map(ix => {
+                                if(ix.program!=null && ix.programId!=null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new PublicKey(ix.programId)
+                                    }
+                                } else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new PublicKey(pubkey))
+                                    }
+                                }
+                            }),
+                            addressTableLookups: val.transaction.message.addressTableLookups==null ? undefined : val.transaction.message.addressTableLookups.map(addressTableLookup => ({
+                                //ParsedAddressTableLookup
+                                ...addressTableLookup,
+                                accountKey: new PublicKey(addressTableLookup.accountKey)
+                            }))
+                        }
+                    }
+                }
+            }),
+            paginationToken: response.result.paginationToken
+        };
+    }
+
+    private async _findInTxsTFA<T>(
+      topicKey: PublicKey,
+      processor: (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => Promise<T>,
+      abortSignal?: AbortSignal,
+      startBlockheight?: number
+    ): Promise<T> {
+        let paginationToken: string;
+        let txs: ParsedTransactionWithMeta[] = 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: T = 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
      *
@@ -35,23 +202,50 @@ export class SolanaEvents extends SolanaModule {
      *  was found, or null if the search should continue
      * @param abortSignal
      * @param logFetchLimit
+     * @param startBlockheight
      */
-    public async findInSignatures<T>(
+    private async _findInSignatures<T>(
         topicKey: PublicKey,
-        processor: (signatures: ConfirmedSignatureInfo[]) => Promise<T>,
+        processor: (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => Promise<T>,
         abortSignal?: AbortSignal,
-        logFetchLimit?: number
+        logFetchLimit?: number,
+        startBlockheight?: number
     ): Promise<T> {
         if(logFetchLimit==null || logFetchLimit>this.LOG_FETCH_LIMIT) logFetchLimit = this.LOG_FETCH_LIMIT;
         let signatures: ConfirmedSignatureInfo[] = 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: T = await processor(signatures);
+            const result: T = await processor({signatures});
             if(result!=null) return result;
             if(signatures.length<logFetchLimit) break;
         }
         return null;
     }
 
+    public async findInSignatures<T>(
+        topicKey: PublicKey,
+        processor: (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => Promise<T>,
+        abortSignal?: AbortSignal,
+        logFetchLimit?: number,
+        startBlockheight?: number
+    ) {
+        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);
+    }
+
 }

package/src/solana/chain/modules/SolanaTransactions.ts

@@ -9,6 +9,7 @@ import * as bs58 from "bs58";
 import {tryWithRetries} from "../../../utils/Utils";
 import {Buffer} from "buffer";
 import {SolanaSigner} from "../../wallet/SolanaSigner";
+import {TransactionRevertedError} from "@atomiqlabs/base";
 
 export type SolanaTx = {tx: Transaction, signers: Signer[]};
 
@@ -74,7 +75,7 @@ export class SolanaTransactions extends SolanaModule {
                     this.logger.info("txConfirmationAndResendWatchdog(): transaction confirmed from HTTP polling, signature: "+signature);
                     resolve(signature);
                 }
-                if(status==="reverted") reject(new Error("Transaction reverted!"));
+                if(status==="reverted") reject(new TransactionRevertedError("Transaction reverted!"));
                 clearInterval(watchdogInterval);
             }, this.retryPolicy?.transactionResendInterval || 3000);
 
@@ -119,14 +120,14 @@ export class SolanaTransactions extends SolanaModule {
             );
             this.logger.info("txConfirmFromWebsocket(): transaction status: "+status+" signature: "+signature);
             if(status==="success") return signature;
-            if(status==="reverted") throw new Error("Transaction reverted!");
+            if(status==="reverted") throw new TransactionRevertedError("Transaction reverted!");
             if(err instanceof TransactionExpiredBlockheightExceededError || err.toString().startsWith("TransactionExpiredBlockheightExceededError")) {
                 throw new Error("Transaction expired before confirmation, please try again!");
             } else {
                 throw err;
             }
         }
-        if(result.value.err!=null) throw new Error("Transaction reverted!");
+        if(result.value.err!=null) throw new TransactionRevertedError("Transaction reverted!");
         return signature;
     }
 
@@ -239,9 +240,11 @@ export class SolanaTransactions extends SolanaModule {
         this.logger.debug("sendAndConfirm(): sending transactions, count: "+_txs.length+
             " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
 
+        const BATCH_SIZE = 50;
+
         const signatures: string[] = [];
-        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));
@@ -252,23 +255,15 @@ export class SolanaTransactions extends SolanaModule {
             });
             this.logger.debug("sendAndConfirm(): sending transaction batch ("+e+".."+(e+50)+"), count: "+txs.length);
 
-            if(parallel) {
-                const promises: Promise<void>[] = [];
-                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);
             }
         }
 

package/src/solana/events/SolanaChainEventsBrowser.ts

@@ -1,18 +1,16 @@
 import {ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SwapEvent} from "@atomiqlabs/base";
-import {SolanaSwapData} from "../swaps/SolanaSwapData";
+import {InitInstruction, SolanaSwapData} from "../swaps/SolanaSwapData";
 import {IdlEvents} from "@coral-xyz/anchor";
 import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
 import {
     getLogger,
     onceAsync, toEscrowHash, tryWithRetries
 } from "../../utils/Utils";
-import {Connection, ParsedTransactionWithMeta, PublicKey} from "@solana/web3.js";
-import * as BN from "bn.js";
+import {Connection, ParsedTransactionWithMeta} from "@solana/web3.js";
 import {SwapTypeEnum} from "../swaps/SwapTypeEnum";
 import {
     InstructionWithAccounts,
-    ProgramEvent,
-    SingleInstructionWithAccounts
+    ProgramEvent
 } from "../program/modules/SolanaProgramEvents";
 import {SwapProgram} from "../swaps/programTypes";
 import {Buffer} from "buffer";
@@ -24,8 +22,6 @@ export type EventObject = {
     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
@@ -64,49 +60,6 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
         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
-     */
-    private instructionToSwapData(
-        initIx: InitInstruction,
-        txoHash: string
-    ): SolanaSwapData {
-        const paymentHash: Buffer = Buffer.from(initIx.data.swapData.hash);
-        let securityDeposit: BN = new BN(0);
-        let claimerBounty: BN = new BN(0);
-        let payIn: boolean = true;
-        if(initIx.name === "offererInitialize") {
-            payIn = false;
-            securityDeposit = initIx.data.securityDeposit;
-            claimerBounty = initIx.data.claimerBounty;
-        }
-
-        return new 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.toNumber(initIx.data.swapData.kind),
-            payIn,
-            initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : PublicKey.default,
-            initIx.data.swapData.payOut ? initIx.accounts.claimerAta : PublicKey.default,
-            securityDeposit,
-            claimerBounty,
-            txoHash
-        );
-    }
-
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *
@@ -125,7 +78,7 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
             ) as InitInstruction;
             if(initIx == null) return null;
 
-            return this.instructionToSwapData(initIx, txoHash);
+            return SolanaSwapData.fromInstruction(initIx, txoHash);
         }
     }
 

package/src/solana/program/modules/SolanaProgramEvents.ts

@@ -1,7 +1,13 @@
 import {SolanaEvents} from "../../chain/modules/SolanaEvents";
 import {BorshCoder, DecodeType, Event, EventParser, Idl, IdlTypes, Instruction} from "@coral-xyz/anchor";
 import {IdlField, IdlInstruction} from "@coral-xyz/anchor/dist/cjs/idl";
-import {ConfirmedSignatureInfo, ParsedMessage, PartiallyDecodedInstruction, PublicKey} from "@solana/web3.js";
+import {
+    ConfirmedSignatureInfo,
+    ParsedMessage, ParsedTransactionWithMeta,
+    PartiallyDecodedInstruction,
+    PublicKey,
+    VersionedTransaction, VersionedTransactionResponse
+} from "@solana/web3.js";
 import {SolanaProgramBase} from "../SolanaProgramBase";
 import {SolanaChainInterface} from "../../chain/SolanaChainInterface";
 
@@ -40,25 +46,6 @@ export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
         }
     }
 
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    private async getEvents(signature: string): Promise<ProgramEvent<IDL>[]> {
-        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
      *
@@ -67,22 +54,50 @@ export 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
      */
     public findInEvents<T>(
         topicKey: PublicKey,
-        processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>,
+        processor: (event: ProgramEvent<IDL>, tx: ParsedTransactionWithMeta) => Promise<T>,
         abortSignal?: AbortSignal,
-        logBatchSize?: number
+        logBatchSize?: number,
+        startBlockheight?: number
     ): Promise<T> {
-        return this.findInSignatures<T>(topicKey, async (signatures: ConfirmedSignatureInfo[]) => {
-            for(let data of signatures) {
-                for(let event of await this.getEvents(data.signature)) {
-                    if(abortSignal!=null) abortSignal.throwIfAborted();
-                    const result: T = await processor(event, data);
-                    if(result!=null) return result;
+        return this.findInSignatures<T>(topicKey, async (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => {
+            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: T = 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: T = await processor(event, tx);
+                        if(result!=null) return result;
+                    }
                 }
             }
-        }, abortSignal, logBatchSize);
+        }, abortSignal, logBatchSize, startBlockheight);
     }
 
     /**

package/src/solana/swaps/SolanaSwapData.ts

@@ -1,6 +1,6 @@
 import {PublicKey} from "@solana/web3.js";
 import * as BN from "bn.js";
-import {SwapData, ChainSwapType} from "@atomiqlabs/base";
+import {ChainSwapType, SwapData} from "@atomiqlabs/base";
 import {SwapProgram} from "./programTypes";
 import {IdlAccounts, IdlTypes} from "@coral-xyz/anchor";
 import {SwapTypeEnum} from "./SwapTypeEnum";
@@ -8,6 +8,9 @@ import {Buffer} from "buffer";
 import {getAssociatedTokenAddressSync} from "@solana/spl-token";
 import {toBigInt, toClaimHash, toEscrowHash} from "../../utils/Utils";
 import {SolanaTokens} from "../chain/modules/SolanaTokens";
+import {SingleInstructionWithAccounts} from "../program/modules/SolanaProgramEvents";
+
+export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3], SwapProgram>;
 
 const EXPIRY_BLOCKHEIGHT_THRESHOLD = new BN("1000000000");
 
@@ -217,6 +220,11 @@ export class SolanaSwapData extends SwapData {
         return this.txoHash;
     }
 
+    getHTLCHashHint(): string {
+        if(this.getType()===ChainSwapType.HTLC) return this.paymentHash;
+        return null;
+    }
+
     getExtraData(): string {
         return this.txoHash;
     }
@@ -300,6 +308,49 @@ export class SolanaSwapData extends SwapData {
             other.token.equals(this.token)
     }
 
+    /**
+     * Converts initialize instruction data into {SolanaSwapData}
+     *
+     * @param initIx
+     * @param txoHash
+     * @private
+     * @returns {SolanaSwapData} converted and parsed swap data
+     */
+    static fromInstruction(
+        initIx: InitInstruction,
+        txoHash: string
+    ): SolanaSwapData {
+        const paymentHash: Buffer = Buffer.from(initIx.data.swapData.hash);
+        let securityDeposit: BN = new BN(0);
+        let claimerBounty: BN = new BN(0);
+        let payIn: boolean = true;
+        if(initIx.name === "offererInitialize") {
+            payIn = false;
+            securityDeposit = initIx.data.securityDeposit;
+            claimerBounty = initIx.data.claimerBounty;
+        }
+
+        return new 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.toNumber(initIx.data.swapData.kind),
+            payIn,
+            initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : PublicKey.default,
+            initIx.data.swapData.payOut ? initIx.accounts.claimerAta : PublicKey.default,
+            securityDeposit,
+            claimerBounty,
+            txoHash
+        );
+    }
+
     static fromEscrowState(account: IdlAccounts<SwapProgram>["escrowState"]) {
         const data: IdlTypes<SwapProgram>["SwapData"] = account.data;