@drift-labs/sdk 2.91.0-beta.1 → 2.91.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.91.0-beta.1
+2.91.0-beta.2

package/lib/tx/baseTxSender.d.ts

@@ -3,6 +3,7 @@ import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
 import { TxHandler } from './txHandler';
 import { IWallet } from '../types';
+import NodeCache from 'node-cache';
 export declare abstract class BaseTxSender implements TxSender {
     connection: Connection;
     wallet: IWallet;
@@ -13,7 +14,13 @@ export declare abstract class BaseTxSender implements TxSender {
     confirmationStrategy: ConfirmationStrategy;
     additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
     txHandler: TxHandler;
-    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, txHandler, }: {
+    trackTxLandRate?: boolean;
+    lookbackWindowMinutes: number;
+    txSigCache?: NodeCache;
+    txLandRate: number;
+    lastPriorityFeeSuggestion: number;
+    landRateToFeeFunc: (landRate: number) => number;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -22,6 +29,9 @@ export declare abstract class BaseTxSender implements TxSender {
         confirmationStrategy?: ConfirmationStrategy;
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
         txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
     });
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
@@ -39,4 +49,7 @@ export declare abstract class BaseTxSender implements TxSender {
     getTimeoutCount(): number;
     checkConfirmationResultForError(txSig: string, result: RpcResponseAndContext<SignatureResult>): Promise<void>;
     reportTransactionError(txSig: string): Promise<any>;
+    getTxLandRate(): number;
+    private defaultLandRateToFeeFunc;
+    getSuggestedPriorityFeeMultiplier(): number;
 }

package/lib/tx/baseTxSender.js

@@ -10,11 +10,17 @@ const anchor_1 = require("@coral-xyz/anchor");
 const assert_1 = __importDefault(require("assert"));
 const bs58_1 = __importDefault(require("bs58"));
 const txHandler_1 = require("./txHandler");
+const node_cache_1 = __importDefault(require("node-cache"));
+const BASELINE_TX_LAND_RATE = 0.9;
 const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES = 10;
 const NOT_CONFIRMED_ERROR_CODE = -1001;
 class BaseTxSender {
-    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks, txHandler, }) {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes = DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES *
+        60, landRateToFeeFunc, }) {
         this.timeoutCount = 0;
+        this.txLandRate = 0;
+        this.lastPriorityFeeSuggestion = 1;
         this.connection = connection;
         this.wallet = wallet;
         this.opts = opts;
@@ -28,6 +34,16 @@ class BaseTxSender {
                 wallet: this.wallet,
                 confirmationOptions: this.opts,
             });
+        this.trackTxLandRate = trackTxLandRate;
+        this.lookbackWindowMinutes = txLandRateLookbackWindowMinutes * 60;
+        if (this.trackTxLandRate) {
+            this.txSigCache = new node_cache_1.default({
+                stdTTL: this.lookbackWindowMinutes,
+                checkperiod: 120,
+            });
+        }
+        this.landRateToFeeFunc =
+            landRateToFeeFunc !== null && landRateToFeeFunc !== void 0 ? landRateToFeeFunc : this.defaultLandRateToFeeFunc.bind(this);
     }
     async send(tx, additionalSigners, opts, preSigned) {
         if (additionalSigners === undefined) {
@@ -246,5 +262,40 @@ class BaseTxSender {
             logs,
         });
     }
+    getTxLandRate() {
+        if (!this.trackTxLandRate) {
+            console.warn('trackTxLandRate is false, returning default land rate of 0');
+            return this.txLandRate;
+        }
+        const keys = this.txSigCache.keys();
+        const denominator = keys.length;
+        if (denominator === 0) {
+            return this.txLandRate;
+        }
+        let numerator = 0;
+        for (const key of keys) {
+            const value = this.txSigCache.get(key);
+            if (value) {
+                numerator += 1;
+            }
+        }
+        this.txLandRate = numerator / denominator;
+        return this.txLandRate;
+    }
+    defaultLandRateToFeeFunc(txLandRate) {
+        if (txLandRate >= BASELINE_TX_LAND_RATE ||
+            this.txSigCache.keys().length < 3) {
+            return 1;
+        }
+        const multiplier = 10 * Math.log10(1 + (BASELINE_TX_LAND_RATE - txLandRate) * 5);
+        return Math.min(multiplier, 10);
+    }
+    getSuggestedPriorityFeeMultiplier() {
+        if (!this.trackTxLandRate) {
+            console.warn('trackTxLandRate is false, returning default multiplier of 1');
+            return 1;
+        }
+        return this.landRateToFeeFunc(this.getTxLandRate());
+    }
 }
 exports.BaseTxSender = BaseTxSender;

