@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/lib/orderParams.js

@@ -2,107 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
-const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO, immediateOrCancel = false) {
-    return {
-        orderType: types_1.OrderType.LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly,
-        immediateOrCancel,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset,
-    };
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
 }
 exports.getLimitOrderParams = getLimitOrderParams;
-function getTriggerMarketOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
-        orderType: types_1.OrderType.TRIGGER_MARKET,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price: numericConstants_1.ZERO,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
 }
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
-function getTriggerLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
-        orderType: types_1.OrderType.TRIGGER_LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
 }
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
-function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAssetAmount, reduceOnly, price = numericConstants_1.ZERO, discountToken = false, referrer = false) {
-    if (baseAssetAmount.eq(numericConstants_1.ZERO) && quoteAssetAmount.eq(numericConstants_1.ZERO)) {
-        throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-    }
-    return {
-        orderType: types_1.OrderType.MARKET,
-        userOrderId: 0,
-        marketIndex,
-        direction,
-        quoteAssetAmount,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/orders.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="bn.js" />
-import { Market, Order, UserAccount, UserPosition } from './types';
-import { BN, ClearingHouseUser } from '.';
+import { MarketAccount, Order, UserAccount, UserPosition } from './types';
+import { BN } from '.';
 import { OraclePriceData } from '.';
-export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
-export declare function calculateBaseAssetAmountMarketCanExecute(market: Market, order: Order, oraclePriceData?: OraclePriceData): BN;
-export declare function calculateAmountToTradeForLimit(market: Market, order: Order, oraclePriceData?: OraclePriceData): BN;
-export declare function calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;
-export declare function calculateBaseAssetAmountUserCanExecute(market: Market, order: Order, user: ClearingHouseUser): BN;
+export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: MarketAccount, order: Order): [UserAccount, UserPosition, MarketAccount] | null;
+export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
+export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
+export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;

package/lib/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
 const market_1 = require("./math/market");
@@ -12,7 +12,7 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
         return null;
     }
     const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
         return null;
     }
     const userAccountAfter = Object.assign({}, userAccount);
@@ -88,7 +88,6 @@ function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
     else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        // should never be a market order queued
         return numericConstants_1.ZERO;
     }
     else {
@@ -102,33 +101,23 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
         if (!oraclePriceData) {
             throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
         }
-        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-        if (order.postOnly) {
-            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
-                ? _1.BN.min(order.price, floatingPrice)
-                : _1.BN.max(order.price, floatingPrice);
-        }
-        else {
-            limitPrice = floatingPrice;
-        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, !order.postOnly);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
+    const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {
         return numericConstants_1.ZERO;
     }
-    return maxAmountToTrade.gt(order.baseAssetAmount)
+    return baseAssetAmount.gt(order.baseAssetAmount)
         ? order.baseAssetAmount
-        : maxAmountToTrade;
+        : baseAssetAmount;
 }
 exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
 function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
-        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.ZERO;
-        }
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
     }
     return calculateAmountToTradeForLimit(market, order);
 }
