@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/tx/retryTxSender.js

@@ -0,0 +1,280 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.RetryTxSender = void 0;
+var assert_1 = require("assert");
+var bs58_1 = require("bs58");
+var DEFAULT_TIMEOUT = 35000;
+var DEFAULT_RETRY = 8000;
+var RetryTxSender = /** @class */ (function () {
+    function RetryTxSender(provider, timeout, retrySleep, additionalConnections) {
+        if (additionalConnections === void 0) { additionalConnections = new Array(); }
+        this.provider = provider;
+        this.timeout = timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT;
+        this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
+        this.additionalConnections = additionalConnections;
+    }
+    RetryTxSender.prototype.send = function (tx, additionalSigners, opts, preSigned) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawTransaction, startTime, txid, e_1, done, resolveReference, stopWaiting, slot, result, e_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (additionalSigners === undefined) {
+                            additionalSigners = [];
+                        }
+                        if (opts === undefined) {
+                            opts = this.provider.opts;
+                        }
+                        if (!!preSigned) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.prepareTx(tx, additionalSigners, opts)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        rawTransaction = tx.serialize();
+                        startTime = this.getTimestamp();
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.provider.connection.sendRawTransaction(rawTransaction, opts)];
+                    case 4:
+                        txid = _a.sent();
+                        this.sendToAdditionalConnections(rawTransaction, opts);
+                        return [3 /*break*/, 6];
+                    case 5:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        throw e_1;
+                    case 6:
+                        done = false;
+                        resolveReference = {
+                            resolve: undefined
+                        };
+                        stopWaiting = function () {
+                            done = true;
+                            if (resolveReference.resolve) {
+                                resolveReference.resolve();
+                            }
+                        };
+                        (function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(!done && this.getTimestamp() - startTime < this.timeout)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.sleep(resolveReference)];
+                                    case 1:
+                                        _a.sent();
+                                        if (!done) {
+                                            this.provider.connection
+                                                .sendRawTransaction(rawTransaction, opts)["catch"](function (e) {
+                                                console.error(e);
+                                                stopWaiting();
+                                            });
+                                            this.sendToAdditionalConnections(rawTransaction, opts);
+                                        }
+                                        return [3 /*break*/, 0];
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); })();
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, 10, 11]);
+                        return [4 /*yield*/, this.confirmTransaction(txid, opts.commitment)];
+                    case 8:
+                        result = _a.sent();
+                        slot = result.context.slot;
+                        return [3 /*break*/, 11];
+                    case 9:
+                        e_2 = _a.sent();
+                        console.error(e_2);
+                        throw e_2;
+                    case 10:
+                        stopWaiting();
+                        return [7 /*endfinally*/];
+                    case 11: return [2 /*return*/, { txSig: txid, slot: slot }];
+                }
+            });
+        });
+    };
+    RetryTxSender.prototype.prepareTx = function (tx, additionalSigners, opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        tx.feePayer = this.provider.wallet.publicKey;
+                        _a = tx;
+                        return [4 /*yield*/, this.provider.connection.getRecentBlockhash(opts.preflightCommitment)];
+                    case 1:
+                        _a.recentBlockhash = (_b.sent()).blockhash;
+                        return [4 /*yield*/, this.provider.wallet.signTransaction(tx)];
+                    case 2:
+                        _b.sent();
+                        additionalSigners
+                            .filter(function (s) { return s !== undefined; })
+                            .forEach(function (kp) {
+                            tx.partialSign(kp);
+                        });
+                        return [2 /*return*/, tx];
+                }
+            });
+        });
+    };
+    RetryTxSender.prototype.confirmTransaction = function (signature, commitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var decodedSignature, start, subscriptionCommitment, subscriptionIds, connections, response, promises, _i, _a, _b, i, subscriptionId, duration;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        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');
+                        start = Date.now();
+                        subscriptionCommitment = commitment || this.provider.opts.commitment;
+                        subscriptionIds = new Array();
+                        connections = __spreadArray([
+                            this.provider.connection
+                        ], this.additionalConnections, true);
+                        response = null;
+                        promises = connections.map(function (connection, i) {
+                            var subscriptionId;
+                            var confirmPromise = new Promise(function (resolve, reject) {
+                                try {
+                                    subscriptionId = connection.onSignature(signature, function (result, context) {
+                                        subscriptionIds[i] = undefined;
+                                        response = {
+                                            context: context,
+                                            value: result
+                                        };
+                                        resolve(null);
+                                    }, subscriptionCommitment);
+                                }
+                                catch (err) {
+                                    reject(err);
+                                }
+                            });
+                            subscriptionIds.push(subscriptionId);
+                            return confirmPromise;
+                        });
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, this.promiseTimeout(promises, this.timeout)];
+                    case 2:
+                        _c.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        for (_i = 0, _a = subscriptionIds.entries(); _i < _a.length; _i++) {
+                            _b = _a[_i], i = _b[0], subscriptionId = _b[1];
+                            if (subscriptionId) {
+                                connections[i].removeSignatureListener(subscriptionId);
+                            }
+                        }
+                        return [7 /*endfinally*/];
+                    case 4:
+                        if (response === null) {
+                            duration = (Date.now() - start) / 1000;
+                            throw new Error("Transaction was not confirmed in ".concat(duration.toFixed(2), " seconds. It is unknown if it succeeded or failed. Check signature ").concat(signature, " using the Solana Explorer or CLI tools."));
+                        }
+                        return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    RetryTxSender.prototype.getTimestamp = function () {
+        return new Date().getTime();
+    };
+    RetryTxSender.prototype.sleep = function (reference) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        reference.resolve = resolve;
+                        setTimeout(resolve, _this.retrySleep);
+                    })];
+            });
+        });
+    };
+    RetryTxSender.prototype.promiseTimeout = function (promises, timeoutMs) {
+        var timeoutId;
+        var timeoutPromise = new Promise(function (resolve) {
+            timeoutId = setTimeout(function () { return resolve(null); }, timeoutMs);
+        });
+        return Promise.race(__spreadArray(__spreadArray([], promises, true), [timeoutPromise], false)).then(function (result) {
+            clearTimeout(timeoutId);
+            return result;
+        });
+    };
+    RetryTxSender.prototype.sendToAdditionalConnections = function (rawTx, opts) {
+        this.additionalConnections.map(function (connection) {
+            connection.sendRawTransaction(rawTx, opts)["catch"](function (e) {
+                console.error(
+                // @ts-ignore
+                "error sending tx to additional connection ".concat(connection._rpcEndpoint));
+                console.error(e);
+            });
+        });
+    };
+    RetryTxSender.prototype.addAdditionalConnection = function (newConnection) {
+        var alreadyUsingConnection = this.additionalConnections.filter(function (connection) {
+            // @ts-ignore
+            return connection._rpcEndpoint === newConnection.rpcEndpoint;
+        }).length > 0;
+        if (!alreadyUsingConnection) {
+            this.additionalConnections.push(newConnection);
+        }
+    };
+    return RetryTxSender;
+}());
+exports.RetryTxSender = RetryTxSender;