package/lib/tx/fastSingleTxSender.d.ts

@@ -15,9 +15,10 @@ export declare class FastSingleTxSender extends BaseTxSender {
     timoutCount: number;
     recentBlockhash: BlockhashWithExpiryBlockHeight;
     skipConfirmation: boolean;
+    confirmInBackground: boolean;
     blockhashCommitment: Commitment;
     blockhashIntervalId: NodeJS.Timer;
-    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, blockhashCommitment, confirmationStrategy, txHandler, }: {
+    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, confirmInBackground, blockhashCommitment, confirmationStrategy, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -25,9 +26,13 @@ export declare class FastSingleTxSender extends BaseTxSender {
         blockhashRefreshInterval?: number;
         additionalConnections?: any;
         skipConfirmation?: boolean;
+        confirmInBackground?: boolean;
         blockhashCommitment?: Commitment;
         confirmationStrategy?: ConfirmationStrategy;
+        trackTxLandRate?: boolean;
         txHandler?: TxHandler;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
     });
     startBlockhashRefreshLoop(): void;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;

package/lib/tx/fastSingleTxSender.js

@@ -7,7 +7,7 @@ const baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_BLOCKHASH_REFRESH = 10000;
 class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, blockhashCommitment = 'finalized', confirmationStrategy = types_1.ConfirmationStrategy.Combo, txHandler, }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, confirmInBackground = false, blockhashCommitment = 'finalized', confirmationStrategy = types_1.ConfirmationStrategy.Combo, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }) {
         super({
             connection,
             wallet,
@@ -16,6 +16,9 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
             additionalConnections,
             confirmationStrategy,
             txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
         });
         this.timoutCount = 0;
         this.connection = connection;
@@ -25,6 +28,7 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         this.blockhashRefreshInterval = blockhashRefreshInterval;
         this.additionalConnections = additionalConnections;
         this.skipConfirmation = skipConfirmation;
+        this.confirmInBackground = confirmInBackground;
         this.blockhashCommitment = blockhashCommitment;
         this.startBlockhashRefreshLoop();
     }
