@atomiqlabs/chain-solana 13.5.13 → 13.5.14

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

@@ -1,504 +1,504 @@
-import {
-    ComputeBudgetInstruction,
-    ComputeBudgetProgram, Finality, Keypair,
-    SendOptions, SignatureResult, Signer, Transaction,
-    TransactionExpiredBlockheightExceededError
-} from "@solana/web3.js";
-import {SolanaModule} from "../SolanaModule";
-// @ts-ignore
-import * as bs58 from "bs58";
-import {tryWithRetries} from "../../../utils/Utils";
-import {Buffer} from "buffer";
-import {SolanaSigner} from "../../wallet/SolanaSigner";
-import {TransactionRevertedError} from "@atomiqlabs/base";
-
-/**
- * Solana unsigned transaction type, optionally also contains additional signers which should be used to additionally
- *  sign the transaction.
- *
- * @category Chain Interface
- */
-export type SolanaTx = {tx: Transaction, signers: Signer[]};
-/**
- * Alias for signed Solana transaction, uses the native transaction type of `@solana/web3.js`
- *
- * @category Chain Interface
- */
-export type SignedSolanaTx = Transaction;
-
-export class SolanaTransactions extends SolanaModule {
-
-    private cbkBeforeTxSigned?: (tx: SolanaTx) => Promise<void>;
-    /**
-     * Callback for sending transaction, returns not null if it was successfully able to send the transaction, and null
-     *  if the transaction should be sent through other means)
-     * @private
-     */
-    private cbkSendTransaction?: (tx: Buffer, options?: SendOptions) => Promise<string>;
-
-    /**
-     * Sends raw solana transaction, first through the cbkSendTransaction callback (for e.g. sending the transaction
-     *  to a different specific RPC), the through the Fees handler (for e.g. Jito transaction) and last through the
-     *  underlying provider's Connection instance (the usual way). Only sends the transaction through one channel.
-     *
-     * @param data
-     * @param options
-     * @private
-     */
-    private async sendRawTransaction(data: Buffer, options?: SendOptions): Promise<string> {
-        let result: string | null = null;
-        options ??= {};
-        options.maxRetries = 0;
-        if(this.cbkSendTransaction!=null) result = await this.cbkSendTransaction(data, options);
-        if(result==null) result = await this.root.Fees.submitTx(data, options);
-        if(result==null) result = await this.connection.sendRawTransaction(data, options);
-        // this.logger.debug("sendRawTransaction(): tx sent, signature: "+result);
-        return result;
-    }
-
-    /**
-     * Waits for the transaction to confirm by periodically checking the transaction status over HTTP, also
-     *  re-sends the transaction at regular intervals
-     *
-     * @param tx solana tx to wait for confirmation for
-     * @param finality wait for this finality
-     * @param abortSignal signal to abort waiting for tx confirmation
-     * @private
-     */
-    private txConfirmationAndResendWatchdog(
-        tx: Transaction,
-        finality?: Finality,
-        abortSignal?: AbortSignal
-    ): Promise<string> {
-        if(tx.signature==null) throw new Error("Cannot check confirmation status of tx without signature!");
-        const rawTx = tx.serialize();
-        const signature = bs58.encode(tx.signature);
-        return new Promise((resolve, reject) => {
-            let watchdogInterval: any;
-            watchdogInterval = setInterval(async () => {
-                const result = await this.sendRawTransaction(rawTx, {skipPreflight: true}).catch(
-                    e => this.logger.error("txConfirmationAndResendWatchdog(): transaction re-sent error: ", e)
-                );
-                this.logger.debug("txConfirmationAndResendWatchdog(): transaction re-sent: "+result);
-
-                let status = await this.getTxIdStatus(signature, finality).catch(
-                    e => this.logger.error("txConfirmationAndResendWatchdog(): get tx id status error: ", e)
-                );
-                if(status==null || status==="not_found") {
-                    const blockValidity = await this.connection.isBlockhashValid(tx.recentBlockhash!, {commitment: finality}).catch(
-                        e => this.logger.error("txConfirmationAndResendWatchdog(): blockhash validity check error: ", e)
-                    );
-                    if(!blockValidity) return;
-                    if(blockValidity.value) return;
-                    try {
-                        //One last try to get the txId status
-                        const statusCheck = await this.getTxIdStatus(signature, finality);
-                        if(statusCheck === "not_found") reject(new Error("Transaction expired before confirmation, please try again!"));
-                        status = statusCheck;
-                    } catch (e) {
-                        this.logger.error("txConfirmationAndResendWatchdog(): re-check get tx id status error: ", e);
-                        return;
-                    }
-                }
-                if(status==="success") {
-                    this.logger.info("txConfirmationAndResendWatchdog(): transaction confirmed from HTTP polling, signature: "+signature);
-                    resolve(signature);
-                }
-                if(status==="reverted") reject(new TransactionRevertedError("Transaction reverted!"));
-                clearInterval(watchdogInterval);
-            }, this.retryPolicy?.transactionResendInterval || 3000);
-
-            if(abortSignal!=null) abortSignal.addEventListener("abort", () => {
-                clearInterval(watchdogInterval);
-                reject(abortSignal.reason);
-            });
-        })
-    }
-
-    /**
-     * Waits for the transaction to confirm from WS, sometimes the WS rejects even though the transaction was confirmed
-     *  this therefore also runs an ultimate check on the transaction in case the WS handler rejects, checking if it
-     *  really was expired
-     *
-     * @param tx solana tx to wait for confirmation for
-     * @param finality wait for this finality
-     * @param abortSignal signal to abort waiting for tx confirmation
-     * @private
-     */
-    private async txConfirmFromWebsocket(
-        tx: Transaction,
-        finality?: Finality,
-        abortSignal?: AbortSignal
-    ): Promise<string> {
-        if(tx.signature==null) throw new Error("Cannot wait for confirmation for tx without signature!");
-        const signature = bs58.encode(tx.signature);
-
-        let result: SignatureResult;
-        try {
-            result = await new Promise<SignatureResult>((resolve, reject) => {
-                let subscriptionId: number | undefined;
-
-                if(abortSignal!=null) abortSignal.addEventListener("abort", () => {
-                    if(subscriptionId!=null) this.connection.removeSignatureListener(subscriptionId).catch(e => {
-                        this.logger.debug("txConfirmFromWebsocket(): remove WS signature confirm listener error: ", e);
-                    });
-                    subscriptionId = undefined;
-                    reject(abortSignal.reason);
-                });
-
-                subscriptionId = this.connection.onSignature(signature, (data) => {
-                    resolve(data);
-                    subscriptionId = undefined;
-                }, finality);
-            });
-            this.logger.info("txConfirmFromWebsocket(): transaction confirmed from WS, signature: "+signature);
-        } catch (err: any) {
-            if(abortSignal!=null && abortSignal.aborted) throw err;
-            this.logger.debug("txConfirmFromWebsocket(): transaction rejected from WS, running ultimate check, expiry blockheight: "+tx.lastValidBlockHeight+" signature: "+signature+" error: "+err);
-            const status = await tryWithRetries(
-                () => this.getTxIdStatus(signature, finality)
-            );
-            this.logger.info("txConfirmFromWebsocket(): transaction status: "+status+" signature: "+signature);
-            if(status==="success") return signature;
-            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.err!=null) throw new TransactionRevertedError("Transaction reverted!");
-        return signature;
-    }
-
-    /**
-     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
-     *  the transaction at regular interval
-     *
-     * @param tx solana transaction to wait for confirmation for & keep re-sending until it confirms
-     * @param abortSignal signal to abort waiting for tx confirmation
-     * @param finality wait for specific finality
-     * @private
-     */
-    private async confirmTransaction(tx: Transaction, abortSignal?: AbortSignal, finality?: Finality) {
-        const abortController = new AbortController();
-        if(abortSignal!=null) {
-            abortSignal.throwIfAborted();
-            abortSignal.addEventListener("abort", () => {
-                abortController.abort(abortSignal.reason);
-            });
-        }
-
-        let txSignature: string;
-        try {
-            txSignature = await Promise.race([
-                this.txConfirmationAndResendWatchdog(tx, finality, abortController.signal),
-                this.txConfirmFromWebsocket(tx, finality, abortController.signal)
-            ]);
-        } catch (e) {
-            abortController.abort(e);
-            throw e;
-        }
-
-        // this.logger.info("confirmTransaction(): transaction confirmed, signature: "+txSignature);
-
-        abortController.abort();
-    }
-
-    /**
-     * Prepares solana transactions, assigns recentBlockhash if needed, applies Phantom hotfix,
-     *  sets feePayer to ourselves, calls beforeTxSigned callback & signs transaction with provided signers array
-     *
-     * @param txs
-     * @param signer
-     */
-    public async prepareTransactions(txs: SolanaTx[], signer?: SolanaSigner): Promise<void> {
-        if(txs.length===0) return;
-        const signerAddress = signer?.getPublicKey() ?? txs[0].tx.feePayer;
-        if(signerAddress==null) throw new Error("Cannot get tx sender address!");
-
-        let latestBlockData: {blockhash: string, lastValidBlockHeight: number} | null = null;
-
-        for(let tx of txs) {
-            if(tx.tx.recentBlockhash==null) {
-                if(latestBlockData==null) {
-                    latestBlockData = await this.connection.getLatestBlockhash("confirmed");
-                    this.logger.debug("prepareTransactions(): fetched latest block data for transactions," +
-                        " blockhash: "+latestBlockData.blockhash+" expiry blockheight: "+latestBlockData.lastValidBlockHeight);
-                }
-                tx.tx.recentBlockhash = latestBlockData.blockhash;
-                tx.tx.lastValidBlockHeight = latestBlockData.lastValidBlockHeight;
-            }
-
-            //This is a hotfix for Phantom adding compute unit price instruction on the first position & breaking
-            // required instructions order (e.g. btc relay verify needs to be 0th instruction in a tx)
-            if((signer==null || signer.keypair==null) && tx.tx.signatures.length===0) {
-                const foundIx = tx.tx.instructions.find(ix => ix.programId.equals(ComputeBudgetProgram.programId) && ComputeBudgetInstruction.decodeInstructionType(ix)==="SetComputeUnitPrice")
-                if(foundIx==null) tx.tx.instructions.splice(tx.tx.instructions.length-1, 0, ComputeBudgetProgram.setComputeUnitPrice({microLamports: 1}));
-            }
-
-            tx.tx.feePayer = signerAddress;
-            if(signer!=null && this.cbkBeforeTxSigned!=null) await this.cbkBeforeTxSigned(tx);
-            if(tx.signers!=null && tx.signers.length>0) for(let signer of tx.signers) tx.tx.sign(signer);
-        }
-    }
-
-    /**
-     * Sends out a signed transaction to the RPC
-     *
-     * @param tx solana tx to send
-     * @param options send options to be passed to the RPC
-     * @param onBeforePublish a callback called before every transaction is published
-     * @private
-     */
-    private async sendSignedTransaction(tx: Transaction, options?: SendOptions, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string> {
-        if(tx.signature==null) throw new Error("Cannot broadcast tx without signature!");
-        const signature = bs58.encode(tx.signature);
-
-        if(onBeforePublish!=null) await onBeforePublish(signature, this.serializeSignedTx(tx));
-        const serializedTx = tx.serialize();
-        this.logger.debug("sendSignedTransaction(): sending transaction: "+serializedTx.toString("hex")+
-            " signature: "+signature);
-        const txResult = await tryWithRetries(() => this.sendRawTransaction(serializedTx, options), this.retryPolicy);
-        this.logger.info("sendSignedTransaction(): tx sent, signature: "+txResult);
-        return txResult;
-    }
-
-    /**
-     * Prepares (adds recent blockhash if required, applies Phantom hotfix),
-     *  signs (all together using signAllTransactions() calls), sends (in parallel or sequentially) &
-     *  optionally waits for confirmation of a batch of solana transactions
-     *
-     * @param signer
-     * @param _txs
-     * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
-     *  are re-sent at regular intervals)
-     * @param abortSignal abort signal to abort waiting for transaction confirmations
-     * @param parallel whether the send all the transaction at once in parallel or sequentially (such that transactions
-     *  are executed in order)
-     * @param onBeforePublish a callback called before every transaction is published
-     */
-    public async sendAndConfirm(signer: SolanaSigner, _txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
-        const options = {
-            skipPreflight: true
-        };
-
-        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+=BATCH_SIZE) {
-            const txs = _txs.slice(e, e+BATCH_SIZE);
-
-            await this.prepareTransactions(txs, signer)
-            const signedTxs = await signer.wallet.signAllTransactions(txs.map(e => e.tx));
-            signedTxs.forEach((tx, index) => {
-                const solTx = txs[index];
-                tx.lastValidBlockHeight = solTx.tx.lastValidBlockHeight;
-                solTx.tx = tx
-            });
-            this.logger.debug("sendAndConfirm(): sending transaction batch ("+e+".."+(e+50)+"), count: "+txs.length);
-
-            //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.tx, options, onBeforePublish);
-                const confirmPromise = this.confirmTransaction(solTx.tx, abortSignal, "confirmed");
-                //Don't await the last promise when !waitForConfirmation
-                if(i<txs.length-1 || e+50<_txs.length || waitForConfirmation) {
-                    await confirmPromise;
-                } else {
-                    confirmPromise.catch(err => this.logger.error(`sendAndConfirm(): Error while awaiting confirmation of ${signature}: `, err));
-                }
-                signatures.push(signature);
-            }
-        }
-
-        this.logger.info("sendAndConfirm(): sent transactions, count: "+_txs.length+
-            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
-
-        return signatures;
-    }
-
-    public async sendSignedAndConfirm(
-        signedTxs: SignedSolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal,
-        parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
-    ): Promise<string[]> {
-        //Verify all txns are properly signed
-        signedTxs.forEach(val => {
-            const pubkeysSigned: Set<string> = new Set<string>(
-                val.signatures.map(val => val.publicKey.toString())
-            );
-            val.instructions.forEach(ix => {
-                ix.keys.forEach(key => {
-                    if(key.isSigner && !pubkeysSigned.has(key.pubkey.toString()))
-                        throw new Error("Transaction requires signature by: "+key.pubkey.toString());
-                });
-            });
-        });
-
-        const options = {
-            skipPreflight: true
-        };
-
-        this.logger.debug("sendSignedAndConfirm(): sending transactions, count: "+signedTxs.length+
-            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
-
-        const abortController = new AbortController();
-        if(abortSignal!=null) {
-            abortSignal.throwIfAborted();
-            abortSignal.addEventListener("abort", () => abortController.abort(abortSignal.reason));
-        }
-
-        const signatures: string[] = [];
-        const promises: Promise<void>[] = [];
-        for(let i=0; i<signedTxs.length; i++) {
-            const signedTx = signedTxs[i];
-            this.logger.debug("sendSignedAndConfirm(): sending transaction "+i+", total count: "+signedTxs.length);
-            const signature = await this.sendSignedTransaction(signedTx, options, onBeforePublish);
-            if(abortSignal!=null) abortSignal.throwIfAborted();
-            const confirmPromise = this.confirmTransaction(signedTx, abortController.signal, "confirmed");
-            signatures.push(signature);
-            if(!parallel) {
-                //Don't await the last one when not wait for confirmations
-                if(i<signedTxs.length-1 || waitForConfirmation) {
-                    await confirmPromise;
-                    continue;
-                }
-            } else {
-                if(waitForConfirmation) {
-                    promises.push(confirmPromise.catch(err => {
-                        this.logger.error(`sendSignedAndConfirm(): Error while awaiting confirmation of ${signature}: `, err);
-                        abortController.abort(err);
-                    }));
-                    continue;
-                }
-            }
-            confirmPromise.catch(err => this.logger.error(`sendSignedAndConfirm(): Error while awaiting confirmation of ${signature}: `, err));
-        }
-
-        abortController.signal.throwIfAborted();
-        if(parallel && waitForConfirmation) await Promise.all(promises);
-        abortController.signal.throwIfAborted();
-
-        this.logger.info("sendSignedAndConfirm(): sent transactions, count: "+signedTxs.length+
-            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
-
-        return signatures;
-    }
-
-    /**
-     * Serializes the solana transaction, saves the transaction, signers & last valid blockheight
-     *
-     * @param tx
-     */
-    public serializeUnsignedTx(tx: SolanaTx): string {
-        return JSON.stringify({
-            tx: tx.tx.serialize({requireAllSignatures: false, verifySignatures: false}).toString("hex"),
-            signers: tx.signers.map(e => Buffer.from(e.secretKey).toString("hex")),
-            lastValidBlockheight: tx.tx.lastValidBlockHeight
-        });
-    }
-
-    /**
-     * Serializes the solana transaction
-     *
-     * @param signedTx
-     */
-    public serializeSignedTx(signedTx: Transaction): string {
-        return signedTx.serialize({requireAllSignatures: false, verifySignatures: false}).toString("hex");
-    }
-
-    /**
-     * Deserializes saved solana transaction, extracting the transaction, signers & last valid blockheight
-     *
-     * @param txData
-     */
-    public deserializeUnsignedTx(txData: string): SolanaTx {
-        const jsonParsed: {
-            tx: string,
-            signers: string[],
-            lastValidBlockheight: number
-        } = JSON.parse(txData);
-
-        const transaction = Transaction.from(Buffer.from(jsonParsed.tx, "hex"));
-        transaction.lastValidBlockHeight = jsonParsed.lastValidBlockheight;
-
-        return {
-            tx: transaction,
-            signers: jsonParsed.signers.map(e => Keypair.fromSecretKey(Buffer.from(e, "hex"))),
-        };
-    }
-
-    /**
-     * Deserializes raw solana transaction
-     *
-     * @param txData
-     */
-    public deserializeSignedTransaction(txData: string): Transaction {
-        return Transaction.from(Buffer.from(txData, "hex"));
-    }
-
-    /**
-     * Gets the status of the raw solana transaction, this also checks transaction expiry & can therefore report tx
-     *  in "pending" status, however pending status doesn't necessarily mean that the transaction was sent (again,
-     *  no mempool on Solana, cannot check that), this function is preferred against getTxIdStatus
-     *
-     * @param tx
-     */
-    public async getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
-        const parsedTx: Transaction = this.deserializeSignedTransaction(tx);
-        const signature = bs58.encode(parsedTx.signature!);
-        const txReceipt = await this.connection.getTransaction(signature, {
-            commitment: "confirmed",
-            maxSupportedTransactionVersion: 0
-        });
-        if(txReceipt==null) {
-            const {value: isValid} = await this.connection.isBlockhashValid(parsedTx.recentBlockhash!, {commitment: "processed"});
-            if(!isValid) return "not_found";
-            return "pending";
-        }
-        if(txReceipt.meta==null) throw new Error(`Cannot read status (meta) of Solana transaction: ${signature}`);
-        if(txReceipt.meta.err) return "reverted";
-        return "success";
-    }
-
-    /**
-     * Gets the status of the solana transaction with a specific txId, this cannot report whether the transaction is
-     *  "pending" because Solana has no concept of mempool & only confirmed transactions are accessible
-     *
-     * @param txId
-     * @param finality
-     */
-    public async getTxIdStatus(txId: string, finality?: Finality): Promise<"success" | "not_found" | "reverted"> {
-        const txReceipt = await this.connection.getTransaction(txId, {
-            commitment: finality || "confirmed",
-            maxSupportedTransactionVersion: 0
-        });
-        if(txReceipt==null) return "not_found";
-        if(txReceipt.meta==null) throw new Error(`Cannot read status (meta) of Solana transaction: ${txId}`);
-        if(txReceipt.meta.err) return "reverted";
-        return "success";
-    }
-
-    public onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void {
-        this.cbkBeforeTxSigned = callback;
-    }
-
-    public offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean {
-        delete this.cbkBeforeTxSigned;
-        return true;
-    }
-
-    public onSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): void {
-        this.cbkSendTransaction = callback;
-    }
-
-    public offSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): boolean {
-        delete this.cbkSendTransaction;
-        return true;
-    }
+import {
+    ComputeBudgetInstruction,
+    ComputeBudgetProgram, Finality, Keypair,
+    SendOptions, SignatureResult, Signer, Transaction,
+    TransactionExpiredBlockheightExceededError
+} from "@solana/web3.js";
+import {SolanaModule} from "../SolanaModule";
+// @ts-ignore
+import * as bs58 from "bs58";
+import {tryWithRetries} from "../../../utils/Utils";
+import {Buffer} from "buffer";
+import {SolanaSigner} from "../../wallet/SolanaSigner";
+import {TransactionRevertedError} from "@atomiqlabs/base";
+
+/**
+ * Solana unsigned transaction type, optionally also contains additional signers which should be used to additionally
+ *  sign the transaction.
+ *
+ * @category Chain Interface
+ */
+export type SolanaTx = {tx: Transaction, signers: Signer[]};
+/**
+ * Alias for signed Solana transaction, uses the native transaction type of `@solana/web3.js`
+ *
+ * @category Chain Interface
+ */
+export type SignedSolanaTx = Transaction;
+
+export class SolanaTransactions extends SolanaModule {
+
+    private cbkBeforeTxSigned?: (tx: SolanaTx) => Promise<void>;
+    /**
+     * Callback for sending transaction, returns not null if it was successfully able to send the transaction, and null
+     *  if the transaction should be sent through other means)
+     * @private
+     */
+    private cbkSendTransaction?: (tx: Buffer, options?: SendOptions) => Promise<string>;
+
+    /**
+     * Sends raw solana transaction, first through the cbkSendTransaction callback (for e.g. sending the transaction
+     *  to a different specific RPC), the through the Fees handler (for e.g. Jito transaction) and last through the
+     *  underlying provider's Connection instance (the usual way). Only sends the transaction through one channel.
+     *
+     * @param data
+     * @param options
+     * @private
+     */
+    private async sendRawTransaction(data: Buffer, options?: SendOptions): Promise<string> {
+        let result: string | null = null;
+        options ??= {};
+        options.maxRetries = 0;
+        if(this.cbkSendTransaction!=null) result = await this.cbkSendTransaction(data, options);
+        if(result==null) result = await this.root.Fees.submitTx(data, options);
+        if(result==null) result = await this.connection.sendRawTransaction(data, options);
+        // this.logger.debug("sendRawTransaction(): tx sent, signature: "+result);
+        return result;
+    }
+
+    /**
+     * Waits for the transaction to confirm by periodically checking the transaction status over HTTP, also
+     *  re-sends the transaction at regular intervals
+     *
+     * @param tx solana tx to wait for confirmation for
+     * @param finality wait for this finality
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @private
+     */
+    private txConfirmationAndResendWatchdog(
+        tx: Transaction,
+        finality?: Finality,
+        abortSignal?: AbortSignal
+    ): Promise<string> {
+        if(tx.signature==null) throw new Error("Cannot check confirmation status of tx without signature!");
+        const rawTx = tx.serialize();
+        const signature = bs58.encode(tx.signature);
+        return new Promise((resolve, reject) => {
+            let watchdogInterval: any;
+            watchdogInterval = setInterval(async () => {
+                const result = await this.sendRawTransaction(rawTx, {skipPreflight: true}).catch(
+                    e => this.logger.error("txConfirmationAndResendWatchdog(): transaction re-sent error: ", e)
+                );
+                this.logger.debug("txConfirmationAndResendWatchdog(): transaction re-sent: "+result);
+
+                let status = await this.getTxIdStatus(signature, finality).catch(
+                    e => this.logger.error("txConfirmationAndResendWatchdog(): get tx id status error: ", e)
+                );
+                if(status==null || status==="not_found") {
+                    const blockValidity = await this.connection.isBlockhashValid(tx.recentBlockhash!, {commitment: finality}).catch(
+                        e => this.logger.error("txConfirmationAndResendWatchdog(): blockhash validity check error: ", e)
+                    );
+                    if(!blockValidity) return;
+                    if(blockValidity.value) return;
+                    try {
+                        //One last try to get the txId status
+                        const statusCheck = await this.getTxIdStatus(signature, finality);
+                        if(statusCheck === "not_found") reject(new Error("Transaction expired before confirmation, please try again!"));
+                        status = statusCheck;
+                    } catch (e) {
+                        this.logger.error("txConfirmationAndResendWatchdog(): re-check get tx id status error: ", e);
+                        return;
+                    }
+                }
+                if(status==="success") {
+                    this.logger.info("txConfirmationAndResendWatchdog(): transaction confirmed from HTTP polling, signature: "+signature);
+                    resolve(signature);
+                }
+                if(status==="reverted") reject(new TransactionRevertedError("Transaction reverted!"));
+                clearInterval(watchdogInterval);
+            }, this.retryPolicy?.transactionResendInterval || 3000);
+
+            if(abortSignal!=null) abortSignal.addEventListener("abort", () => {
+                clearInterval(watchdogInterval);
+                reject(abortSignal.reason);
+            });
+        })
+    }
+
+    /**
+     * Waits for the transaction to confirm from WS, sometimes the WS rejects even though the transaction was confirmed
+     *  this therefore also runs an ultimate check on the transaction in case the WS handler rejects, checking if it
+     *  really was expired
+     *
+     * @param tx solana tx to wait for confirmation for
+     * @param finality wait for this finality
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @private
+     */
+    private async txConfirmFromWebsocket(
+        tx: Transaction,
+        finality?: Finality,
+        abortSignal?: AbortSignal
+    ): Promise<string> {
+        if(tx.signature==null) throw new Error("Cannot wait for confirmation for tx without signature!");
+        const signature = bs58.encode(tx.signature);
+
+        let result: SignatureResult;
+        try {
+            result = await new Promise<SignatureResult>((resolve, reject) => {
+                let subscriptionId: number | undefined;
+
+                if(abortSignal!=null) abortSignal.addEventListener("abort", () => {
+                    if(subscriptionId!=null) this.connection.removeSignatureListener(subscriptionId).catch(e => {
+                        this.logger.debug("txConfirmFromWebsocket(): remove WS signature confirm listener error: ", e);
+                    });
+                    subscriptionId = undefined;
+                    reject(abortSignal.reason);
+                });
+
+                subscriptionId = this.connection.onSignature(signature, (data) => {
+                    resolve(data);
+                    subscriptionId = undefined;
+                }, finality);
+            });
+            this.logger.info("txConfirmFromWebsocket(): transaction confirmed from WS, signature: "+signature);
+        } catch (err: any) {
+            if(abortSignal!=null && abortSignal.aborted) throw err;
+            this.logger.debug("txConfirmFromWebsocket(): transaction rejected from WS, running ultimate check, expiry blockheight: "+tx.lastValidBlockHeight+" signature: "+signature+" error: "+err);
+            const status = await tryWithRetries(
+                () => this.getTxIdStatus(signature, finality)
+            );
+            this.logger.info("txConfirmFromWebsocket(): transaction status: "+status+" signature: "+signature);
+            if(status==="success") return signature;
+            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.err!=null) throw new TransactionRevertedError("Transaction reverted!");
+        return signature;
+    }
+
+    /**
+     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
+     *  the transaction at regular interval
+     *
+     * @param tx solana transaction to wait for confirmation for & keep re-sending until it confirms
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @param finality wait for specific finality
+     * @private
+     */
+    private async confirmTransaction(tx: Transaction, abortSignal?: AbortSignal, finality?: Finality) {
+        const abortController = new AbortController();
+        if(abortSignal!=null) {
+            abortSignal.throwIfAborted();
+            abortSignal.addEventListener("abort", () => {
+                abortController.abort(abortSignal.reason);
+            });
+        }
+
+        let txSignature: string;
+        try {
+            txSignature = await Promise.race([
+                this.txConfirmationAndResendWatchdog(tx, finality, abortController.signal),
+                this.txConfirmFromWebsocket(tx, finality, abortController.signal)
+            ]);
+        } catch (e) {
+            abortController.abort(e);
+            throw e;
+        }
+
+        // this.logger.info("confirmTransaction(): transaction confirmed, signature: "+txSignature);
+
+        abortController.abort();
+    }
+
+    /**
+     * Prepares solana transactions, assigns recentBlockhash if needed, applies Phantom hotfix,
+     *  sets feePayer to ourselves, calls beforeTxSigned callback & signs transaction with provided signers array
+     *
+     * @param txs
+     * @param signer
+     */
+    public async prepareTransactions(txs: SolanaTx[], signer?: SolanaSigner): Promise<void> {
+        if(txs.length===0) return;
+        const signerAddress = signer?.getPublicKey() ?? txs[0].tx.feePayer;
+        if(signerAddress==null) throw new Error("Cannot get tx sender address!");
+
+        let latestBlockData: {blockhash: string, lastValidBlockHeight: number} | null = null;
+
+        for(let tx of txs) {
+            if(tx.tx.recentBlockhash==null) {
+                if(latestBlockData==null) {
+                    latestBlockData = await this.connection.getLatestBlockhash("confirmed");
+                    this.logger.debug("prepareTransactions(): fetched latest block data for transactions," +
+                        " blockhash: "+latestBlockData.blockhash+" expiry blockheight: "+latestBlockData.lastValidBlockHeight);
+                }
+                tx.tx.recentBlockhash = latestBlockData.blockhash;
+                tx.tx.lastValidBlockHeight = latestBlockData.lastValidBlockHeight;
+            }
+
+            //This is a hotfix for Phantom adding compute unit price instruction on the first position & breaking
+            // required instructions order (e.g. btc relay verify needs to be 0th instruction in a tx)
+            if((signer==null || signer.keypair==null) && tx.tx.signatures.length===0) {
+                const foundIx = tx.tx.instructions.find(ix => ix.programId.equals(ComputeBudgetProgram.programId) && ComputeBudgetInstruction.decodeInstructionType(ix)==="SetComputeUnitPrice")
+                if(foundIx==null) tx.tx.instructions.splice(tx.tx.instructions.length-1, 0, ComputeBudgetProgram.setComputeUnitPrice({microLamports: 1}));
+            }
+
+            tx.tx.feePayer = signerAddress;
+            if(signer!=null && this.cbkBeforeTxSigned!=null) await this.cbkBeforeTxSigned(tx);
+            if(tx.signers!=null && tx.signers.length>0) for(let signer of tx.signers) tx.tx.sign(signer);
+        }
+    }
+
+    /**
+     * Sends out a signed transaction to the RPC
+     *
+     * @param tx solana tx to send
+     * @param options send options to be passed to the RPC
+     * @param onBeforePublish a callback called before every transaction is published
+     * @private
+     */
+    private async sendSignedTransaction(tx: Transaction, options?: SendOptions, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string> {
+        if(tx.signature==null) throw new Error("Cannot broadcast tx without signature!");
+        const signature = bs58.encode(tx.signature);
+
+        if(onBeforePublish!=null) await onBeforePublish(signature, this.serializeSignedTx(tx));
+        const serializedTx = tx.serialize();
+        this.logger.debug("sendSignedTransaction(): sending transaction: "+serializedTx.toString("hex")+
+            " signature: "+signature);
+        const txResult = await tryWithRetries(() => this.sendRawTransaction(serializedTx, options), this.retryPolicy);
+        this.logger.info("sendSignedTransaction(): tx sent, signature: "+txResult);
+        return txResult;
+    }
+
+    /**
+     * Prepares (adds recent blockhash if required, applies Phantom hotfix),
+     *  signs (all together using signAllTransactions() calls), sends (in parallel or sequentially) &
+     *  optionally waits for confirmation of a batch of solana transactions
+     *
+     * @param signer
+     * @param _txs
+     * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
+     *  are re-sent at regular intervals)
+     * @param abortSignal abort signal to abort waiting for transaction confirmations
+     * @param parallel whether the send all the transaction at once in parallel or sequentially (such that transactions
+     *  are executed in order)
+     * @param onBeforePublish a callback called before every transaction is published
+     */
+    public async sendAndConfirm(signer: SolanaSigner, _txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
+        const options = {
+            skipPreflight: true
+        };
+
+        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+=BATCH_SIZE) {
+            const txs = _txs.slice(e, e+BATCH_SIZE);
+
+            await this.prepareTransactions(txs, signer)
+            const signedTxs = await signer.wallet.signAllTransactions(txs.map(e => e.tx));
+            signedTxs.forEach((tx, index) => {
+                const solTx = txs[index];
+                tx.lastValidBlockHeight = solTx.tx.lastValidBlockHeight;
+                solTx.tx = tx
+            });
+            this.logger.debug("sendAndConfirm(): sending transaction batch ("+e+".."+(e+50)+"), count: "+txs.length);
+
+            //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.tx, options, onBeforePublish);
+                const confirmPromise = this.confirmTransaction(solTx.tx, abortSignal, "confirmed");
+                //Don't await the last promise when !waitForConfirmation
+                if(i<txs.length-1 || e+50<_txs.length || waitForConfirmation) {
+                    await confirmPromise;
+                } else {
+                    confirmPromise.catch(err => this.logger.error(`sendAndConfirm(): Error while awaiting confirmation of ${signature}: `, err));
+                }
+                signatures.push(signature);
+            }
+        }
+
+        this.logger.info("sendAndConfirm(): sent transactions, count: "+_txs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        return signatures;
+    }
+
+    public async sendSignedAndConfirm(
+        signedTxs: SignedSolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal,
+        parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
+    ): Promise<string[]> {
+        //Verify all txns are properly signed
+        signedTxs.forEach(val => {
+            const pubkeysSigned: Set<string> = new Set<string>(
+                val.signatures.map(val => val.publicKey.toString())
+            );
+            val.instructions.forEach(ix => {
+                ix.keys.forEach(key => {
+                    if(key.isSigner && !pubkeysSigned.has(key.pubkey.toString()))
+                        throw new Error("Transaction requires signature by: "+key.pubkey.toString());
+                });
+            });
+        });
+
+        const options = {
+            skipPreflight: true
+        };
+
+        this.logger.debug("sendSignedAndConfirm(): sending transactions, count: "+signedTxs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        const abortController = new AbortController();
+        if(abortSignal!=null) {
+            abortSignal.throwIfAborted();
+            abortSignal.addEventListener("abort", () => abortController.abort(abortSignal.reason));
+        }
+
+        const signatures: string[] = [];
+        const promises: Promise<void>[] = [];
+        for(let i=0; i<signedTxs.length; i++) {
+            const signedTx = signedTxs[i];
+            this.logger.debug("sendSignedAndConfirm(): sending transaction "+i+", total count: "+signedTxs.length);
+            const signature = await this.sendSignedTransaction(signedTx, options, onBeforePublish);
+            if(abortSignal!=null) abortSignal.throwIfAborted();
+            const confirmPromise = this.confirmTransaction(signedTx, abortController.signal, "confirmed");
+            signatures.push(signature);
+            if(!parallel) {
+                //Don't await the last one when not wait for confirmations
+                if(i<signedTxs.length-1 || waitForConfirmation) {
+                    await confirmPromise;
+                    continue;
+                }
+            } else {
+                if(waitForConfirmation) {
+                    promises.push(confirmPromise.catch(err => {
+                        this.logger.error(`sendSignedAndConfirm(): Error while awaiting confirmation of ${signature}: `, err);
+                        abortController.abort(err);
+                    }));
+                    continue;
+                }
+            }
+            confirmPromise.catch(err => this.logger.error(`sendSignedAndConfirm(): Error while awaiting confirmation of ${signature}: `, err));
+        }
+
+        abortController.signal.throwIfAborted();
+        if(parallel && waitForConfirmation) await Promise.all(promises);
+        abortController.signal.throwIfAborted();
+
+        this.logger.info("sendSignedAndConfirm(): sent transactions, count: "+signedTxs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        return signatures;
+    }
+
+    /**
+     * Serializes the solana transaction, saves the transaction, signers & last valid blockheight
+     *
+     * @param tx
+     */
+    public serializeUnsignedTx(tx: SolanaTx): string {
+        return JSON.stringify({
+            tx: tx.tx.serialize({requireAllSignatures: false, verifySignatures: false}).toString("hex"),
+            signers: tx.signers.map(e => Buffer.from(e.secretKey).toString("hex")),
+            lastValidBlockheight: tx.tx.lastValidBlockHeight
+        });
+    }
+
+    /**
+     * Serializes the solana transaction
+     *
+     * @param signedTx
+     */
+    public serializeSignedTx(signedTx: Transaction): string {
+        return signedTx.serialize({requireAllSignatures: false, verifySignatures: false}).toString("hex");
+    }
+
+    /**
+     * Deserializes saved solana transaction, extracting the transaction, signers & last valid blockheight
+     *
+     * @param txData
+     */
+    public deserializeUnsignedTx(txData: string): SolanaTx {
+        const jsonParsed: {
+            tx: string,
+            signers: string[],
+            lastValidBlockheight: number
+        } = JSON.parse(txData);
+
+        const transaction = Transaction.from(Buffer.from(jsonParsed.tx, "hex"));
+        transaction.lastValidBlockHeight = jsonParsed.lastValidBlockheight;
+
+        return {
+            tx: transaction,
+            signers: jsonParsed.signers.map(e => Keypair.fromSecretKey(Buffer.from(e, "hex"))),
+        };
+    }
+
+    /**
+     * Deserializes raw solana transaction
+     *
+     * @param txData
+     */
+    public deserializeSignedTransaction(txData: string): Transaction {
+        return Transaction.from(Buffer.from(txData, "hex"));
+    }
+
+    /**
+     * Gets the status of the raw solana transaction, this also checks transaction expiry & can therefore report tx
+     *  in "pending" status, however pending status doesn't necessarily mean that the transaction was sent (again,
+     *  no mempool on Solana, cannot check that), this function is preferred against getTxIdStatus
+     *
+     * @param tx
+     */
+    public async getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
+        const parsedTx: Transaction = this.deserializeSignedTransaction(tx);
+        const signature = bs58.encode(parsedTx.signature!);
+        const txReceipt = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+        });
+        if(txReceipt==null) {
+            const {value: isValid} = await this.connection.isBlockhashValid(parsedTx.recentBlockhash!, {commitment: "processed"});
+            if(!isValid) return "not_found";
+            return "pending";
+        }
+        if(txReceipt.meta==null) throw new Error(`Cannot read status (meta) of Solana transaction: ${signature}`);
+        if(txReceipt.meta.err) return "reverted";
+        return "success";
+    }
+
+    /**
+     * Gets the status of the solana transaction with a specific txId, this cannot report whether the transaction is
+     *  "pending" because Solana has no concept of mempool & only confirmed transactions are accessible
+     *
+     * @param txId
+     * @param finality
+     */
+    public async getTxIdStatus(txId: string, finality?: Finality): Promise<"success" | "not_found" | "reverted"> {
+        const txReceipt = await this.connection.getTransaction(txId, {
+            commitment: finality || "confirmed",
+            maxSupportedTransactionVersion: 0
+        });
+        if(txReceipt==null) return "not_found";
+        if(txReceipt.meta==null) throw new Error(`Cannot read status (meta) of Solana transaction: ${txId}`);
+        if(txReceipt.meta.err) return "reverted";
+        return "success";
+    }
+
+    public onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void {
+        this.cbkBeforeTxSigned = callback;
+    }
+
+    public offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean {
+        delete this.cbkBeforeTxSigned;
+        return true;
+    }
+
+    public onSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): void {
+        this.cbkSendTransaction = callback;
+    }
+
+    public offSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): boolean {
+        delete this.cbkSendTransaction;
+        return true;
+    }
 }