@drift-labs/sdk 2.77.0-beta.0 → 2.77.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.77.0-beta.0
+2.77.0-beta.2

package/lib/driftClient.d.ts

@@ -112,7 +112,8 @@ export declare class DriftClient {
      * Adds and subscribes to users based on params set by the constructor or by updateWallet.
      */
     addAndSubscribeToUsers(): Promise<boolean>;
-    initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    private getProcessedTransactionParams;
+    initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<[TransactionSignature, PublicKey]>;
     getInitializeUserInstructions(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[PublicKey, TransactionInstruction]>;
     getInitializeUserStatsIx(): Promise<TransactionInstruction>;
     getNextSubAccountId(): Promise<number>;
@@ -249,7 +250,7 @@ export declare class DriftClient {
      * @returns
      */
     initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, txParams?: TxParams, customMaxMarginRatio?: number): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(subAccountId: number, name: string, marketIndex: number, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(subAccountId: number, name: string, marketIndex: number, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<[TransactionSignature, PublicKey]>;
     /**
      * Withdraws from a user account. If deposit doesn't already exist, creates a borrow
      * @param amount
@@ -661,6 +662,15 @@ export declare class DriftClient {
     } | undefined;
     private handleSignedTransaction;
     sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
-    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[]): Promise<Transaction | VersionedTransaction>;
+    /**
+     *
+     * @param instructions
+     * @param txParams
+     * @param txVersion
+     * @param lookupTables
+     * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+     * @returns
+     */
+    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<Transaction | VersionedTransaction>;
 }
 export {};

package/lib/driftClient.js

@@ -56,6 +56,7 @@ const memcmp_1 = require("./memcmp");
 const marinade_1 = require("./marinade");
 const orderParams_1 = require("./orderParams");
 const utils_2 = require("./math/utils");
+const txParamProcessor_1 = require("./tx/txParamProcessor");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -437,7 +438,23 @@ class DriftClient {
         }
         return result;
     }
-    async initializeUserAccount(subAccountId = 0, name, referrerInfo) {
+    async getProcessedTransactionParams(txParams, txParamProcessingParams) {
+        const tx = await txParamProcessor_1.TransactionProcessor.process({
+            txProps: {
+                instructions: txParams.instructions,
+                txParams: txParams.txParams,
+                txVersion: txParams.txVersion,
+                lookupTables: txParams.lookupTables,
+            },
+            txBuilder: (updatedTxParams) => this.buildTransaction(updatedTxParams.instructions, updatedTxParams === null || updatedTxParams === void 0 ? void 0 : updatedTxParams.txParams, updatedTxParams.txVersion, updatedTxParams.lookupTables, true),
+            processConfig: txParamProcessingParams,
+            processParams: {
+                connection: this.connection,
+            },
+        });
+        return tx;
+    }
+    async initializeUserAccount(subAccountId = 0, name, referrerInfo, txParams) {
         const initializeIxs = [];
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
         if (subAccountId === 0) {
@@ -446,7 +463,7 @@ class DriftClient {
             }
         }
         initializeIxs.push(initializeUserAccountIx);
-        const tx = await this.buildTransaction(initializeIxs);
+        const tx = await this.buildTransaction(initializeIxs, txParams);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         await this.addUser(subAccountId);
         return [txSig, userAccountPublicKey];
@@ -1147,21 +1164,11 @@ class DriftClient {
      * @returns
      */
     async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
-        var _a;
         const ixs = [];
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
         const additionalSigners = [];
         const spotMarket = this.getSpotMarketAccount(marketIndex);
         const isSolMarket = spotMarket.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
-        let params = {
-            computeUnits: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : 600000,
-        };
-        if (txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice) {
-            params = {
-                ...params,
-                computeUnitsPrice: txParams.computeUnitsPrice,
-            };
-        }
         const authority = this.wallet.publicKey;
         const isFromSubaccount = fromSubAccountId !== null &&
             fromSubAccountId !== undefined &&
@@ -1203,13 +1210,13 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             ixs.push((0, spl_token_1.createCloseAccountInstruction)(wsolTokenAccount, authority, authority, []));
         }
-        const tx = await this.buildTransaction(ixs, params);
+        const tx = await this.buildTransaction(ixs, txParams);
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
         await this.addUser(subAccountId);
         return [txSig, userAccountPublicKey];
     }
-    async initializeUserAccountForDevnet(subAccountId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo) {
+    async initializeUserAccountForDevnet(subAccountId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo, txParams) {
         const ixs = [];
         const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
@@ -1221,7 +1228,7 @@ class DriftClient {
             }
         }
         ixs.push(initializeUserAccountIx, depositCollateralIx);
-        const tx = await this.buildTransaction(ixs);
+        const tx = await this.buildTransaction(ixs, txParams);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         await this.addUser(subAccountId);
         return [txSig, userAccountPublicKey];
@@ -1258,10 +1265,7 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             withdrawIxs.push((0, spl_token_1.createCloseAccountInstruction)(associatedTokenAddress, authority, authority, []));
         }
-        const tx = await this.buildTransaction(withdrawIxs, {
-            ...(txParams !== null && txParams !== void 0 ? txParams : this.txParams),
-            computeUnits: 1400000,
-        });
+        const tx = await this.buildTransaction(withdrawIxs, txParams !== null && txParams !== void 0 ? txParams : this.txParams);
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
@@ -2512,12 +2516,26 @@ class DriftClient {
             const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
             ixs.push(bracketOrdersIx);
         }
-        const placeAndTakeTx = (await this.buildTransaction(ixs, txParams));
-        // if param is passed, return early before the tx fails so ui can fallback to placeOrder
-        if (simulateFirst) {
-            const success = await this.txSender.simulateTransaction(placeAndTakeTx);
-            if (!success)
+        const shouldUseSimulationComputeUnits = txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits;
+        const shouldExitIfSimulationFails = simulateFirst;
+        const txParamsWithoutImplicitSimulation = {
+            ...txParams,
+            useSimulationComputeUnits: false,
+        };
+        let placeAndTakeTx = await this.buildTransaction(ixs, txParamsWithoutImplicitSimulation);
+        if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
+            const simulationResult = await txParamProcessor_1.TransactionProcessor.getTxSimComputeUnits(
+            // @ts-ignore :: TODO - TEST WITH LEGACY TRANSACTION
+            placeAndTakeTx, this.connection);
+            if (shouldExitIfSimulationFails && !simulationResult.success) {
                 return;
+            }
+            if (shouldUseSimulationComputeUnits) {
+                placeAndTakeTx = await this.buildTransaction(ixs, {
+                    ...txParamsWithoutImplicitSimulation,
+                    computeUnits: simulationResult.computeUnits,
+                });
+            }
         }
         let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
@@ -3506,23 +3524,63 @@ class DriftClient {
                 onSignedCb: this.handleSignedTransaction.bind(this),
             }
             : undefined;
-        if (tx instanceof web3_js_1.VersionedTransaction) {
+        const version = tx === null || tx === void 0 ? void 0 : tx.version;
+        const isVersionedTx = tx instanceof web3_js_1.VersionedTransaction || version !== undefined;
+        if (isVersionedTx) {
             return this.txSender.sendVersionedTransaction(tx, additionalSigners, opts, preSigned, extraConfirmationOptions);
         }
         else {
             return this.txSender.send(tx, additionalSigners, opts, preSigned, extraConfirmationOptions);
         }
     }
-    async buildTransaction(instructions, txParams, txVersion, lookupTables) {
+    /**
+     *
+     * @param instructions
+     * @param txParams
+     * @param txVersion
+     * @param lookupTables
+     * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+     * @returns
+     */
+    async buildTransaction(instructions, txParams, txVersion, lookupTables, forceVersionedTransaction) {
         var _a, _b;
+        txVersion = txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion;
+        // # Collect and process Tx Params
+        let baseTxParams = {
+            computeUnits: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : this.txParams.computeUnits,
+            computeUnitsPrice: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice) !== null && _b !== void 0 ? _b : this.txParams.computeUnitsPrice,
+        };
+        if (txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits) {
+            const splitTxParams = {
+                baseTxParams: {
+                    computeUnits: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits,
+                    computeUnitsPrice: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice,
+                },
+                txParamProcessingParams: {
+                    useSimulatedComputeUnits: txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits,
+                    computeUnitsBufferMultiplier: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsBufferMultiplier,
+                },
+            };
+            const processedTxParams = await this.getProcessedTransactionParams({
+                instructions,
+                txParams: splitTxParams.baseTxParams,
+                txVersion,
+                lookupTables,
+            }, splitTxParams.txParamProcessingParams);
+            baseTxParams = {
+                ...baseTxParams,
+                ...processedTxParams,
+            };
+        }
+        // # Create Tx Instructions
         const allIx = [];
-        const computeUnits = (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : this.txParams.computeUnits;
+        const computeUnits = baseTxParams === null || baseTxParams === void 0 ? void 0 : baseTxParams.computeUnits;
         if (computeUnits !== 200000) {
             allIx.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
                 units: computeUnits,
             }));
         }
-        const computeUnitsPrice = (_b = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice) !== null && _b !== void 0 ? _b : this.txParams.computeUnitsPrice;
+        const computeUnitsPrice = baseTxParams === null || baseTxParams === void 0 ? void 0 : baseTxParams.computeUnitsPrice;
         if (computeUnitsPrice !== 0) {
             allIx.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
                 microLamports: computeUnitsPrice,
@@ -3534,9 +3592,22 @@ class DriftClient {
         else {
             allIx.push(instructions);
         }
-        txVersion = txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion;
+        const latestBlockHashAndContext = await this.connection.getLatestBlockhashAndContext({
+            commitment: this.opts.preflightCommitment,
+        });
+        // # Create and return Transaction
         if (txVersion === 'legacy') {
-            return new web3_js_1.Transaction().add(...allIx);
+            if (forceVersionedTransaction) {
+                const message = new web3_js_1.TransactionMessage({
+                    payerKey: this.provider.wallet.publicKey,
+                    recentBlockhash: latestBlockHashAndContext.value.blockhash,
+                    instructions: allIx,
+                }).compileToLegacyMessage();
+                return new web3_js_1.VersionedTransaction(message);
+            }
+            else {
+                return new web3_js_1.Transaction().add(...allIx);
+            }
         }
         else {
             const marketLookupTable = await this.fetchMarketLookupTableAccount();
@@ -3545,7 +3616,7 @@ class DriftClient {
                 : [marketLookupTable];
             const message = new web3_js_1.TransactionMessage({
                 payerKey: this.provider.wallet.publicKey,
-                recentBlockhash: (await this.provider.connection.getRecentBlockhash(this.opts.preflightCommitment)).blockhash,
+                recentBlockhash: latestBlockHashAndContext.value.blockhash,
                 instructions: allIx,
             }).compileToV0Message(lookupTables);
             return new web3_js_1.VersionedTransaction(message);

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.76.0",
+    "version": "2.75.0",
     "name": "drift",
     "instructions": [
         {

package/lib/priorityFee/driftPriorityFeeMethod.d.ts

@@ -1,3 +1,3 @@
 import { HeliusPriorityFeeLevels } from './heliusPriorityFeeMethod';
 export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
-export declare function fetchDriftPriorityFee(url: string, marketType: string, marketIndex: number): Promise<DriftPriorityFeeResponse>;
+export declare function fetchDriftPriorityFee(url: string, marketTypes: string[], marketIndexs: number[]): Promise<DriftPriorityFeeResponse>;

package/lib/priorityFee/driftPriorityFeeMethod.js

@@ -5,8 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchDriftPriorityFee = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
-async function fetchDriftPriorityFee(url, marketType, marketIndex) {
-    const response = await (0, node_fetch_1.default)(`${url}?marketType=${marketType}&marketIndex=${marketIndex}`);
-    return await response.json();
+async function fetchDriftPriorityFee(url, marketTypes, marketIndexs) {
+    try {
+        const response = await (0, node_fetch_1.default)(`${url}/batchPriorityFees?marketType=${marketTypes.join(',')}&marketIndex=${marketIndexs.join(',')}`);
+        return await response.json();
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return [];
 }
 exports.fetchDriftPriorityFee = fetchDriftPriorityFee;

package/lib/priorityFee/heliusPriorityFeeMethod.js

@@ -17,24 +17,30 @@ var HeliusPriorityLevel;
 /// Fetches the priority fee from the Helius API
 /// https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api
 async function fetchHeliusPriorityFee(heliusRpcUrl, lookbackDistance, addresses) {
-    const response = await (0, node_fetch_1.default)(heliusRpcUrl, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            jsonrpc: '2.0',
-            id: '1',
-            method: 'getPriorityFeeEstimate',
-            params: [
-                {
-                    accountKeys: addresses,
-                    options: {
-                        includeAllPriorityFeeLevels: true,
-                        lookbackSlots: lookbackDistance,
+    try {
+        const response = await (0, node_fetch_1.default)(heliusRpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: '1',
+                method: 'getPriorityFeeEstimate',
+                params: [
+                    {
+                        accountKeys: addresses,
+                        options: {
+                            includeAllPriorityFeeLevels: true,
+                            lookbackSlots: lookbackDistance,
+                        },
                     },
-                },
-            ],
-        }),
-    });
-    return await response.json();
+                ],
+            }),
+        });
+        return await response.json();
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return undefined;
 }
 exports.fetchHeliusPriorityFee = fetchHeliusPriorityFee;

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -3,7 +3,6 @@ import { PriorityFeeMethod, PriorityFeeStrategy, PriorityFeeSubscriberConfig } f
 import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
 import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
 import { HeliusPriorityFeeLevels, HeliusPriorityLevel } from './heliusPriorityFeeMethod';
-import { MarketType } from '..';
 export type DriftMarketInfo = {
     marketType: string;
     marketIndex: number;
@@ -12,7 +11,7 @@ export declare class PriorityFeeSubscriber {
     connection: Connection;
     frequencyMs: number;
     addresses: string[];
-    driftMarket?: DriftMarketInfo;
+    driftMarkets?: DriftMarketInfo[];
     customStrategy?: PriorityFeeStrategy;
     averageStrategy: AverageOverSlotsStrategy;
     maxStrategy: MaxOverSlotsStrategy;
@@ -46,5 +45,5 @@ export declare class PriorityFeeSubscriber {
     load(): Promise<void>;
     unsubscribe(): Promise<void>;
     updateAddresses(addresses: PublicKey[]): void;
-    updateMarketTypeAndIndex(marketType: MarketType, marketIndex: number): void;
+    updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]): void;
 }

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -7,7 +7,6 @@ const maxOverSlotsStrategy_1 = require("./maxOverSlotsStrategy");
 const solanaPriorityFeeMethod_1 = require("./solanaPriorityFeeMethod");
 const heliusPriorityFeeMethod_1 = require("./heliusPriorityFeeMethod");
 const driftPriorityFeeMethod_1 = require("./driftPriorityFeeMethod");
-const __1 = require("..");
 class PriorityFeeSubscriber {
     constructor(config) {
         var _a, _b;
@@ -24,7 +23,7 @@ class PriorityFeeSubscriber {
         this.addresses = config.addresses
             ? config.addresses.map((address) => address.toBase58())
             : [];
-        this.driftMarket = config.driftMarket;
+        this.driftMarkets = config.driftMarkets;
         if (config.customStrategy) {
             this.customStrategy = config.customStrategy;
         }
@@ -68,12 +67,14 @@ class PriorityFeeSubscriber {
     }
     async loadForSolana() {
         const samples = await (0, solanaPriorityFeeMethod_1.fetchSolanaPriorityFee)(this.connection, this.lookbackDistance, this.addresses);
-        this.latestPriorityFee = samples[0].prioritizationFee;
-        this.lastSlotSeen = samples[0].slot;
-        this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
-        this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
-        if (this.customStrategy) {
-            this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
+        if (samples.length > 0) {
+            this.latestPriorityFee = samples[0].prioritizationFee;
+            this.lastSlotSeen = samples[0].slot;
+            this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
+            this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
+            if (this.customStrategy) {
+                this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
+            }
         }
     }
     async loadForHelius() {
@@ -91,22 +92,15 @@ class PriorityFeeSubscriber {
         }
     }
     async loadForDrift() {
-        if (!this.driftMarket) {
+        if (!this.driftMarkets) {
             return;
         }
-        const sample = await (0, driftPriorityFeeMethod_1.fetchDriftPriorityFee)(this.driftPriorityFeeEndpoint, this.driftMarket.marketType, this.driftMarket.marketIndex);
+        const sample = await (0, driftPriorityFeeMethod_1.fetchDriftPriorityFee)(this.driftPriorityFeeEndpoint, this.driftMarkets.map((m) => m.marketType), this.driftMarkets.map((m) => m.marketIndex));
         if (sample.length > 0) {
             this.lastAvgStrategyResult = sample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.MEDIUM];
             this.lastMaxStrategyResult = sample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.UNSAFE_MAX];
             if (this.customStrategy) {
-                // stay compatible with helius response
-                this.lastCustomStrategyResult = this.customStrategy.calculate({
-                    jsonrpc: '',
-                    result: {
-                        priorityFeeLevels: sample[0],
-                    },
-                    id: '',
-                });
+                this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
             }
         }
     }
@@ -186,8 +180,8 @@ class PriorityFeeSubscriber {
     updateAddresses(addresses) {
         this.addresses = addresses.map((k) => k.toBase58());
     }
-    updateMarketTypeAndIndex(marketType, marketIndex) {
-        this.driftMarket = { marketType: (0, __1.getVariant)(marketType), marketIndex };
+    updateMarketTypeAndIndex(driftMarkets) {
+        this.driftMarkets = driftMarkets;
     }
 }
 exports.PriorityFeeSubscriber = PriorityFeeSubscriber;

package/lib/priorityFee/solanaPriorityFeeMethod.js

@@ -2,14 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSolanaPriorityFee = void 0;
 async function fetchSolanaPriorityFee(connection, lookbackDistance, addresses) {
-    // @ts-ignore
-    const rpcJSONResponse = await connection._rpcRequest('getRecentPrioritizationFees', [addresses]);
-    const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
-    if (!results.length)
-        return;
-    // Sort and filter results based on the slot lookback setting
-    const descResults = results.sort((a, b) => b.slot - a.slot);
-    const cutoffSlot = descResults[0].slot - lookbackDistance;
-    return descResults.filter((result) => result.slot >= cutoffSlot);
+    try {
+        // @ts-ignore
+        const rpcJSONResponse = await connection._rpcRequest('getRecentPrioritizationFees', [addresses]);
+        const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
+        if (!results.length)
+            return;
+        // Sort and filter results based on the slot lookback setting
+        const descResults = results.sort((a, b) => b.slot - a.slot);
+        const cutoffSlot = descResults[0].slot - lookbackDistance;
+        return descResults.filter((result) => result.slot >= cutoffSlot);
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return [];
 }
 exports.fetchSolanaPriorityFee = fetchSolanaPriorityFee;

package/lib/priorityFee/types.d.ts

@@ -2,8 +2,9 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
 import { DriftMarketInfo } from './priorityFeeSubscriber';
+import { DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
 export interface PriorityFeeStrategy {
-    calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse): number;
+    calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse | DriftPriorityFeeResponse): number;
 }
 export declare enum PriorityFeeMethod {
     SOLANA = "solana",
@@ -14,7 +15,7 @@ export type PriorityFeeSubscriberConfig = {
     connection?: Connection;
     frequencyMs: number;
     addresses?: PublicKey[];
-    driftMarket?: DriftMarketInfo;
+    driftMarkets?: DriftMarketInfo[];
     customStrategy?: PriorityFeeStrategy;
     priorityFeeMethod?: PriorityFeeMethod;
     slotsToCheck?: number;

package/lib/tx/txParamProcessor.d.ts

@@ -0,0 +1,28 @@
+import { AddressLookupTableAccount, Connection, TransactionInstruction, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
+import { BaseTxParams, ProcessingTxParams } from '..';
+type TransactionProps = {
+    instructions: TransactionInstruction | TransactionInstruction[];
+    txParams?: BaseTxParams;
+    txVersion?: TransactionVersion;
+    lookupTables?: AddressLookupTableAccount[];
+    forceVersionedTransaction?: boolean;
+};
+/**
+ * This class is responsible for running through a "processing" pipeline for a base transaction, to adjust the standard transaction parameters based on a given configuration.
+ */
+export declare class TransactionProcessor {
+    private static getComputeUnitsFromSim;
+    static getTxSimComputeUnits(tx: VersionedTransaction, connection: Connection): Promise<{
+        success: boolean;
+        computeUnits: number;
+    }>;
+    static process(props: {
+        txProps: TransactionProps;
+        txBuilder: (baseTransactionProps: TransactionProps) => Promise<VersionedTransaction>;
+        processConfig: ProcessingTxParams;
+        processParams: {
+            connection: Connection;
+        };
+    }): Promise<BaseTxParams>;
+}
+export {};

package/lib/tx/txParamProcessor.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionProcessor = void 0;
+const COMPUTE_UNIT_BUFFER_FACTOR = 1.2;
+const TEST_SIMS_ALWAYS_FAIL = false;
+/**
+ * This class is responsible for running through a "processing" pipeline for a base transaction, to adjust the standard transaction parameters based on a given configuration.
+ */
+class TransactionProcessor {
+    static async getComputeUnitsFromSim(txSim) {
+        var _a, _b;
+        if ((_a = txSim === null || txSim === void 0 ? void 0 : txSim.value) === null || _a === void 0 ? void 0 : _a.unitsConsumed) {
+            return (_b = txSim === null || txSim === void 0 ? void 0 : txSim.value) === null || _b === void 0 ? void 0 : _b.unitsConsumed;
+        }
+        return undefined;
+    }
+    static async getTxSimComputeUnits(tx, connection) {
+        var _a, _b, _c;
+        try {
+            if (TEST_SIMS_ALWAYS_FAIL)
+                throw new Error('Test Error::SIMS_ALWAYS_FAIL');
+            const simTxResult = await connection.simulateTransaction(tx, {
+                replaceRecentBlockhash: true, // This is important to ensure that the blockhash is not too new.. Otherwise we will very often receive a "blockHashNotFound" error
+            });
+            if ((_a = simTxResult === null || simTxResult === void 0 ? void 0 : simTxResult.value) === null || _a === void 0 ? void 0 : _a.err) {
+                throw new Error((_c = (_b = simTxResult === null || simTxResult === void 0 ? void 0 : simTxResult.value) === null || _b === void 0 ? void 0 : _b.err) === null || _c === void 0 ? void 0 : _c.toString());
+            }
+            const computeUnits = await this.getComputeUnitsFromSim(simTxResult);
+            return {
+                success: true,
+                computeUnits: computeUnits,
+            };
+        }
+        catch (e) {
+            console.warn(`Failed to get Simulated Compute Units for txParamProcessor`, e);
+            return {
+                success: false,
+                computeUnits: undefined,
+            };
+        }
+    }
+    static async process(props) {
+        var _a;
+        // # Exit early if no process config is provided
+        if (!props.processConfig || Object.keys(props.processConfig).length === 0) {
+            return props.txProps.txParams;
+        }
+        // # Setup
+        const { txProps: txProps, txBuilder: txBuilder, processConfig, processParams: processProps, } = props;
+        const baseTransaction = await txBuilder(txProps);
+        const finalTxProps = {
+            ...txProps,
+        };
+        // # Run Processes
+        if (processConfig.useSimulatedComputeUnits) {
+            const txSimComputeUnitsResult = await this.getTxSimComputeUnits(baseTransaction, processProps.connection);
+            if (txSimComputeUnitsResult.success) {
+                const bufferedComputeUnits = txSimComputeUnitsResult.computeUnits *
+                    ((_a = processConfig === null || processConfig === void 0 ? void 0 : processConfig.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : COMPUTE_UNIT_BUFFER_FACTOR);
+                // Adjust the transaction based on the simulated compute units
+                finalTxProps.txParams = {
+                    ...txProps.txParams,
+                    computeUnits: bufferedComputeUnits,
+                };
+            }
+        }
+        // # Return Final Tx Params
+        return finalTxProps.txParams;
+    }
+}
+exports.TransactionProcessor = TransactionProcessor;

package/lib/tx/whileValidTxSender.d.ts

@@ -28,7 +28,7 @@ export declare class WhileValidTxSender extends BaseTxSender {
     });
     sleep(reference: ResolveReference): Promise<void>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], _additionalSigners?: Array<Signer>, _opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], _additionalSigners?: Array<Signer>, _opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
 }