@@ -41,9 +45,11 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         }
     }
     async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b;
         let txid;
         try {
             txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+            (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, false);
             this.sendToAdditionalConnections(rawTransaction, opts);
         }
         catch (e) {
@@ -53,9 +59,20 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         let slot;
         if (!this.skipConfirmation) {
             try {
-                const result = await this.confirmTransaction(txid, opts.commitment);
-                await this.checkConfirmationResultForError(txid, result);
-                slot = result.context.slot;
+                if (this.confirmInBackground) {
+                    this.confirmTransaction(txid, opts.commitment).then(async (result) => {
+                        var _a;
+                        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, true);
+                        await this.checkConfirmationResultForError(txid, result);
+                        slot = result.context.slot;
+                    });
+                }
+                else {
+                    const result = await this.confirmTransaction(txid, opts.commitment);
+                    (_b = this.txSigCache) === null || _b === void 0 ? void 0 : _b.set(txid, true);
+                    await this.checkConfirmationResultForError(txid, result);
+                    slot = result.context.slot;
+                }
             }
             catch (e) {
                 console.error(e);

package/lib/tx/forwardOnlyTxSender.d.ts

@@ -15,7 +15,7 @@ export declare class ForwardOnlyTxSender extends BaseTxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    constructor({ connection, wallet, opts, timeout, retrySleep, confirmationStrategy, additionalTxSenderCallbacks, txHandler, }: {
+    constructor({ connection, wallet, opts, timeout, retrySleep, confirmationStrategy, additionalTxSenderCallbacks, txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -24,6 +24,9 @@ export declare class ForwardOnlyTxSender extends BaseTxSender {
         confirmationStrategy?: ConfirmationStrategy;
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
         txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
     });
     sleep(reference: ResolveReference): Promise<void>;
     sendToAdditionalConnections(rawTx: Buffer | Uint8Array, _opts: ConfirmOptions): void;

package/lib/tx/forwardOnlyTxSender.js

@@ -12,7 +12,7 @@ const types_1 = require("./types");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 5000;
 class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }) {
         super({
             connection,
             wallet,
@@ -22,6 +22,9 @@ class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
             confirmationStrategy,
             additionalTxSenderCallbacks,
             txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
         });
         this.timoutCount = 0;
         this.connection = connection;
@@ -44,11 +47,13 @@ class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
         });
     }
     async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b;
         const deserializedTx = web3_js_1.VersionedTransaction.deserialize(rawTransaction);
         const txSig = deserializedTx.signatures[0];
         const encodedTxSig = bs58_1.default.encode(txSig);
         const startTime = this.getTimestamp();
         this.sendToAdditionalConnections(rawTransaction, opts);
+        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(encodedTxSig, false);
         let done = false;
         const resolveReference = {
             resolve: undefined,
@@ -71,6 +76,7 @@ class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
         try {
             const result = await this.confirmTransaction(encodedTxSig, opts.commitment);
             slot = result.context.slot;
+            (_b = this.txSigCache) === null || _b === void 0 ? void 0 : _b.set(encodedTxSig, true);
             // eslint-disable-next-line no-useless-catch
         }
         catch (e) {

package/lib/tx/retryTxSender.d.ts

@@ -15,7 +15,7 @@ export declare class RetryTxSender extends BaseTxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, txHandler, }: {
+    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -25,6 +25,9 @@ export declare class RetryTxSender extends BaseTxSender {
         confirmationStrategy?: ConfirmationStrategy;
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
         txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
     });
     sleep(reference: ResolveReference): Promise<void>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;

package/lib/tx/retryTxSender.js

@@ -7,7 +7,7 @@ const baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 2000;
 class RetryTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }) {
         super({
             connection,
             wallet,
@@ -17,6 +17,9 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
             confirmationStrategy,
             additionalTxSenderCallbacks,
             txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
         });
         this.timoutCount = 0;
         this.connection = connection;
@@ -33,8 +36,10 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
         });
     }
     async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b;
         const startTime = this.getTimestamp();
         const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, false);
         this.sendToAdditionalConnections(rawTransaction, opts);
         let done = false;
         const resolveReference = {
@@ -63,6 +68,7 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
         let slot;
         try {
             const result = await this.confirmTransaction(txid, opts.commitment);
+            (_b = this.txSigCache) === null || _b === void 0 ? void 0 : _b.set(txid, true);
             await this.checkConfirmationResultForError(txid, result);
             slot = result.context.slot;
             // eslint-disable-next-line no-useless-catch

package/lib/tx/whileValidTxSender.d.ts

@@ -20,7 +20,7 @@ export declare class WhileValidTxSender extends BaseTxSender {
         lastValidBlockHeight: number;
     }>;
     blockhashCommitment: Commitment;
-    constructor({ connection, wallet, opts, retrySleep, additionalConnections, additionalTxSenderCallbacks, blockhashCommitment, txHandler, }: {
+    constructor({ connection, wallet, opts, retrySleep, additionalConnections, additionalTxSenderCallbacks, blockhashCommitment, txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -29,6 +29,9 @@ export declare class WhileValidTxSender extends BaseTxSender {
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
         blockhashCommitment?: Commitment;
         txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
     });
     sleep(reference: ResolveReference): Promise<void>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;

package/lib/tx/whileValidTxSender.js

@@ -10,7 +10,7 @@ const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_RETRY = 2000;
 const VALID_BLOCK_HEIGHT_OFFSET = -150; // This is a bit of weirdness but the lastValidBlockHeight value returned from connection.getLatestBlockhash is always 300 blocks ahead of the current block, even though the transaction actually expires after 150 blocks. This accounts for that so that we can at least accuractely estimate the transaction expiry.
 class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), additionalTxSenderCallbacks = [], blockhashCommitment = 'finalized', txHandler, }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), additionalTxSenderCallbacks = [], blockhashCommitment = 'finalized', txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }) {
         super({
             connection,
             wallet,
@@ -18,6 +18,9 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
             additionalConnections,
             additionalTxSenderCallbacks,
             txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
         });
         this.timoutCount = 0;
         this.untilValid = new Map();
@@ -83,8 +86,10 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
         return this.sendRawTransaction(signedTx.serialize(), opts);
     }
     async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b;
         const startTime = this.getTimestamp();
         const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, false);
         this.sendToAdditionalConnections(rawTransaction, opts);
         let done = false;
         const resolveReference = {
@@ -118,6 +123,7 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
                 lastValidBlockHeight: lastValidBlockHeight + VALID_BLOCK_HEIGHT_OFFSET,
                 blockhash,
             }, opts.commitment);
