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

package/src/slot/SlotSubscriber.js

@@ -0,0 +1,39 @@
+"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());
+    });
+};
+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();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentSlot = yield this.connection.getSlot('confirmed');
+            this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+                this.currentSlot = slotInfo.slot;
+                this.eventEmitter.emit('newSlot', slotInfo.slot);
+            });
+        });
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscriptionId) {
+                yield this.connection.removeSlotChangeListener(this.subscriptionId);
+            }
+        });
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/src/slot/SlotSubscriber.ts

@@ -0,0 +1,42 @@
+import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type SlotSubscriberConfig = {}; // for future customization
+
+export interface SlotSubscriberEvents {
+	newSlot: (newSlot: number) => void;
+}
+
+export class SlotSubscriber {
+	currentSlot: number;
+	subscriptionId: number;
+	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
+
+	public constructor(
+		private connection: Connection,
+		_config?: SlotSubscriberConfig
+	) {
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public async subscribe(): Promise<void> {
+		this.currentSlot = await this.connection.getSlot('confirmed');
+
+		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+			this.currentSlot = slotInfo.slot;
+			this.eventEmitter.emit('newSlot', slotInfo.slot);
+		});
+	}
+
+	public getSlot(): number {
+		return this.currentSlot;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.subscriptionId) {
+			await this.connection.removeSlotChangeListener(this.subscriptionId);
+		}
+	}
+}

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

package/src/tx/retryTxSender.js

@@ -0,0 +1,188 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryTxSender = void 0;
+const assert_1 = __importDefault(require("assert"));
+const bs58_1 = __importDefault(require("bs58"));
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_RETRY = 8000;
+class RetryTxSender {
+    constructor(provider, timeout, retrySleep, 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;
+    }
+    send(tx, additionalSigners, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (additionalSigners === undefined) {
+                additionalSigners = [];
+            }
+            if (opts === undefined) {
+                opts = this.provider.opts;
+            }
+            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();
+                }
+            };
+            (() => __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);
+                    }
+                }
+            }))();
+            let slot;
+            try {
+                const result = yield 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;
+        });
+    }
+    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);
+            }
+            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;
+            });
+            try {
+                yield 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;
+        });
+    }
+    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);
+            });
+        });
+    }
+    promiseTimeout(promises, timeoutMs) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => resolve(null), timeoutMs);
+        });
+        return Promise.race([...promises, timeoutPromise]).then((result) => {
+            clearTimeout(timeoutId);
+            return result;
+        });
+    }
+    sendToAdditionalConnections(rawTx, opts) {
+        this.additionalConnections.map((connection) => {
+            connection.sendRawTransaction(rawTx, opts).catch((e) => {
+                console.error(
+                // @ts-ignore
+                `error sending tx to additional connection ${connection._rpcEndpoint}`);
+                console.error(e);
+            });
+        });
+    }
+    addAdditionalConnection(newConnection) {
+        const alreadyUsingConnection = this.additionalConnections.filter((connection) => {
+            // @ts-ignore
+            return connection._rpcEndpoint === newConnection.rpcEndpoint;
+        }).length > 0;
+        if (!alreadyUsingConnection) {
+            this.additionalConnections.push(newConnection);
+        }
+    }
+}
+exports.RetryTxSender = RetryTxSender;

package/src/tx/retryTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSender } from './types';
+import { TxSender, TxSigAndSlot } from './types';
 import {
 	Commitment,
 	ConfirmOptions,
@@ -43,7 +43,7 @@ export class RetryTxSender implements TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
-	): Promise<TransactionSignature> {
+	): Promise<TxSigAndSlot> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
 		}
@@ -86,8 +86,10 @@ export class RetryTxSender implements TxSender {
 			}
 		})();
 
+		let slot: number;
 		try {
-			await this.confirmTransaction(txid, opts.commitment);
+			const result = await this.confirmTransaction(txid, opts.commitment);
+			slot = result.context.slot;
 		} catch (e) {
 			console.error(e);
 			throw e;
@@ -95,7 +97,7 @@ export class RetryTxSender implements TxSender {
 			stopWaiting();
 		}
 
-		return txid;
+		return { txSig: txid, slot };
 	}
 
 	async prepareTx(

package/src/tx/types.js

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

package/src/tx/types.ts

@@ -6,6 +6,11 @@ import {
 	TransactionSignature,
 } from '@solana/web3.js';
 
+export type TxSigAndSlot = {
+	txSig: TransactionSignature;
+	slot: number;
+};
+
 export interface TxSender {
 	provider: Provider;
 
@@ -13,5 +18,5 @@ export interface TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
-	): Promise<TransactionSignature>;
+	): Promise<TxSigAndSlot>;
 }

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: 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
+) {
+    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;

package/src/tx/utils.ts

@@ -1,5 +1,24 @@
-import { Transaction, TransactionInstruction } from '@solana/web3.js';
+import {
+	Transaction,
+	TransactionInstruction,
+	ComputeBudgetProgram,
+} from '@solana/web3.js';
 
-export function wrapInTx(instruction: TransactionInstruction): Transaction {
-	return new Transaction().add(instruction);
+const COMPUTE_UNITS_DEFAULT = 200_000;
+
+export function wrapInTx(
+	instruction: TransactionInstruction,
+	computeUnits = 600_000 // TODO, requires less code change
+): Transaction {
+	const tx = new Transaction();
+	if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: computeUnits,
+				additionalFee: 0,
+			})
+		);
+	}
+
+	return tx.add(instruction);
 }

package/src/types.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderParams = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+const _1 = require(".");
+// # Utility Types / Enums / Constants
+class SwapDirection {
+}
+exports.SwapDirection = SwapDirection;
+SwapDirection.ADD = { add: {} };
+SwapDirection.REMOVE = { remove: {} };
+class BankBalanceType {
+}
+exports.BankBalanceType = BankBalanceType;
+BankBalanceType.DEPOSIT = { deposit: {} };
+BankBalanceType.BORROW = { borrow: {} };
+class PositionDirection {
+}
+exports.PositionDirection = PositionDirection;
+PositionDirection.LONG = { long: {} };
+PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
+class OracleSource {
+}
+exports.OracleSource = OracleSource;
+OracleSource.PYTH = { pyth: {} };
+OracleSource.SWITCHBOARD = { switchboard: {} };
+OracleSource.QUOTE_ASSET = { quoteAsset: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.EXPIRE = { expire: {} };
+OrderAction.FILL = { fill: {} };
+OrderAction.TRIGGER = { trigger: {} };
+class OrderActionExplanation {
+}
+exports.OrderActionExplanation = OrderActionExplanation;
+OrderActionExplanation.NONE = { none: {} };
+OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
+    breachedMarginRequirement: {},
+};
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {},
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {},
+};
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
+function isOneOfVariant(object, types) {
+    return types.reduce((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 = {}));
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    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,
+    optionalAccounts: {
+        discountToken: false,
+        referrer: false,
+    },
+};