@atomiqlabs/chain-solana 7.2.0

package/src/solana/base/modules/SolanaTokens.ts

@@ -0,0 +1,310 @@
+import {SolanaModule} from "../SolanaModule";
+import {PublicKey, SystemProgram} from "@solana/web3.js";
+import {
+    Account, createAssociatedTokenAccountInstruction,
+    createCloseAccountInstruction, createSyncNativeInstruction, createTransferInstruction,
+    getAccount, getAssociatedTokenAddress,
+    getAssociatedTokenAddressSync,
+    TokenAccountNotFoundError
+} from "@solana/spl-token";
+import * as BN from "bn.js";
+import {SolanaTx} from "./SolanaTransactions";
+import {SolanaAction} from "../SolanaAction";
+import {tryWithRetries} from "../../../utils/Utils";
+
+export class SolanaTokens extends SolanaModule {
+
+    public static readonly CUCosts = {
+        WRAP_SOL: 10000,
+        ATA_CLOSE: 10000,
+        ATA_INIT: 40000,
+        TRANSFER: 50000,
+        TRANSFER_SOL: 5000
+    };
+
+    /**
+     * Creates an ATA for a specific public key & token, the ATA creation is paid for by the underlying provider's
+     *  public key
+     *
+     * @param signer
+     * @param publicKey public key address of the user for which to initiate the ATA
+     * @param token token identification for which the ATA should be initialized
+     * @param requiredAta optional required ata address to use, if the address doesn't match it returns null
+     * @constructor
+     */
+    public InitAta(signer: PublicKey, publicKey: PublicKey, token: PublicKey, requiredAta?: PublicKey): SolanaAction | null {
+        const ata = getAssociatedTokenAddressSync(token, publicKey);
+        if(requiredAta!=null && !ata.equals(requiredAta)) return null;
+        return new SolanaAction(
+            signer,
+            this.root,
+            createAssociatedTokenAccountInstruction(
+                signer,
+                ata,
+                publicKey,
+                token
+            ),
+            SolanaTokens.CUCosts.ATA_INIT
+        )
+    }
+
+    /**
+     * Action for wrapping SOL to WSOL for a specific public key
+     *
+     * @param publicKey public key of the user for which to wrap the SOL
+     * @param amount amount of SOL in lamports (smallest unit) to wrap
+     * @param initAta whether we should also initialize the ATA before depositing SOL
+     * @constructor
+     */
+    public Wrap(publicKey: PublicKey, amount: BN, initAta: boolean): SolanaAction {
+        const ata = getAssociatedTokenAddressSync(this.WSOL_ADDRESS, publicKey);
+        const action = new SolanaAction(publicKey, this.root);
+        if(initAta) action.addIx(
+            createAssociatedTokenAccountInstruction(publicKey, ata, publicKey, this.WSOL_ADDRESS),
+            SolanaTokens.CUCosts.ATA_INIT
+        );
+        action.addIx(
+            SystemProgram.transfer({
+                fromPubkey: publicKey,
+                toPubkey: ata,
+                lamports: BigInt(amount.toString(10))
+            }),
+            SolanaTokens.CUCosts.WRAP_SOL
+        );
+        action.addIx(createSyncNativeInstruction(ata));
+        return action;
+    }
+
+    /**
+     * Action for unwrapping WSOL to SOL for a specific public key
+     *
+     * @param publicKey public key of the user for which to unwrap the sol
+     * @constructor
+     */
+    public Unwrap(publicKey: PublicKey): SolanaAction {
+        const ata = getAssociatedTokenAddressSync(this.WSOL_ADDRESS, publicKey);
+        return new SolanaAction(
+            publicKey,
+            this.root,
+            createCloseAccountInstruction(ata, publicKey, publicKey),
+            SolanaTokens.CUCosts.ATA_CLOSE
+        );
+    }
+
+    public readonly WSOL_ADDRESS = new PublicKey("So11111111111111111111111111111111111111112");
+    public readonly SPL_ATA_RENT_EXEMPT = 2039280;
+
+    /**
+     * Action for transferring the native SOL token, uses provider's public key as a sender
+     *
+     * @param signer
+     * @param recipient
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private SolTransfer(signer: PublicKey, recipient: PublicKey, amount: BN): SolanaAction {
+        return new SolanaAction(signer, this.root,
+            SystemProgram.transfer({
+                fromPubkey: signer,
+                toPubkey: recipient,
+                lamports: BigInt(amount.toString(10))
+            }),
+            SolanaTokens.CUCosts.TRANSFER_SOL
+        );
+    }
+
+    /**
+     * Action for transferring the SPL token, uses provider's public key as a sender
+     *
+     * @param signer
+     * @param recipient
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Transfer(signer: PublicKey, recipient: PublicKey, token: PublicKey, amount: BN): SolanaAction {
+        const srcAta = getAssociatedTokenAddressSync(token, signer, false)
+        const dstAta = getAssociatedTokenAddressSync(token, recipient, false);
+        return new SolanaAction(signer, this.root,
+            createTransferInstruction(
+                srcAta,
+                dstAta,
+                signer,
+                BigInt(amount.toString(10))
+            ),
+            SolanaTokens.CUCosts.TRANSFER
+        );
+    }
+
+    /**
+     * Creates transactions for sending SOL (the native token)
+     *
+     * @param signer
+     * @param amount amount of the SOL in lamports (smallest unit) to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    private async txsTransferSol(signer: PublicKey, amount: BN, recipient: PublicKey, feeRate?: string): Promise<SolanaTx[]> {
+        const wsolAta = getAssociatedTokenAddressSync(this.WSOL_ADDRESS, signer, false);
+
+        const shouldUnwrap = await this.ataExists(wsolAta);
+        const action = new SolanaAction(signer, this.root);
+        if(shouldUnwrap) {
+            feeRate = feeRate || await this.root.Fees.getFeeRate([signer, recipient, wsolAta]);
+            action.add(this.Unwrap(signer));
+        } else {
+            feeRate = feeRate || await this.root.Fees.getFeeRate([signer, recipient]);
+        }
+        action.add(this.SolTransfer(signer, recipient, amount));
+
+        this.logger.debug("txsTransferSol(): transfer native solana TX created, recipient: "+recipient.toString()+
+             " amount: "+amount.toString(10)+" unwrapping: "+shouldUnwrap);
+
+        return [await action.tx(feeRate)];
+    }
+
+    /**
+     * Creates transactions for sending the over the tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    private async txsTransferTokens(signer: PublicKey, token: PublicKey, amount: BN, recipient: PublicKey, feeRate?: string) {
+        const srcAta = await getAssociatedTokenAddress(token, signer);
+        const dstAta = getAssociatedTokenAddressSync(token, recipient, false);
+
+        feeRate = feeRate || await this.root.Fees.getFeeRate([signer, srcAta, dstAta]);
+
+        const initAta = !await this.ataExists(dstAta);
+        const action = new SolanaAction(signer, this.root);
+        if(initAta) {
+            action.add(this.InitAta(signer, recipient, token));
+        }
+        action.add(this.Transfer(signer, recipient, token, amount));
+
+        this.logger.debug("txsTransferTokens(): transfer TX created, recipient: "+recipient.toString()+
+            " token: "+token.toString()+ " amount: "+amount.toString(10)+" initAta: "+initAta);
+
+        return [await action.tx(feeRate)];
+    }
+
+    ///////////////////
+    //// Tokens
+    /**
+     * Checks if the provided string is a valid solana token
+     *
+     * @param token
+     */
+    public isValidToken(token: string) {
+        try {
+            new PublicKey(token);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Returns the specific ATA or null if it doesn't exist
+     *
+     * @param ata
+     */
+    public getATAOrNull(ata: PublicKey): Promise<Account | null> {
+        return getAccount(this.connection, ata).catch(e => {
+            if(e instanceof TokenAccountNotFoundError) return null;
+            throw e;
+        });
+    }
+
+    /**
+     * Checks whether the specific ATA exists, uses tryWithRetries so retries on failure
+     *
+     * @param ata
+     */
+    public async ataExists(ata: PublicKey) {
+        const account = await tryWithRetries<Account>(
+            () => this.getATAOrNull(ata),
+            this.retryPolicy
+        );
+        return account!=null;
+    }
+
+    /**
+     * Returns the rent exempt deposit required to initiate the ATA
+     */
+    public getATARentExemptLamports(): Promise<BN> {
+        return Promise.resolve(new BN(this.SPL_ATA_RENT_EXEMPT));
+    }
+
+    /**
+     * Returns the token balance of the public key
+     *
+     * @param publicKey
+     * @param token
+     */
+    public async getTokenBalance(publicKey: PublicKey, token: PublicKey) {
+        const ata: PublicKey = getAssociatedTokenAddressSync(token, publicKey);
+        const [ataAccount, balance] = await Promise.all<[Promise<Account>, Promise<number>]>([
+            this.getATAOrNull(ata),
+            (token!=null && token.equals(this.WSOL_ADDRESS)) ? this.connection.getBalance(publicKey) : Promise.resolve(null)
+        ]);
+
+        let ataExists: boolean = ataAccount!=null;
+        let sum: BN = new BN(0);
+        if(ataExists) {
+            sum = sum.add(new BN(ataAccount.amount.toString()));
+        }
+
+        if(balance!=null) {
+            let balanceLamports: BN = new BN(balance);
+            if(!ataExists) balanceLamports = balanceLamports.sub(await this.getATARentExemptLamports());
+            if(!balanceLamports.isNeg()) sum = sum.add(balanceLamports);
+        }
+
+        this.logger.debug("getTokenBalance(): token balance fetched, token: "+token.toString()+
+            " address: "+publicKey.toString()+" amount: "+sum.toString());
+
+        return sum;
+    }
+
+    /**
+     * Returns the native currency address, we use WSOL address as placeholder for SOL
+     */
+    public getNativeCurrencyAddress(): PublicKey {
+        return this.WSOL_ADDRESS;
+    }
+
+    /**
+     * Parses string base58 representation of the token address to a PublicKey object
+     * @param address
+     */
+    public toTokenAddress(address: string): PublicKey {
+        return new PublicKey(address);
+    }
+
+    ///////////////////
+    //// Transfers
+    /**
+     * Create transactions for sending a specific token to a destination address
+     *
+     * @param signer
+     * @param token token to use for the transfer
+     * @param amount amount of token in base units to transfer
+     * @param dstAddress destination address of the recipient
+     * @param feeRate fee rate to use for the transaction
+     */
+    public txsTransfer(signer:PublicKey, token: PublicKey, amount: BN, dstAddress: PublicKey, feeRate?: string): Promise<SolanaTx[]> {
+        if(this.WSOL_ADDRESS.equals(token)) {
+            return this.txsTransferSol(signer, amount, dstAddress, feeRate);
+        }
+        return this.txsTransferTokens(signer, token, amount, dstAddress, feeRate);
+    }
+
+}

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

@@ -0,0 +1,366 @@
+import {
+    ComputeBudgetInstruction,
+    ComputeBudgetProgram, Finality, Keypair, RpcResponseAndContext,
+    SendOptions, SignatureResult, Signer, Transaction,
+    TransactionExpiredBlockheightExceededError
+} from "@solana/web3.js";
+import {SolanaModule} from "../SolanaModule";
+import * as bs58 from "bs58";
+import {tryWithRetries} from "../../../utils/Utils";
+import {Buffer} from "buffer";
+import {SolanaSigner} from "../../wallet/SolanaSigner";
+
+export type SolanaTx = {tx: Transaction, signers: Signer[]};
+
+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;
+        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 solanaTx 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(
+        solanaTx: SolanaTx,
+        finality?: Finality,
+        abortSignal?: AbortSignal
+    ): Promise<string> {
+        const rawTx = solanaTx.tx.serialize();
+        const signature = bs58.encode(solanaTx.tx.signature);
+        return new Promise((resolve, reject) => {
+            let watchdogInterval: NodeJS.Timer;
+            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);
+
+                const status = await this.getTxIdStatus(signature, finality).catch(
+                    e => this.logger.error("txConfirmationAndResendWatchdog(): get tx id status error: ", e)
+                );
+                if(status==null || status==="not_found") return;
+                if(status==="success") {
+                    this.logger.info("txConfirmationAndResendWatchdog(): transaction confirmed from HTTP polling, signature: "+signature);
+                    resolve(signature);
+                }
+                if(status==="reverted") reject(new Error("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 solanaTx 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(
+        solanaTx: SolanaTx,
+        finality?: Finality,
+        abortSignal?: AbortSignal
+    ): Promise<string> {
+        const signature = bs58.encode(solanaTx.tx.signature);
+
+        let result: RpcResponseAndContext<SignatureResult>;
+        try {
+            result = await this.connection.confirmTransaction({
+                signature: signature,
+                blockhash: solanaTx.tx.recentBlockhash,
+                lastValidBlockHeight: solanaTx.tx.lastValidBlockHeight,
+                abortSignal
+            }, finality);
+            this.logger.info("txConfirmFromWebsocket(): transaction confirmed from WS, signature: "+signature);
+        } catch (err) {
+            if(abortSignal!=null && abortSignal.aborted) throw err;
+            this.logger.debug("txConfirmFromWebsocket(): transaction rejected from WS, running ultimate check, expiry blockheight: "+solanaTx.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 Error("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!");
+        return signature;
+    }
+
+    /**
+     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
+     *  the transaction at regular interval
+     *
+     * @param solanaTx 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(solanaTx: SolanaTx, abortSignal?: AbortSignal, finality?: Finality) {
+        const abortController = new AbortController();
+        if(abortSignal!=null) abortSignal.addEventListener("abort", () => {
+            abortController.abort();
+        });
+
+        let txSignature: string;
+        try {
+            txSignature = await Promise.race([
+                this.txConfirmationAndResendWatchdog(solanaTx, finality, abortController.signal),
+                this.txConfirmFromWebsocket(solanaTx, 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 signer
+     * @param txs
+     * @private
+     */
+    private async prepareTransactions(signer: SolanaSigner, txs: SolanaTx[]): Promise<void> {
+        let latestBlockData: {blockhash: string, lastValidBlockHeight: number} = null;
+
+        for(let tx of txs) {
+            if(tx.tx.recentBlockhash==null) {
+                if(latestBlockData==null) {
+                    latestBlockData = await tryWithRetries(
+                        () => this.connection.getLatestBlockhash("confirmed"),
+                        this.retryPolicy
+                    );
+                    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.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 = signer.getPublicKey();
+            if(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 solTx 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(solTx: SolanaTx, options?: SendOptions, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string> {
+        if(onBeforePublish!=null) await onBeforePublish(bs58.encode(solTx.tx.signature), await this.serializeTx(solTx));
+        const serializedTx = solTx.tx.serialize();
+        this.logger.debug("sendSignedTransaction(): sending transaction: "+serializedTx.toString("hex")+
+            " signature: "+bs58.encode(solTx.tx.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 transactions to send
+     * @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[]> {
+        await this.prepareTransactions(signer, txs)
+        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
+        });
+
+        const options = {
+            skipPreflight: true
+        };
+
+        this.logger.debug("sendAndConfirm(): sending transactions, count: "+txs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        const signatures: string[] = [];
+        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 || waitForConfirmation) await confirmPromise;
+                signatures.push(signature);
+            }
+        }
+
+        this.logger.info("sendAndConfirm(): sent transactions, count: "+txs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        return signatures;
+    }
+
+    /**
+     * Serializes the solana transaction, saves the transaction, signers & last valid blockheight
+     *
+     * @param tx
+     */
+    public serializeTx(tx: SolanaTx): Promise<string> {
+        return Promise.resolve(JSON.stringify({
+            tx: tx.tx.serialize().toString("hex"),
+            signers: tx.signers.map(e => Buffer.from(e.secretKey).toString("hex")),
+            lastValidBlockheight: tx.tx.lastValidBlockHeight
+        }));
+    }
+
+    /**
+     * Deserializes saved solana transaction, extracting the transaction, signers & last valid blockheight
+     *
+     * @param txData
+     */
+    public deserializeTx(txData: string): Promise<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 Promise.resolve({
+            tx: transaction,
+            signers: jsonParsed.signers.map(e => Keypair.fromSecretKey(Buffer.from(e, "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: SolanaTx = await this.deserializeTx(tx);
+        const txReceipt = await this.connection.getTransaction(bs58.encode(parsedTx.tx.signature), {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+        });
+        if(txReceipt==null) {
+            const currentBlockheight = await this.connection.getBlockHeight("processed");
+            if(currentBlockheight>parsedTx.tx.lastValidBlockHeight) return "not_found";
+            return "pending";
+        }
+        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.err) return "reverted";
+        return "success";
+    }
+
+    public onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void {
+        this.cbkBeforeTxSigned = callback;
+    }
+
+    public offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean {
+        this.cbkBeforeTxSigned = null;
+        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 {
+        this.cbkSendTransaction = null;
+        return true;
+    }
+}