+            (_b = this.txSigCache) === null || _b === void 0 ? void 0 : _b.set(txid, true);
             await this.checkConfirmationResultForError(txid, result);
             slot = result.context.slot;
             // eslint-disable-next-line no-useless-catch

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.91.0-beta.1",
+	"version": "2.91.0-beta.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -46,6 +46,7 @@
 		"@solana/web3.js": "1.92.3",
 		"@switchboard-xyz/on-demand": "1.2.1",
 		"anchor-bankrun": "^0.3.0",
+		"node-cache": "^5.1.2",
 		"rpc-websockets": "7.5.1",
 		"solana-bankrun": "^0.3.0",
 		"strict-event-emitter-types": "^2.0.0",

package/src/tx/baseTxSender.ts

@@ -25,8 +25,11 @@ import assert from 'assert';
 import bs58 from 'bs58';
 import { TxHandler } from './txHandler';
 import { IWallet } from '../types';
+import NodeCache from 'node-cache';
 
+const BASELINE_TX_LAND_RATE = 0.9;
 const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES = 10;
 const NOT_CONFIRMED_ERROR_CODE = -1001;
 
 export abstract class BaseTxSender implements TxSender {
@@ -39,6 +42,14 @@ export abstract class BaseTxSender implements TxSender {
 	confirmationStrategy: ConfirmationStrategy;
 	additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
 	txHandler: TxHandler;
+	trackTxLandRate?: boolean;
+
+	// For landing rate calcs
+	lookbackWindowMinutes: number;
+	txSigCache?: NodeCache;
+	txLandRate = 0;
+	lastPriorityFeeSuggestion = 1;
+	landRateToFeeFunc: (landRate: number) => number;
 
 	public constructor({
 		connection,
@@ -48,7 +59,11 @@ export abstract class BaseTxSender implements TxSender {
 		additionalConnections = new Array<Connection>(),
 		confirmationStrategy = ConfirmationStrategy.Combo,
 		additionalTxSenderCallbacks,
+		trackTxLandRate,
 		txHandler,
+		txLandRateLookbackWindowMinutes = DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES *
+			60,
+		landRateToFeeFunc,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -58,6 +73,9 @@ export abstract class BaseTxSender implements TxSender {
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		txHandler?: TxHandler;
+		trackTxLandRate?: boolean;
+		txLandRateLookbackWindowMinutes?: number;
+		landRateToFeeFunc?: (landRate: number) => number;
 	}) {
 		this.connection = connection;
 		this.wallet = wallet;
@@ -73,6 +91,16 @@ export abstract class BaseTxSender implements TxSender {
 				wallet: this.wallet,
 				confirmationOptions: this.opts,
 			});
+		this.trackTxLandRate = trackTxLandRate;
+		this.lookbackWindowMinutes = txLandRateLookbackWindowMinutes * 60;
+		if (this.trackTxLandRate) {
+			this.txSigCache = new NodeCache({
+				stdTTL: this.lookbackWindowMinutes,
+				checkperiod: 120,
+			});
+		}
+		this.landRateToFeeFunc =
+			landRateToFeeFunc ?? this.defaultLandRateToFeeFunc.bind(this);
 	}
 
 	async send(
@@ -404,4 +432,49 @@ export abstract class BaseTxSender implements TxSender {
 			logs,
 		});
 	}
+
+	public getTxLandRate() {
+		if (!this.trackTxLandRate) {
+			console.warn(
+				'trackTxLandRate is false, returning default land rate of 0'
+			);
+			return this.txLandRate;
+		}
+		const keys = this.txSigCache.keys();
+		const denominator = keys.length;
+		if (denominator === 0) {
+			return this.txLandRate;
+		}
+		let numerator = 0;
+		for (const key of keys) {
+			const value = this.txSigCache.get(key);
+			if (value) {
+				numerator += 1;
+			}
+		}
+		this.txLandRate = numerator / denominator;
+		return this.txLandRate;
+	}
+
+	private defaultLandRateToFeeFunc(txLandRate: number) {
+		if (
+			txLandRate >= BASELINE_TX_LAND_RATE ||
+			this.txSigCache.keys().length < 3
+		) {
+			return 1;
+		}
+		const multiplier =
+			10 * Math.log10(1 + (BASELINE_TX_LAND_RATE - txLandRate) * 5);
+		return Math.min(multiplier, 10);
+	}
+
+	public getSuggestedPriorityFeeMultiplier() {
+		if (!this.trackTxLandRate) {
+			console.warn(
+				'trackTxLandRate is false, returning default multiplier of 1'
+			);
+			return 1;
+		}
+		return this.landRateToFeeFunc(this.getTxLandRate());
+	}
 }

package/src/tx/fastSingleTxSender.ts

@@ -24,6 +24,7 @@ export class FastSingleTxSender extends BaseTxSender {
 	timoutCount = 0;
 	recentBlockhash: BlockhashWithExpiryBlockHeight;
 	skipConfirmation: boolean;
+	confirmInBackground: boolean;
 	blockhashCommitment: Commitment;
 	blockhashIntervalId: NodeJS.Timer;
 
@@ -35,9 +36,13 @@ export class FastSingleTxSender extends BaseTxSender {
 		blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH,
 		additionalConnections = new Array<Connection>(),
 		skipConfirmation = false,
+		confirmInBackground = false,
 		blockhashCommitment = 'finalized',
 		confirmationStrategy = ConfirmationStrategy.Combo,
+		trackTxLandRate,
 		txHandler,
+		txLandRateLookbackWindowMinutes,
+		landRateToFeeFunc,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -46,9 +51,13 @@ export class FastSingleTxSender extends BaseTxSender {
 		blockhashRefreshInterval?: number;
 		additionalConnections?;
 		skipConfirmation?: boolean;
+		confirmInBackground?: boolean;
 		blockhashCommitment?: Commitment;
 		confirmationStrategy?: ConfirmationStrategy;
+		trackTxLandRate?: boolean;
 		txHandler?: TxHandler;
+		txLandRateLookbackWindowMinutes?: number;
+		landRateToFeeFunc?: (landRate: number) => number;
 	}) {
 		super({
 			connection,
@@ -58,6 +67,9 @@ export class FastSingleTxSender extends BaseTxSender {
 			additionalConnections,
 			confirmationStrategy,
 			txHandler,
+			trackTxLandRate,
+			txLandRateLookbackWindowMinutes,
+			landRateToFeeFunc,
 		});
 		this.connection = connection;
 		this.wallet = wallet;
@@ -66,6 +78,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		this.blockhashRefreshInterval = blockhashRefreshInterval;
 		this.additionalConnections = additionalConnections;
 		this.skipConfirmation = skipConfirmation;
+		this.confirmInBackground = confirmInBackground;
 		this.blockhashCommitment = blockhashCommitment;
 		this.startBlockhashRefreshLoop();
 	}
@@ -91,6 +104,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		let txid: TransactionSignature;
 		try {
 			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+			this.txSigCache?.set(txid, false);
 			this.sendToAdditionalConnections(rawTransaction, opts);
 		} catch (e) {
 			console.error(e);
@@ -100,9 +114,20 @@ export class FastSingleTxSender extends BaseTxSender {
 		let slot: number;
 		if (!this.skipConfirmation) {
 			try {
-				const result = await this.confirmTransaction(txid, opts.commitment);
-				await this.checkConfirmationResultForError(txid, result);
-				slot = result.context.slot;
+				if (this.confirmInBackground) {
+					this.confirmTransaction(txid, opts.commitment).then(
+						async (result) => {
+							this.txSigCache?.set(txid, true);
+							await this.checkConfirmationResultForError(txid, result);
+							slot = result.context.slot;
+						}
+					);
+				} else {
+					const result = await this.confirmTransaction(txid, opts.commitment);
+					this.txSigCache?.set(txid, true);
+					await this.checkConfirmationResultForError(txid, result);
+					slot = result.context.slot;
+				}
 			} catch (e) {
 				console.error(e);
 				throw e;

package/src/tx/forwardOnlyTxSender.ts

@@ -35,6 +35,9 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 		confirmationStrategy = ConfirmationStrategy.Combo,
 		additionalTxSenderCallbacks = [],
 		txHandler,
+		trackTxLandRate,
+		txLandRateLookbackWindowMinutes,
+		landRateToFeeFunc,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -44,6 +47,9 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		txHandler?: TxHandler;
+		trackTxLandRate?: boolean;
+		txLandRateLookbackWindowMinutes?: number;
+		landRateToFeeFunc?: (landRate: number) => number;
 	}) {
 		super({
 			connection,
@@ -54,6 +60,9 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 			confirmationStrategy,
 			additionalTxSenderCallbacks,
 			txHandler,
+			trackTxLandRate,
+			txLandRateLookbackWindowMinutes,
+			landRateToFeeFunc,
 		});
 		this.connection = connection;
 		this.wallet = wallet;
@@ -91,6 +100,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 		const startTime = this.getTimestamp();
 
 		this.sendToAdditionalConnections(rawTransaction, opts);
+		this.txSigCache?.set(encodedTxSig, false);
 
 		let done = false;
 		const resolveReference: ResolveReference = {
@@ -119,6 +129,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 				opts.commitment
 			);
 			slot = result.context.slot;
+			this.txSigCache?.set(encodedTxSig, true);
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {
 			throw e;

package/src/tx/retryTxSender.ts

@@ -31,6 +31,9 @@ export class RetryTxSender extends BaseTxSender {
 		confirmationStrategy = ConfirmationStrategy.Combo,
 		additionalTxSenderCallbacks = [],
 		txHandler,
+		trackTxLandRate,
+		txLandRateLookbackWindowMinutes,
+		landRateToFeeFunc,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -41,6 +44,9 @@ export class RetryTxSender extends BaseTxSender {
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		txHandler?: TxHandler;
+		trackTxLandRate?: boolean;
+		txLandRateLookbackWindowMinutes?: number;
+		landRateToFeeFunc?: (landRate: number) => number;
 	}) {
 		super({
 			connection,
@@ -51,6 +57,9 @@ export class RetryTxSender extends BaseTxSender {
 			confirmationStrategy,
 			additionalTxSenderCallbacks,
 			txHandler,
+			trackTxLandRate,
+			txLandRateLookbackWindowMinutes,
+			landRateToFeeFunc,
 		});
 		this.connection = connection;
 		this.wallet = wallet;
@@ -74,6 +83,7 @@ export class RetryTxSender extends BaseTxSender {
 		const startTime = this.getTimestamp();
 
 		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+		this.txSigCache?.set(txid, false);
 		this.sendToAdditionalConnections(rawTransaction, opts);
 
 		let done = false;
@@ -105,6 +115,7 @@ export class RetryTxSender extends BaseTxSender {
 		let slot: number;
 		try {
 			const result = await this.confirmTransaction(txid, opts.commitment);
+			this.txSigCache?.set(txid, true);
 
 			await this.checkConfirmationResultForError(txid, result);
 

package/src/tx/whileValidTxSender.ts

@@ -44,6 +44,9 @@ export class WhileValidTxSender extends BaseTxSender {
 		additionalTxSenderCallbacks = [],
 		blockhashCommitment = 'finalized',
 		txHandler,
+		trackTxLandRate,
+		txLandRateLookbackWindowMinutes,
+		landRateToFeeFunc,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -53,6 +56,9 @@ export class WhileValidTxSender extends BaseTxSender {
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		blockhashCommitment?: Commitment;
 		txHandler?: TxHandler;
+		trackTxLandRate?: boolean;
+		txLandRateLookbackWindowMinutes?: number;
+		landRateToFeeFunc?: (landRate: number) => number;
 	}) {
 		super({
 			connection,
@@ -61,6 +67,9 @@ export class WhileValidTxSender extends BaseTxSender {
 			additionalConnections,
 			additionalTxSenderCallbacks,
 			txHandler,
+			trackTxLandRate,
+			txLandRateLookbackWindowMinutes,
+			landRateToFeeFunc,
 		});
 		this.retrySleep = retrySleep;
 		this.blockhashCommitment = blockhashCommitment;
@@ -168,6 +177,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		const startTime = this.getTimestamp();
 
 		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+		this.txSigCache?.set(txid, false);
 		this.sendToAdditionalConnections(rawTransaction, opts);
 
 		let done = false;
@@ -208,7 +218,7 @@ export class WhileValidTxSender extends BaseTxSender {
 				},
 				opts.commitment
 			);
-
+			this.txSigCache?.set(txid, true);
 			await this.checkConfirmationResultForError(txid, result);
 
 			slot = result.context.slot;