@atomiqlabs/chain-solana 13.5.13 → 13.5.14

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

@@ -1,522 +1,522 @@
-import {
-    ComputeBudgetProgram,
-    Connection,
-    ParsedNoneModeBlockResponse,
-    PublicKey,
-    SendOptions,
-    SystemInstruction,
-    SystemProgram,
-    Transaction
-} from "@solana/web3.js";
-import {getLogger, SolanaTxUtils} from "../../../utils/Utils";
-
-const MAX_FEE_AGE = 5000;
-
-/**
- * Bribe configuration used for Jito-like tips that handled outside of native Solana network fees
- *
- * @category Chain Interface
- */
-export type FeeBribeData = {
-    /**
-     * Address to send the bribe to (e.g. Jito tip)
-     */
-    address: string,
-    /**
-     * HTTP endpoint to send the transaction to instead of the RPC, e.g. a Jito endpoint
-     */
-    endpoint: string,
-    /**
-     * An optional function for overriding the bribe to be sent to the specified address for the tx
-     */
-    getBribeFee?: (original: bigint) => bigint
-};
-
-/**
- * Fee estimation service for the Solana network. Uses client-side fee estimation algorithm by default, which
- *  fetches a bunch (default 8) random blocks in the past period (default 150) and computes the average fee. It
- *  automatically detects whether the underlying RPC endpoint is a Helius one which features the `getPriorityFeeEstimate`
- *  endpoint, and if available uses that one.
- *
- * @category Chain Interface
- */
-export class SolanaFees {
-
-    private readonly connection: Connection;
-    private readonly maxFeeMicroLamports: bigint;
-    private readonly numSamples: number;
-    private readonly period: number;
-    private useHeliusApi: "yes" | "no" | "auto";
-    private heliusApiSupported: boolean = true;
-    private readonly heliusFeeLevel: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax";
-    private readonly bribeData?: FeeBribeData;
-    private readonly getStaticFee?: (original: bigint) => bigint;
-
-    private readonly logger = getLogger("SolanaFees: ");
-
-    private blockFeeCache?: {
-        timestamp: number,
-        feeRate: Promise<bigint>
-    };
-
-    /**
-     * @param connection Underlying Solana network connection to use for read access to Solana
-     * @param maxFeeMicroLamports Maximum allowed fee in microLamports/CU (1/1,000,000 of a lamport per compute unit)
-     * @param numSamples Number of samples to use when estimating the global fee on the client-side, this many blocks are
-     *  sampled from the last `period` blocks to estimate an average fee rate
-     * @param period Period of past blocks to sample random blocks from when estimating the global fee on the client-side
-     * @param useHeliusApi Whether to use the helius API or not, default to `"auto"`, which automatically detects if the
-     *  underlying RPC supports Helius's `getPriorityFeeEstimate` RPC call
-     * @param heliusFeeLevel Fee level to use when fetching the fee rate from Helius's `getPriorityFeeEstimate` RPC endpoint,
-     *  for the meaning of the different levels refer to https://www.helius.dev/docs/priority-fee-api#priority-levels-explained
-     * @param getStaticFee Optional function for adding a base fee to transactions (this function returns the base fee
-     *  in lamports to be added to the transaction) - this fee doesn't scale with CUs of the transaction and is instead
-     *  applied as-is
-     * @param bribeData Bribe fee configuration (used for e.g. Jito tips)
-     */
-    constructor(
-        connection: Connection,
-        maxFeeMicroLamports: number = 250000,
-        numSamples: number = 8,
-        period: number = 150,
-        useHeliusApi: "yes" | "no" | "auto" = "auto",
-        heliusFeeLevel: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax" = "veryHigh",
-        getStaticFee?: (feeRate: bigint) => bigint,
-        bribeData?: FeeBribeData,
-    ) {
-        this.connection = connection;
-        this.maxFeeMicroLamports = BigInt(maxFeeMicroLamports);
-        this.numSamples = numSamples;
-        this.period = period;
-        this.useHeliusApi = useHeliusApi;
-        this.heliusFeeLevel = heliusFeeLevel;
-        this.bribeData = bribeData;
-        this.getStaticFee = getStaticFee;
-    }
-
-    /**
-     * Returns solana block with transactionDetails="signatures"
-     *
-     * @param slot
-     * @private
-     */
-    private async getBlockWithSignature(slot: number): Promise<ParsedNoneModeBlockResponse & {signatures: string[]} | null> {
-        const response = await (this.connection as any)._rpcRequest("getBlock", [
-            slot,
-            {
-                encoding: "json",
-                transactionDetails: "signatures",
-                commitment: "confirmed",
-                rewards: true
-            }
-        ]);
-
-        if(response.error!=null) {
-            if(response.error.code===-32004 || response.error.code===-32007 || response.error.code===-32009 || response.error.code===-32014) {
-                return null;
-            }
-            throw new Error(response.error.message);
-        }
-
-        return response.result;
-    }
-
-    /**
-     * Returns fee estimate from Helius API - only works with Helius RPC, return null for all other RPC providers
-     *
-     * @param mutableAccounts
-     * @private
-     */
-    private async getPriorityFeeEstimate(mutableAccounts: PublicKey[]): Promise<{
-        "min": number,
-        "low": number,
-        "medium": number,
-        "high": number,
-        "veryHigh": number,
-        "unsafeMax": number
-    } | null> {
-        //Try to use getPriorityFeeEstimate api of Helius
-        const response = await (this.connection as any)._rpcRequest("getPriorityFeeEstimate", [
-            {
-                "accountKeys": mutableAccounts.map(e => e.toBase58()),
-                "options": {
-                    "includeAllPriorityFeeLevels": true
-                }
-            }
-        ]).catch((e: any) => {
-            //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 response.result.priorityFeeLevels;
-    }
-
-    /**
-     * Sends the transaction over Jito
-     *
-     * @param tx
-     * @param options
-     * @private
-     * @returns {Promise<string>} transaction signature
-     */
-    private async sendJitoTx(tx: Buffer, options?: SendOptions): Promise<string> {
-        if(this.bribeData?.endpoint==null) throw new Error("Jito endpoint not specified!");
-        if(options==null) options = {};
-        const request = await fetch(this.bribeData.endpoint, {
-            method: "POST",
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method: "sendTransaction",
-                params: [tx.toString("base64"), {
-                    ...options,
-                    encoding: "base64"
-                }],
-            }),
-            headers: {
-                "Content-Type": "application/json"
-            }
-        });
-
-        if(request.ok) {
-            const parsedResponse = await request.json();
-            return parsedResponse.result;
-        }
-
-        throw new Error(await request.text());
-    }
-
-    /**
-     * Checks whether the transaction should be sent over Jito, returns the fee paid to Jito in case the transaction
-     *  should be sent over Jito, returns null if the transaction shouldn't be sent over Jito
-     *
-     * @param parsedTx
-     * @private
-     */
-    private getJitoTxFee(parsedTx: Transaction): bigint | null {
-        const lastIx = parsedTx.instructions[parsedTx.instructions.length-1];
-
-        if(!lastIx.programId.equals(SystemProgram.programId)) return null;
-        if(SystemInstruction.decodeInstructionType(lastIx)!=="Transfer") return null;
-
-        const decodedIxData = SystemInstruction.decodeTransfer(lastIx);
-        if(decodedIxData.toPubkey.toBase58()!==this.bribeData?.address) return null;
-        return decodedIxData.lamports;
-    }
-
-    /**
-     * Gets the mean microLamports/CU fee rate for the block at a specific slot
-     *
-     * @param slot
-     * @private
-     */
-    private async getBlockMeanFeeRate(slot: number): Promise<bigint | null> {
-        const block = await this.getBlockWithSignature(slot);
-        if(block==null || block.rewards==null) return null;
-
-        const blockComission = block.rewards.find(e => e.rewardType==="Fee");
-        if(blockComission==null) return null;
-        const totalBlockFees: bigint = BigInt(blockComission.lamports) * 2n;
-
-        //Subtract per-signature fees to get pure compute fees
-        const totalTransactionBaseFees = BigInt(block.signatures.length) * 5000n;
-        const computeFees = totalBlockFees - totalTransactionBaseFees;
-
-        //Total compute fees in micro lamports
-        const computeFeesMicroLamports = computeFees * 1000000n;
-        //micro lamports per CU considering block was full (48M compute units)
-        const perCUMicroLamports = computeFeesMicroLamports / 48000000n;
-
-        this.logger.debug("getBlockMeanFeeRate(): slot: "+slot+" total reward: "+totalBlockFees.toString(10)+
-            " total transactions: "+block.signatures.length+" computed fee: "+perCUMicroLamports);
-
-        return perCUMicroLamports;
-    }
-
-    /**
-     * Manually gets global fee rate by sampling random blocks over the last period
-     *
-     * @private
-     * @returns {Promise<BN>} sampled mean microLamports/CU fee over the last period
-     */
-    private async _getGlobalFeeRate(): Promise<bigint> {
-        let slot = await this.connection.getSlot();
-
-        const slots: number[] = [];
-
-        for(let i=0;i<this.period;i++) {
-            slots.push(slot-i);
-        }
-
-        const promises: Promise<bigint>[] = [];
-        for(let i=0;i<this.numSamples;i++) {
-            promises.push((async () => {
-                let feeRate: bigint | null = null;
-                while(feeRate==null) {
-                    if(slots.length===0) throw new Error("Ran out of slots to check!");
-                    const index = Math.floor(Math.random()*slots.length);
-                    const slotNumber = slots[index];
-                    slots.splice(index, 1);
-                    feeRate = await this.getBlockMeanFeeRate(slotNumber);
-                }
-                return feeRate;
-            })());
-        }
-
-        const meanFees = await Promise.all(promises);
-        const min = meanFees.reduce(
-            (prev: bigint | null, current: bigint) => prev==null || prev>current ? current : prev,
-            null
-        );
-
-        if(min==null) throw new Error("Cannot estimate fee, meanFees length is 0");
-
-        this.logger.debug("_getGlobalFeeRate(): slot: "+slot+" global fee minimum: "+min.toString(10));
-
-        return min;
-    }
-
-    /**
-     * Gets the combined microLamports/CU fee rate (from localized & global fee market)
-     *
-     * @param mutableAccounts
-     * @private
-     */
-    private async _getFeeRate(mutableAccounts: PublicKey[]): Promise<bigint> {
-        if(this.useHeliusApi==="yes" || (this.useHeliusApi==="auto" && this.heliusApiSupported)) {
-            //Try to use getPriorityFeeEstimate api of Helius
-            const fees = await this.getPriorityFeeEstimate(mutableAccounts);
-            if(fees!=null) {
-                let calculatedFee = BigInt(fees[this.heliusFeeLevel]);
-                if(calculatedFee < 8000n) calculatedFee = 8000n;
-                if(calculatedFee > this.maxFeeMicroLamports) calculatedFee = this.maxFeeMicroLamports;
-                return calculatedFee;
-            }
-            this.logger.warn("_getFeeRate(): tried fetching fees from Helius API, not supported," +
-                " falling back to client-side fee estimation");
-            this.heliusApiSupported = false;
-        }
-
-        const [globalFeeRate, localFeeRate] = await Promise.all([
-            this.getGlobalFeeRate(),
-            this.connection.getRecentPrioritizationFees({
-                lockedWritableAccounts: mutableAccounts
-            }).then(resp => {
-                let lamports = 0;
-                for(let i=20;i>=0;i--) {
-                    const data = resp[resp.length-i-1];
-                    if(data!=null) lamports = Math.min(lamports, data.prioritizationFee);
-                }
-                return BigInt(lamports);
-            })
-        ]);
-
-        let fee = globalFeeRate;
-        if(fee < localFeeRate) fee = localFeeRate;
-        if(fee < 8000n) fee = 8000n;
-        if(fee > this.maxFeeMicroLamports) fee = this.maxFeeMicroLamports;
-
-        return fee;
-    }
-
-    /**
-     * Gets global fee rate, with caching
-     *
-     * @returns {Promise<BN>} global fee rate microLamports/CU
-     */
-    public getGlobalFeeRate(): Promise<bigint> {
-        if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > MAX_FEE_AGE) {
-            let obj: {timestamp: number, feeRate: Promise<bigint>};
-            this.blockFeeCache = obj = {
-                timestamp: Date.now(),
-                feeRate: this._getGlobalFeeRate().catch(e => {
-                    if(this.blockFeeCache===obj) delete this.blockFeeCache;
-                    throw e;
-                })
-            };
-        }
-
-        return this.blockFeeCache.feeRate;
-    }
-
-    /**
-     * Gets the combined microLamports/CU fee rate (from localized & global fee market), cached & adjusted as for
-     *  when bribe and/or static fee should be included, format: <uLamports/CU>;<static fee lamport>[;<bribe address>]
-     *
-     * @param mutableAccounts
-     * @private
-     */
-    public async getFeeRate(mutableAccounts: PublicKey[]): Promise<string> {
-        let feeMicroLamportPerCU = await this._getFeeRate(mutableAccounts);
-        if(this.bribeData?.getBribeFee!=null) feeMicroLamportPerCU = this.bribeData.getBribeFee(feeMicroLamportPerCU);
-
-        let fee: string = feeMicroLamportPerCU.toString(10);
-        if(this.getStaticFee!=null) {
-            fee += ";"+this.getStaticFee(feeMicroLamportPerCU);
-        } else {
-            fee += ";0"
-        }
-
-        if(this.bribeData?.address) {
-            fee += ";"+this.bribeData.address;
-        }
-
-        this.logger.debug("getFeeRate(): calculated fee: "+fee);
-
-        return fee;
-    }
-
-    /**
-     * Calculates the total priority fee paid for a given compute budget at a given fee rate
-     *
-     * @param computeUnits
-     * @param feeRate
-     * @param includeStaticFee whether the include the static/base part of the fee rate
-     */
-    public getPriorityFee(computeUnits: number, feeRate: string, includeStaticFee: boolean = true): bigint {
-        if(feeRate==null) return 0n;
-
-        const hashArr = feeRate.split("#");
-        if(hashArr.length>1) {
-            feeRate = hashArr[0];
-        }
-
-        const arr = feeRate.split(";");
-        const cuPrice = BigInt(arr[0]);
-        const staticFee = includeStaticFee ? BigInt(arr[1]) : 0n;
-
-        return staticFee + (cuPrice * BigInt(computeUnits) / 1000000n);
-    }
-
-    /**
-     * Applies fee rate to a transaction, should be called before adding instructions to the transaction, specifically
-     *  it adds the setComputeUnitLimit & setComputeUnitPrice instruction.
-     *
-     * @example
-     * ```typescript
-     * const feeRate = solanaFees.getFeeRate([...writeableAccounts]);
-     * const tx = new Transaction();
-     * //Apply the fee rate part at the beginning of the transaction (specifically setComputeUnitLimit & setComputeUnitPrice)
-     * SolanaFees.applyFeeRateBegin(tx, feeRate);
-     * //Add instructions here
-     * tx.add(instruction1);
-     * tx.add(instruction2);
-     * //Set the fee payer
-     * tx.feePayer = feePayerPublicKey;
-     * //Apply the fee rate part at the end of the transaction (specifically the transfer to the bribe account, e.g. Jito tip)
-     * SolanaFees.applyFeeRateEnd(tx, feeRate);
-     * ```
-     *
-     * @param tx
-     * @param computeBudget
-     * @param feeRate
-     */
-    public static applyFeeRateBegin(tx: Transaction, computeBudget: number | null, feeRate: string) {
-        if(feeRate==null) return;
-
-        const hashArr = feeRate.split("#");
-        if(hashArr.length>1) {
-            feeRate = hashArr[0];
-        }
-
-        if(computeBudget!=null && computeBudget>0) tx.add(ComputeBudgetProgram.setComputeUnitLimit({
-            units: computeBudget,
-        }));
-
-        //Check if bribe is included
-        const arr = feeRate.split(";");
-        if(arr.length>2) {
-
-        } else {
-            let fee: bigint = BigInt(arr[0]);
-            if(arr.length>1) {
-                const staticFee = BigInt(arr[1]);
-                const cuBigInt = BigInt(computeBudget || (200000*SolanaTxUtils.getNonComputeBudgetIxs(tx)));
-                const staticFeePerCU = staticFee*BigInt(1000000)/cuBigInt;
-                fee += staticFeePerCU;
-            }
-            tx.add(ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: fee
-            }));
-        }
-    }
-
-    /**
-     * Applies fee rate to a transaction, should be called after adding instructions to the transaction, specifically
-     *  it adds the adds the bribe SystemProgram.transfer instruction.
-     *
-     * @example
-     * ```typescript
-     * const feeRate = solanaFees.getFeeRate([...writeableAccounts]);
-     * const tx = new Transaction();
-     * //Apply the fee rate part at the beginning of the transaction (specifically setComputeUnitLimit & setComputeUnitPrice)
-     * SolanaFees.applyFeeRateBegin(tx, feeRate);
-     * //Add instructions here
-     * tx.add(instruction1);
-     * tx.add(instruction2);
-     * //Set the fee payer
-     * tx.feePayer = feePayerPublicKey;
-     * //Apply the fee rate part at the end of the transaction (specifically the transfer to the bribe account, e.g. Jito tip)
-     * SolanaFees.applyFeeRateEnd(tx, feeRate);
-     * ```
-     *
-     * @param tx
-     * @param computeBudget
-     * @param feeRate
-     */
-    public static applyFeeRateEnd(tx: Transaction, computeBudget: number | null, feeRate: string) {
-        if(feeRate==null) return;
-
-        const hashArr = feeRate.split("#");
-        if(hashArr.length>1) {
-            feeRate = hashArr[0];
-        }
-
-        //Check if bribe is included
-        const arr = feeRate.split(";");
-        if(arr.length>2) {
-            const cuBigInt = BigInt(computeBudget ?? (200000*(SolanaTxUtils.getNonComputeBudgetIxs(tx)+1)));
-            const cuPrice = BigInt(arr[0]);
-            const staticFee = BigInt(arr[1]);
-            const bribeAddress = new PublicKey(arr[2]);
-            if(tx.feePayer==null) throw new Error("Cannot apply tx bribe without feePayer being known!");
-            tx.add(SystemProgram.transfer({
-                fromPubkey: tx.feePayer,
-                toPubkey: bribeAddress,
-                lamports: staticFee + (cuBigInt*cuPrice/BigInt(1000000))
-            }));
-            return;
-        }
-    }
-
-    /**
-     * Checks if the transaction should be submitted over Jito and if yes submits it
-     *
-     * @param tx Raw signed transaction to be attempted to be sent over Jito
-     * @param options Send options for the sendTransaction RPC call
-     * @returns {Promise<string | null>} null if the transaction was not sent over Jito, tx signature when tx was sent over Jito
-     */
-    submitTx(tx: Buffer, options?: SendOptions): Promise<string | null> {
-        const parsedTx = Transaction.from(tx);
-        const jitoFee = this.getJitoTxFee(parsedTx);
-        if(jitoFee==null) return Promise.resolve(null);
-
-        this.logger.info("submitTx(): sending tx over Jito, signature: "+parsedTx.signature+" fee: "+jitoFee.toString(10));
-        return this.sendJitoTx(tx, options);
-    }
-
-}
+import {
+    ComputeBudgetProgram,
+    Connection,
+    ParsedNoneModeBlockResponse,
+    PublicKey,
+    SendOptions,
+    SystemInstruction,
+    SystemProgram,
+    Transaction
+} from "@solana/web3.js";
+import {getLogger, SolanaTxUtils} from "../../../utils/Utils";
+
+const MAX_FEE_AGE = 5000;
+
+/**
+ * Bribe configuration used for Jito-like tips that handled outside of native Solana network fees
+ *
+ * @category Chain Interface
+ */
+export type FeeBribeData = {
+    /**
+     * Address to send the bribe to (e.g. Jito tip)
+     */
+    address: string,
+    /**
+     * HTTP endpoint to send the transaction to instead of the RPC, e.g. a Jito endpoint
+     */
+    endpoint: string,
+    /**
+     * An optional function for overriding the bribe to be sent to the specified address for the tx
+     */
+    getBribeFee?: (original: bigint) => bigint
+};
+
+/**
+ * Fee estimation service for the Solana network. Uses client-side fee estimation algorithm by default, which
+ *  fetches a bunch (default 8) random blocks in the past period (default 150) and computes the average fee. It
+ *  automatically detects whether the underlying RPC endpoint is a Helius one which features the `getPriorityFeeEstimate`
+ *  endpoint, and if available uses that one.
+ *
+ * @category Chain Interface
+ */
+export class SolanaFees {
+
+    private readonly connection: Connection;
+    private readonly maxFeeMicroLamports: bigint;
+    private readonly numSamples: number;
+    private readonly period: number;
+    private useHeliusApi: "yes" | "no" | "auto";
+    private heliusApiSupported: boolean = true;
+    private readonly heliusFeeLevel: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax";
+    private readonly bribeData?: FeeBribeData;
+    private readonly getStaticFee?: (original: bigint) => bigint;
+
+    private readonly logger = getLogger("SolanaFees: ");
+
+    private blockFeeCache?: {
+        timestamp: number,
+        feeRate: Promise<bigint>
+    };
+
+    /**
+     * @param connection Underlying Solana network connection to use for read access to Solana
+     * @param maxFeeMicroLamports Maximum allowed fee in microLamports/CU (1/1,000,000 of a lamport per compute unit)
+     * @param numSamples Number of samples to use when estimating the global fee on the client-side, this many blocks are
+     *  sampled from the last `period` blocks to estimate an average fee rate
+     * @param period Period of past blocks to sample random blocks from when estimating the global fee on the client-side
+     * @param useHeliusApi Whether to use the helius API or not, default to `"auto"`, which automatically detects if the
+     *  underlying RPC supports Helius's `getPriorityFeeEstimate` RPC call
+     * @param heliusFeeLevel Fee level to use when fetching the fee rate from Helius's `getPriorityFeeEstimate` RPC endpoint,
+     *  for the meaning of the different levels refer to https://www.helius.dev/docs/priority-fee-api#priority-levels-explained
+     * @param getStaticFee Optional function for adding a base fee to transactions (this function returns the base fee
+     *  in lamports to be added to the transaction) - this fee doesn't scale with CUs of the transaction and is instead
+     *  applied as-is
+     * @param bribeData Bribe fee configuration (used for e.g. Jito tips)
+     */
+    constructor(
+        connection: Connection,
+        maxFeeMicroLamports: number = 250000,
+        numSamples: number = 8,
+        period: number = 150,
+        useHeliusApi: "yes" | "no" | "auto" = "auto",
+        heliusFeeLevel: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax" = "veryHigh",
+        getStaticFee?: (feeRate: bigint) => bigint,
+        bribeData?: FeeBribeData,
+    ) {
+        this.connection = connection;
+        this.maxFeeMicroLamports = BigInt(maxFeeMicroLamports);
+        this.numSamples = numSamples;
+        this.period = period;
+        this.useHeliusApi = useHeliusApi;
+        this.heliusFeeLevel = heliusFeeLevel;
+        this.bribeData = bribeData;
+        this.getStaticFee = getStaticFee;
+    }
+
+    /**
+     * Returns solana block with transactionDetails="signatures"
+     *
+     * @param slot
+     * @private
+     */
+    private async getBlockWithSignature(slot: number): Promise<ParsedNoneModeBlockResponse & {signatures: string[]} | null> {
+        const response = await (this.connection as any)._rpcRequest("getBlock", [
+            slot,
+            {
+                encoding: "json",
+                transactionDetails: "signatures",
+                commitment: "confirmed",
+                rewards: true
+            }
+        ]);
+
+        if(response.error!=null) {
+            if(response.error.code===-32004 || response.error.code===-32007 || response.error.code===-32009 || response.error.code===-32014) {
+                return null;
+            }
+            throw new Error(response.error.message);
+        }
+
+        return response.result;
+    }
+
+    /**
+     * Returns fee estimate from Helius API - only works with Helius RPC, return null for all other RPC providers
+     *
+     * @param mutableAccounts
+     * @private
+     */
+    private async getPriorityFeeEstimate(mutableAccounts: PublicKey[]): Promise<{
+        "min": number,
+        "low": number,
+        "medium": number,
+        "high": number,
+        "veryHigh": number,
+        "unsafeMax": number
+    } | null> {
+        //Try to use getPriorityFeeEstimate api of Helius
+        const response = await (this.connection as any)._rpcRequest("getPriorityFeeEstimate", [
+            {
+                "accountKeys": mutableAccounts.map(e => e.toBase58()),
+                "options": {
+                    "includeAllPriorityFeeLevels": true
+                }
+            }
+        ]).catch((e: any) => {
+            //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 response.result.priorityFeeLevels;
+    }
+
+    /**
+     * Sends the transaction over Jito
+     *
+     * @param tx
+     * @param options
+     * @private
+     * @returns {Promise<string>} transaction signature
+     */
+    private async sendJitoTx(tx: Buffer, options?: SendOptions): Promise<string> {
+        if(this.bribeData?.endpoint==null) throw new Error("Jito endpoint not specified!");
+        if(options==null) options = {};
+        const request = await fetch(this.bribeData.endpoint, {
+            method: "POST",
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "sendTransaction",
+                params: [tx.toString("base64"), {
+                    ...options,
+                    encoding: "base64"
+                }],
+            }),
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+
+        if(request.ok) {
+            const parsedResponse = await request.json();
+            return parsedResponse.result;
+        }
+
+        throw new Error(await request.text());
+    }
+
+    /**
+     * Checks whether the transaction should be sent over Jito, returns the fee paid to Jito in case the transaction
+     *  should be sent over Jito, returns null if the transaction shouldn't be sent over Jito
+     *
+     * @param parsedTx
+     * @private
+     */
+    private getJitoTxFee(parsedTx: Transaction): bigint | null {
+        const lastIx = parsedTx.instructions[parsedTx.instructions.length-1];
+
+        if(!lastIx.programId.equals(SystemProgram.programId)) return null;
+        if(SystemInstruction.decodeInstructionType(lastIx)!=="Transfer") return null;
+
+        const decodedIxData = SystemInstruction.decodeTransfer(lastIx);
+        if(decodedIxData.toPubkey.toBase58()!==this.bribeData?.address) return null;
+        return decodedIxData.lamports;
+    }
+
+    /**
+     * Gets the mean microLamports/CU fee rate for the block at a specific slot
+     *
+     * @param slot
+     * @private
+     */
+    private async getBlockMeanFeeRate(slot: number): Promise<bigint | null> {
+        const block = await this.getBlockWithSignature(slot);
+        if(block==null || block.rewards==null) return null;
+
+        const blockComission = block.rewards.find(e => e.rewardType==="Fee");
+        if(blockComission==null) return null;
+        const totalBlockFees: bigint = BigInt(blockComission.lamports) * 2n;
+
+        //Subtract per-signature fees to get pure compute fees
+        const totalTransactionBaseFees = BigInt(block.signatures.length) * 5000n;
+        const computeFees = totalBlockFees - totalTransactionBaseFees;
+
+        //Total compute fees in micro lamports
+        const computeFeesMicroLamports = computeFees * 1000000n;
+        //micro lamports per CU considering block was full (48M compute units)
+        const perCUMicroLamports = computeFeesMicroLamports / 48000000n;
+
+        this.logger.debug("getBlockMeanFeeRate(): slot: "+slot+" total reward: "+totalBlockFees.toString(10)+
+            " total transactions: "+block.signatures.length+" computed fee: "+perCUMicroLamports);
+
+        return perCUMicroLamports;
+    }
+
+    /**
+     * Manually gets global fee rate by sampling random blocks over the last period
+     *
+     * @private
+     * @returns {Promise<BN>} sampled mean microLamports/CU fee over the last period
+     */
+    private async _getGlobalFeeRate(): Promise<bigint> {
+        let slot = await this.connection.getSlot();
+
+        const slots: number[] = [];
+
+        for(let i=0;i<this.period;i++) {
+            slots.push(slot-i);
+        }
+
+        const promises: Promise<bigint>[] = [];
+        for(let i=0;i<this.numSamples;i++) {
+            promises.push((async () => {
+                let feeRate: bigint | null = null;
+                while(feeRate==null) {
+                    if(slots.length===0) throw new Error("Ran out of slots to check!");
+                    const index = Math.floor(Math.random()*slots.length);
+                    const slotNumber = slots[index];
+                    slots.splice(index, 1);
+                    feeRate = await this.getBlockMeanFeeRate(slotNumber);
+                }
+                return feeRate;
+            })());
+        }
+
+        const meanFees = await Promise.all(promises);
+        const min = meanFees.reduce(
+            (prev: bigint | null, current: bigint) => prev==null || prev>current ? current : prev,
+            null
+        );
+
+        if(min==null) throw new Error("Cannot estimate fee, meanFees length is 0");
+
+        this.logger.debug("_getGlobalFeeRate(): slot: "+slot+" global fee minimum: "+min.toString(10));
+
+        return min;
+    }
+
+    /**
+     * Gets the combined microLamports/CU fee rate (from localized & global fee market)
+     *
+     * @param mutableAccounts
+     * @private
+     */
+    private async _getFeeRate(mutableAccounts: PublicKey[]): Promise<bigint> {
+        if(this.useHeliusApi==="yes" || (this.useHeliusApi==="auto" && this.heliusApiSupported)) {
+            //Try to use getPriorityFeeEstimate api of Helius
+            const fees = await this.getPriorityFeeEstimate(mutableAccounts);
+            if(fees!=null) {
+                let calculatedFee = BigInt(fees[this.heliusFeeLevel]);
+                if(calculatedFee < 8000n) calculatedFee = 8000n;
+                if(calculatedFee > this.maxFeeMicroLamports) calculatedFee = this.maxFeeMicroLamports;
+                return calculatedFee;
+            }
+            this.logger.warn("_getFeeRate(): tried fetching fees from Helius API, not supported," +
+                " falling back to client-side fee estimation");
+            this.heliusApiSupported = false;
+        }
+
+        const [globalFeeRate, localFeeRate] = await Promise.all([
+            this.getGlobalFeeRate(),
+            this.connection.getRecentPrioritizationFees({
+                lockedWritableAccounts: mutableAccounts
+            }).then(resp => {
+                let lamports = 0;
+                for(let i=20;i>=0;i--) {
+                    const data = resp[resp.length-i-1];
+                    if(data!=null) lamports = Math.min(lamports, data.prioritizationFee);
+                }
+                return BigInt(lamports);
+            })
+        ]);
+
+        let fee = globalFeeRate;
+        if(fee < localFeeRate) fee = localFeeRate;
+        if(fee < 8000n) fee = 8000n;
+        if(fee > this.maxFeeMicroLamports) fee = this.maxFeeMicroLamports;
+
+        return fee;
+    }
+
+    /**
+     * Gets global fee rate, with caching
+     *
+     * @returns {Promise<BN>} global fee rate microLamports/CU
+     */
+    public getGlobalFeeRate(): Promise<bigint> {
+        if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > MAX_FEE_AGE) {
+            let obj: {timestamp: number, feeRate: Promise<bigint>};
+            this.blockFeeCache = obj = {
+                timestamp: Date.now(),
+                feeRate: this._getGlobalFeeRate().catch(e => {
+                    if(this.blockFeeCache===obj) delete this.blockFeeCache;
+                    throw e;
+                })
+            };
+        }
+
+        return this.blockFeeCache.feeRate;
+    }
+
+    /**
+     * Gets the combined microLamports/CU fee rate (from localized & global fee market), cached & adjusted as for
+     *  when bribe and/or static fee should be included, format: <uLamports/CU>;<static fee lamport>[;<bribe address>]
+     *
+     * @param mutableAccounts
+     * @private
+     */
+    public async getFeeRate(mutableAccounts: PublicKey[]): Promise<string> {
+        let feeMicroLamportPerCU = await this._getFeeRate(mutableAccounts);
+        if(this.bribeData?.getBribeFee!=null) feeMicroLamportPerCU = this.bribeData.getBribeFee(feeMicroLamportPerCU);
+
+        let fee: string = feeMicroLamportPerCU.toString(10);
+        if(this.getStaticFee!=null) {
+            fee += ";"+this.getStaticFee(feeMicroLamportPerCU);
+        } else {
+            fee += ";0"
+        }
+
+        if(this.bribeData?.address) {
+            fee += ";"+this.bribeData.address;
+        }
+
+        this.logger.debug("getFeeRate(): calculated fee: "+fee);
+
+        return fee;
+    }
+
+    /**
+     * Calculates the total priority fee paid for a given compute budget at a given fee rate
+     *
+     * @param computeUnits
+     * @param feeRate
+     * @param includeStaticFee whether the include the static/base part of the fee rate
+     */
+    public getPriorityFee(computeUnits: number, feeRate: string, includeStaticFee: boolean = true): bigint {
+        if(feeRate==null) return 0n;
+
+        const hashArr = feeRate.split("#");
+        if(hashArr.length>1) {
+            feeRate = hashArr[0];
+        }
+
+        const arr = feeRate.split(";");
+        const cuPrice = BigInt(arr[0]);
+        const staticFee = includeStaticFee ? BigInt(arr[1]) : 0n;
+
+        return staticFee + (cuPrice * BigInt(computeUnits) / 1000000n);
+    }
+
+    /**
+     * Applies fee rate to a transaction, should be called before adding instructions to the transaction, specifically
+     *  it adds the setComputeUnitLimit & setComputeUnitPrice instruction.
+     *
+     * @example
+     * ```typescript
+     * const feeRate = solanaFees.getFeeRate([...writeableAccounts]);
+     * const tx = new Transaction();
+     * //Apply the fee rate part at the beginning of the transaction (specifically setComputeUnitLimit & setComputeUnitPrice)
+     * SolanaFees.applyFeeRateBegin(tx, feeRate);
+     * //Add instructions here
+     * tx.add(instruction1);
+     * tx.add(instruction2);
+     * //Set the fee payer
+     * tx.feePayer = feePayerPublicKey;
+     * //Apply the fee rate part at the end of the transaction (specifically the transfer to the bribe account, e.g. Jito tip)
+     * SolanaFees.applyFeeRateEnd(tx, feeRate);
+     * ```
+     *
+     * @param tx
+     * @param computeBudget
+     * @param feeRate
+     */
+    public static applyFeeRateBegin(tx: Transaction, computeBudget: number | null, feeRate: string) {
+        if(feeRate==null) return;
+
+        const hashArr = feeRate.split("#");
+        if(hashArr.length>1) {
+            feeRate = hashArr[0];
+        }
+
+        if(computeBudget!=null && computeBudget>0) tx.add(ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeBudget,
+        }));
+
+        //Check if bribe is included
+        const arr = feeRate.split(";");
+        if(arr.length>2) {
+
+        } else {
+            let fee: bigint = BigInt(arr[0]);
+            if(arr.length>1) {
+                const staticFee = BigInt(arr[1]);
+                const cuBigInt = BigInt(computeBudget || (200000*SolanaTxUtils.getNonComputeBudgetIxs(tx)));
+                const staticFeePerCU = staticFee*BigInt(1000000)/cuBigInt;
+                fee += staticFeePerCU;
+            }
+            tx.add(ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: fee
+            }));
+        }
+    }
+
+    /**
+     * Applies fee rate to a transaction, should be called after adding instructions to the transaction, specifically
+     *  it adds the adds the bribe SystemProgram.transfer instruction.
+     *
+     * @example
+     * ```typescript
+     * const feeRate = solanaFees.getFeeRate([...writeableAccounts]);
+     * const tx = new Transaction();
+     * //Apply the fee rate part at the beginning of the transaction (specifically setComputeUnitLimit & setComputeUnitPrice)
+     * SolanaFees.applyFeeRateBegin(tx, feeRate);
+     * //Add instructions here
+     * tx.add(instruction1);
+     * tx.add(instruction2);
+     * //Set the fee payer
+     * tx.feePayer = feePayerPublicKey;
+     * //Apply the fee rate part at the end of the transaction (specifically the transfer to the bribe account, e.g. Jito tip)
+     * SolanaFees.applyFeeRateEnd(tx, feeRate);
+     * ```
+     *
+     * @param tx
+     * @param computeBudget
+     * @param feeRate
+     */
+    public static applyFeeRateEnd(tx: Transaction, computeBudget: number | null, feeRate: string) {
+        if(feeRate==null) return;
+
+        const hashArr = feeRate.split("#");
+        if(hashArr.length>1) {
+            feeRate = hashArr[0];
+        }
+
+        //Check if bribe is included
+        const arr = feeRate.split(";");
+        if(arr.length>2) {
+            const cuBigInt = BigInt(computeBudget ?? (200000*(SolanaTxUtils.getNonComputeBudgetIxs(tx)+1)));
+            const cuPrice = BigInt(arr[0]);
+            const staticFee = BigInt(arr[1]);
+            const bribeAddress = new PublicKey(arr[2]);
+            if(tx.feePayer==null) throw new Error("Cannot apply tx bribe without feePayer being known!");
+            tx.add(SystemProgram.transfer({
+                fromPubkey: tx.feePayer,
+                toPubkey: bribeAddress,
+                lamports: staticFee + (cuBigInt*cuPrice/BigInt(1000000))
+            }));
+            return;
+        }
+    }
+
+    /**
+     * Checks if the transaction should be submitted over Jito and if yes submits it
+     *
+     * @param tx Raw signed transaction to be attempted to be sent over Jito
+     * @param options Send options for the sendTransaction RPC call
+     * @returns {Promise<string | null>} null if the transaction was not sent over Jito, tx signature when tx was sent over Jito
+     */
+    submitTx(tx: Buffer, options?: SendOptions): Promise<string | null> {
+        const parsedTx = Transaction.from(tx);
+        const jitoFee = this.getJitoTxFee(parsedTx);
+        if(jitoFee==null) return Promise.resolve(null);
+
+        this.logger.info("submitTx(): sending tx over Jito, signature: "+parsedTx.signature+" fee: "+jitoFee.toString(10));
+        return this.sendJitoTx(tx, options);
+    }
+
+}