package/src/tx/retryTxSender.ts

@@ -42,7 +42,8 @@ export class RetryTxSender implements TxSender {
 	async send(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		preSigned?: boolean
 	): Promise<TxSigAndSlot> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
@@ -51,7 +52,9 @@ export class RetryTxSender implements TxSender {
 			opts = this.provider.opts;
 		}
 
-		await this.prepareTx(tx, additionalSigners, opts);
+		if (!preSigned) {
+			await this.prepareTx(tx, additionalSigners, opts);
+		}
 
 		const rawTransaction = tx.serialize();
 		const startTime = this.getTimestamp();

package/src/tx/types.js

@@ -1,2 +1,2 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;

package/src/tx/types.ts

@@ -17,6 +17,7 @@ export interface TxSender {
 	send(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		preSigned?: boolean
 	): Promise<TxSigAndSlot>;
 }

package/src/tx/utils.js

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

package/src/types.js

@@ -0,0 +1,216 @@
+"use strict";
+exports.__esModule = true;
+exports.DefaultOrderParams = exports.LiquidationType = exports.LPAction = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.SpotFulfillmentStatus = exports.SpotFulfillmentType = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.MarketType = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.SpotBalanceType = exports.SwapDirection = exports.ContractType = exports.MarketStatus = void 0;
+var _1 = require(".");
+// # Utility Types / Enums / Constants
+var MarketStatus = /** @class */ (function () {
+    function MarketStatus() {
+    }
+    MarketStatus.INITIALIZED = { initialized: {} };
+    MarketStatus.REDUCEONLY = { reduceonly: {} };
+    MarketStatus.SETTLEMENT = { settlement: {} };
+    return MarketStatus;
+}());
+exports.MarketStatus = MarketStatus;
+var ContractType = /** @class */ (function () {
+    function ContractType() {
+    }
+    ContractType.PERPETUAL = { perpetual: {} };
+    ContractType.FUTURE = { future: {} };
+    return ContractType;
+}());
+exports.ContractType = ContractType;
+var SwapDirection = /** @class */ (function () {
+    function SwapDirection() {
+    }
+    SwapDirection.ADD = { add: {} };
+    SwapDirection.REMOVE = { remove: {} };
+    return SwapDirection;
+}());
+exports.SwapDirection = SwapDirection;
+var SpotBalanceType = /** @class */ (function () {
+    function SpotBalanceType() {
+    }
+    SpotBalanceType.DEPOSIT = { deposit: {} };
+    SpotBalanceType.BORROW = { borrow: {} };
+    return SpotBalanceType;
+}());
+exports.SpotBalanceType = SpotBalanceType;
+var PositionDirection = /** @class */ (function () {
+    function PositionDirection() {
+    }
+    PositionDirection.LONG = { long: {} };
+    PositionDirection.SHORT = { short: {} };
+    return PositionDirection;
+}());
+exports.PositionDirection = PositionDirection;
+var DepositDirection = /** @class */ (function () {
+    function DepositDirection() {
+    }
+    DepositDirection.DEPOSIT = { deposit: {} };
+    DepositDirection.WITHDRAW = { withdraw: {} };
+    return DepositDirection;
+}());
+exports.DepositDirection = DepositDirection;
+var OracleSource = /** @class */ (function () {
+    function OracleSource() {
+    }
+    OracleSource.PYTH = { pyth: {} };
+    OracleSource.SWITCHBOARD = { switchboard: {} };
+    OracleSource.QUOTE_ASSET = { quoteAsset: {} };
+    return OracleSource;
+}());
+exports.OracleSource = OracleSource;
+var OrderType = /** @class */ (function () {
+    function OrderType() {
+    }
+    OrderType.LIMIT = { limit: {} };
+    OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+    OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+    OrderType.MARKET = { market: {} };
+    return OrderType;
+}());
+exports.OrderType = OrderType;
+var MarketType = /** @class */ (function () {
+    function MarketType() {
+    }
+    MarketType.SPOT = { spot: {} };
+    MarketType.PERP = { perp: {} };
+    return MarketType;
+}());
+exports.MarketType = MarketType;
+var OrderStatus = /** @class */ (function () {
+    function OrderStatus() {
+    }
+    OrderStatus.INIT = { init: {} };
+    OrderStatus.OPEN = { open: {} };
+    return OrderStatus;
+}());
+exports.OrderStatus = OrderStatus;
+var OrderDiscountTier = /** @class */ (function () {
+    function OrderDiscountTier() {
+    }
+    OrderDiscountTier.NONE = { none: {} };
+    OrderDiscountTier.FIRST = { first: {} };
+    OrderDiscountTier.SECOND = { second: {} };
+    OrderDiscountTier.THIRD = { third: {} };
+    OrderDiscountTier.FOURTH = { fourth: {} };
+    return OrderDiscountTier;
+}());
+exports.OrderDiscountTier = OrderDiscountTier;
+var OrderAction = /** @class */ (function () {
+    function OrderAction() {
+    }
+    OrderAction.PLACE = { place: {} };
+    OrderAction.CANCEL = { cancel: {} };
+    OrderAction.EXPIRE = { expire: {} };
+    OrderAction.FILL = { fill: {} };
+    OrderAction.TRIGGER = { trigger: {} };
+    return OrderAction;
+}());
+exports.OrderAction = OrderAction;
+var OrderActionExplanation = /** @class */ (function () {
+    function OrderActionExplanation() {
+    }
+    OrderActionExplanation.NONE = { none: {} };
+    OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+        oraclePriceBreachedLimitPrice: {}
+    };
+    OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+        marketOrderFilledToLimitPrice: {}
+    };
+    OrderActionExplanation.CANCELED_FOR_LIQUIDATION = {
+        canceledForLiquidation: {}
+    };
+    OrderActionExplanation.MARKET_ORDER_AUCTION_EXPIRED = {
+        marketOrderAuctionExpired: {}
+    };
+    return OrderActionExplanation;
+}());
+exports.OrderActionExplanation = OrderActionExplanation;
+var OrderTriggerCondition = /** @class */ (function () {
+    function OrderTriggerCondition() {
+    }
+    OrderTriggerCondition.ABOVE = { above: {} };
+    OrderTriggerCondition.BELOW = { below: {} };
+    return OrderTriggerCondition;
+}());
+exports.OrderTriggerCondition = OrderTriggerCondition;
+var SpotFulfillmentType = /** @class */ (function () {
+    function SpotFulfillmentType() {
+    }
+    SpotFulfillmentType.SERUM_v3 = { serumV3: {} };
+    return SpotFulfillmentType;
+}());
+exports.SpotFulfillmentType = SpotFulfillmentType;
+var SpotFulfillmentStatus = /** @class */ (function () {
+    function SpotFulfillmentStatus() {
+    }
+    SpotFulfillmentStatus.ENABLED = { enabled: {} };
+    SpotFulfillmentStatus.DISABLED = { disabled: {} };
+    return SpotFulfillmentStatus;
+}());
+exports.SpotFulfillmentStatus = SpotFulfillmentStatus;
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
+function isOneOfVariant(object, types) {
+    return types.reduce(function (result, type) {
+        return result || object.hasOwnProperty(type);
+    }, false);
+}
+exports.isOneOfVariant = isOneOfVariant;
+var TradeSide;
+(function (TradeSide) {
+    TradeSide[TradeSide["None"] = 0] = "None";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+})(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+var LPAction = /** @class */ (function () {
+    function LPAction() {
+    }
+    LPAction.ADD_LIQUIDITY = { addLiquidity: {} };
+    LPAction.REMOVE_LIQUIDITY = { removeLiquidity: {} };
+    LPAction.SETTLE_LIQUIDITY = { settleLiquidity: {} };
+    return LPAction;
+}());
+exports.LPAction = LPAction;
+var LiquidationType = /** @class */ (function () {
+    function LiquidationType() {
+    }
+    LiquidationType.LIQUIDATE_PERP = { liquidatePerp: {} };
+    LiquidationType.LIQUIDATE_BORROW = { liquidateBorrow: {} };
+    LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
+        liquidateBorrowForPerpPnl: {}
+    };
+    LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+        liquidatePerpPnlForDeposit: {}
+    };
+    LiquidationType.PERP_BANKRUPTCY = {
+        perpBankruptcy: {}
+    };
+    LiquidationType.BORROW_BANKRUPTCY = {
+        borrowBankruptcy: {}
+    };
+    return LiquidationType;
+}());
+exports.LiquidationType = LiquidationType;
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    marketType: MarketType.PERP,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: _1.ZERO,
+    price: _1.ZERO,
+    marketIndex: _1.ZERO,
+    reduceOnly: false,
+    postOnly: false,
+    immediateOrCancel: false,
+    triggerPrice: _1.ZERO,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    positionLimit: _1.ZERO,
+    oraclePriceOffset: _1.ZERO,
+    padding0: _1.ZERO,
+    padding1: _1.ZERO
+};