@@ -138,75 +127,8 @@ function isSameDirection(firstDirection, secondDirection) {
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function calculateAmountToTradeForTriggerMarket(market, order) {
-    return isTriggerConditionSatisfied(market, order)
-        ? order.baseAssetAmount
-        : numericConstants_1.ZERO;
-}
-function isTriggerConditionSatisfied(market, order) {
-    const markPrice = (0, market_1.calculateMarkPrice)(market);
-    if ((0, types_1.isVariant)(order.triggerCondition, 'above')) {
-        return markPrice.gt(order.triggerPrice);
-    }
-    else {
-        return markPrice.lt(order.triggerPrice);
-    }
-}
-function calculateBaseAssetAmountUserCanExecute(market, order, user) {
-    const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-    const freeCollateral = user.getFreeCollateral();
-    let quoteAssetAmount;
-    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
-        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
-    }
-    else {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        const positionValue = (0, _1.calculateBaseAssetValue)(market, position);
-        quoteAssetAmount = freeCollateral
-            .mul(maxLeverage)
-            .div(_1.TEN_THOUSAND)
-            .add(positionValue.mul(numericConstants_1.TWO));
-    }
-    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+    if (!order.triggered) {
         return numericConstants_1.ZERO;
     }
-    const swapDirection = (0, types_1.isVariant)(order.direction, 'long')
-        ? types_1.SwapDirection.ADD
-        : types_1.SwapDirection.REMOVE;
-    const useSpread = !order.postOnly;
-    let amm;
-    if (useSpread) {
-        const { baseAssetReserve, quoteAssetReserve } = (0, _1.calculateSpreadReserves)(market.amm, order.direction);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: market.amm.sqrtK,
-            pegMultiplier: market.amm.pegMultiplier,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const baseAssetReservesBefore = amm.baseAssetReserve;
-    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteAssetAmount, swapDirection);
-    let baseAssetAmount = baseAssetReservesBefore
-        .sub(baseAssetReservesAfter)
-        .abs();
-    if (order.reduceOnly) {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        if ((0, types_1.isVariant)(order.direction, 'long') &&
-            position.baseAssetAmount.gte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else if ((0, types_1.isVariant)(order.direction, 'short') &&
-            position.baseAssetAmount.lte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else {
-            _1.BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-        }
-    }
-    return baseAssetAmount;
+    return order.baseAssetAmount;
 }
-exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/slot/SlotSubscriber.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+declare type SlotSubscriberConfig = {};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
+export declare class SlotSubscriber {
+    private connection;
+    currentSlot: number;
+    subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
+    constructor(connection: Connection, _config?: SlotSubscriberConfig);
+    subscribe(): Promise<void>;
+    getSlot(): number;
+    unsubscribe(): Promise<void>;
+}
+export {};

package/lib/slot/SlotSubscriber.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotSubscriber = void 0;
+const events_1 = require("events");
+class SlotSubscriber {
+    constructor(connection, _config) {
+        this.connection = connection;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        this.currentSlot = await this.connection.getSlot('confirmed');
+        this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+            this.currentSlot = slotInfo.slot;
+            this.eventEmitter.emit('newSlot', slotInfo.slot);
+        });
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    async unsubscribe() {
+        if (this.subscriptionId) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+        }
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/lib/tx/retryTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSender } from './types';
+import { TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@project-serum/anchor';
 declare type ResolveReference = {
@@ -11,7 +11,7 @@ export declare class RetryTxSender implements TxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
     getTimestamp(): number;

package/lib/tx/retryTxSender.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -24,133 +15,127 @@ class RetryTxSender {
         this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
         this.additionalConnections = additionalConnections;
     }
-    send(tx, additionalSigners, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (additionalSigners === undefined) {
-                additionalSigners = [];
-            }
-            if (opts === undefined) {
-                opts = this.provider.opts;
+    async send(tx, additionalSigners, opts) {
+        if (additionalSigners === undefined) {
+            additionalSigners = [];
+        }
+        if (opts === undefined) {
+            opts = this.provider.opts;
+        }
+        await this.prepareTx(tx, additionalSigners, opts);
+        const rawTransaction = tx.serialize();
+        const startTime = this.getTimestamp();
+        const txid = await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+        this.sendToAdditionalConnections(rawTransaction, opts);
+        let done = false;
+        const resolveReference = {
+            resolve: undefined,
+        };
+        const stopWaiting = () => {
+            done = true;
+            if (resolveReference.resolve) {
+                resolveReference.resolve();
             }
-            yield this.prepareTx(tx, additionalSigners, opts);
-            const rawTransaction = tx.serialize();
-            const startTime = this.getTimestamp();
-            const txid = yield this.provider.connection.sendRawTransaction(rawTransaction, opts);
-            this.sendToAdditionalConnections(rawTransaction, opts);
-            let done = false;
-            const resolveReference = {
-                resolve: undefined,
-            };
-            const stopWaiting = () => {
-                done = true;
-                if (resolveReference.resolve) {
-                    resolveReference.resolve();
+        };
+        (async () => {
+            while (!done && this.getTimestamp() - startTime < this.timeout) {
+                await this.sleep(resolveReference);
+                if (!done) {
+                    this.provider.connection
+                        .sendRawTransaction(rawTransaction, opts)
+                        .catch((e) => {
+                        console.error(e);
+                        stopWaiting();
+                    });
+                    this.sendToAdditionalConnections(rawTransaction, opts);
                 }
-            };
-            (() => __awaiter(this, void 0, void 0, function* () {
-                while (!done && this.getTimestamp() - startTime < this.timeout) {
-                    yield this.sleep(resolveReference);
-                    if (!done) {
-                        this.provider.connection
-                            .sendRawTransaction(rawTransaction, opts)
-                            .catch((e) => {
-                            console.error(e);
-                            stopWaiting();
-                        });
-                        this.sendToAdditionalConnections(rawTransaction, opts);
-                    }
-                }
-            }))();
-            try {
-                yield this.confirmTransaction(txid, opts.commitment);
-            }
-            catch (e) {
-                console.error(e);
-                throw e;
             }
-            finally {
-                stopWaiting();
-            }
-            return txid;
-        });
+        })();
+        let slot;
+        try {
+            const result = await this.confirmTransaction(txid, opts.commitment);
+            slot = result.context.slot;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+        finally {
+            stopWaiting();
+        }
+        return { txSig: txid, slot };
     }
-    prepareTx(tx, additionalSigners, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            tx.feePayer = this.provider.wallet.publicKey;
-            tx.recentBlockhash = (yield this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
-            yield this.provider.wallet.signTransaction(tx);
-            additionalSigners
-                .filter((s) => s !== undefined)
-                .forEach((kp) => {
-                tx.partialSign(kp);
-            });
-            return tx;
+    async prepareTx(tx, additionalSigners, opts) {
+        tx.feePayer = this.provider.wallet.publicKey;
+        tx.recentBlockhash = (await this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
+        await this.provider.wallet.signTransaction(tx);
+        additionalSigners
+            .filter((s) => s !== undefined)
+            .forEach((kp) => {
+            tx.partialSign(kp);
         });
+        return tx;
     }
-    confirmTransaction(signature, commitment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let decodedSignature;
-            try {
-                decodedSignature = bs58_1.default.decode(signature);
-            }
-            catch (err) {
-                throw new Error('signature must be base58 encoded: ' + signature);
-            }
-            (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
-            const start = Date.now();
-            const subscriptionCommitment = commitment || this.provider.opts.commitment;
-            const subscriptionIds = new Array();
-            const connections = [
-                this.provider.connection,
-                ...this.additionalConnections,
-            ];
-            let response = null;
-            const promises = connections.map((connection, i) => {
-                let subscriptionId;
-                const confirmPromise = new Promise((resolve, reject) => {
-                    try {
-                        subscriptionId = connection.onSignature(signature, (result, context) => {
-                            subscriptionIds[i] = undefined;
-                            response = {
-                                context,
-                                value: result,
-                            };
-                            resolve(null);
-                        }, subscriptionCommitment);
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                });
-                subscriptionIds.push(subscriptionId);
-                return confirmPromise;
+    async confirmTransaction(signature, commitment) {
+        let decodedSignature;
+        try {
+            decodedSignature = bs58_1.default.decode(signature);
+        }
+        catch (err) {
+            throw new Error('signature must be base58 encoded: ' + signature);
+        }
+        (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+        const start = Date.now();
+        const subscriptionCommitment = commitment || this.provider.opts.commitment;
+        const subscriptionIds = new Array();
+        const connections = [
+            this.provider.connection,
+            ...this.additionalConnections,
+        ];
+        let response = null;
+        const promises = connections.map((connection, i) => {
+            let subscriptionId;
+            const confirmPromise = new Promise((resolve, reject) => {
+                try {
+                    subscriptionId = connection.onSignature(signature, (result, context) => {
+                        subscriptionIds[i] = undefined;
+                        response = {
+                            context,
+                            value: result,
+                        };
+                        resolve(null);
+                    }, subscriptionCommitment);
+                }
+                catch (err) {
+                    reject(err);
+                }
             });
-            try {
-                yield this.promiseTimeout(promises, this.timeout);
-            }
-            finally {
-                for (const [i, subscriptionId] of subscriptionIds.entries()) {
-                    if (subscriptionId) {
-                        connections[i].removeSignatureListener(subscriptionId);
-                    }
+            subscriptionIds.push(subscriptionId);
+            return confirmPromise;
+        });
+        try {
+            await this.promiseTimeout(promises, this.timeout);
+        }
+        finally {
+            for (const [i, subscriptionId] of subscriptionIds.entries()) {
+                if (subscriptionId) {
+                    connections[i].removeSignatureListener(subscriptionId);
                 }
             }
-            if (response === null) {
-                const duration = (Date.now() - start) / 1000;
-                throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
-            }
-            return response;
-        });
+        }
+        if (response === null) {
+            const duration = (Date.now() - start) / 1000;
+            throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
+        }
+        return response;
     }
     getTimestamp() {
         return new Date().getTime();
     }
-    sleep(reference) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                reference.resolve = resolve;
-                setTimeout(resolve, this.retrySleep);
-            });
+    async sleep(reference) {
+        return new Promise((resolve) => {
+            reference.resolve = resolve;
+            setTimeout(resolve, this.retrySleep);
         });
     }
     promiseTimeout(promises, timeoutMs) {

package/lib/tx/types.d.ts

@@ -1,6 +1,10 @@
 import { Provider } from '@project-serum/anchor';
 import { ConfirmOptions, Signer, Transaction, TransactionSignature } from '@solana/web3.js';
+export declare type TxSigAndSlot = {
+    txSig: TransactionSignature;
+    slot: number;
+};
 export interface TxSender {
     provider: Provider;
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
 }

package/lib/tx/utils.d.ts

@@ -1,2 +1,2 @@
 import { Transaction, TransactionInstruction } from '@solana/web3.js';
-export declare function wrapInTx(instruction: TransactionInstruction): Transaction;
+export declare function wrapInTx(instruction: TransactionInstruction, computeUnits?: number): Transaction;

package/lib/tx/utils.js

@@ -2,7 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapInTx = void 0;
 const web3_js_1 = require("@solana/web3.js");
-function wrapInTx(instruction) {
-    return new web3_js_1.Transaction().add(instruction);
+const COMPUTE_UNITS_DEFAULT = 200000;
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
+) {
+    const tx = new web3_js_1.Transaction();
+    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: computeUnits,
+            additionalFee: 0,
+        }));
+    }
+    return tx.add(instruction);
 }
 exports.wrapInTx = wrapInTx;