@drift-labs/sdk 0.1.23-master.0 → 0.1.23-master.4

package/lib/tx/retryTxSender.js

@@ -0,0 +1,153 @@
+"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) {
+        this.provider = provider;
+        this.timeout = timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT;
+        this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
+    }
+    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);
+            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();
+                        });
+                    }
+                }
+            }))();
+            try {
+                yield this.confirmTransaction(txid, opts.commitment);
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+            finally {
+                stopWaiting();
+            }
+            return txid;
+        });
+    }
+    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);
+            }
+            (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+            const start = Date.now();
+            const subscriptionCommitment = commitment || this.provider.opts.commitment;
+            let subscriptionId;
+            let response = null;
+            const confirmPromise = new Promise((resolve, reject) => {
+                try {
+                    subscriptionId = this.provider.connection.onSignature(signature, (result, context) => {
+                        subscriptionId = undefined;
+                        response = {
+                            context,
+                            value: result,
+                        };
+                        resolve(null);
+                    }, subscriptionCommitment);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            try {
+                yield this.promiseTimeout(confirmPromise, this.timeout);
+            }
+            finally {
+                if (subscriptionId) {
+                    this.provider.connection.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(promise, timeoutMs) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => resolve(null), timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]).then((result) => {
+            clearTimeout(timeoutId);
+            return result;
+        });
+    }
+}
+exports.RetryTxSender = RetryTxSender;

package/lib/tx/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.23-master.0",
+	"version": "0.1.23-master.4",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.ts

@@ -135,19 +135,11 @@ export class BulkAccountLoader {
 			{ commitment: this.commitment },
 		];
 
-		let rpcResponse;
-		try {
-			// @ts-ignore
-			rpcResponse = await this.connection._rpcRequest(
-				'getMultipleAccounts',
-				args
-			);
-		} catch (e) {
-			for (const [_, callback] of this.errorCallbacks) {
-				callback(e);
-			}
-			return;
-		}
+		// @ts-ignore
+		const rpcResponse = await this.connection._rpcRequest(
+			'getMultipleAccounts',
+			args
+		);
 
 		const newSlot = rpcResponse.result.context.slot;
 

package/src/clearingHouse.ts

@@ -52,7 +52,6 @@ import {
 	ClearingHouseAccountTypes,
 } from './accounts/types';
 import { TxSender } from './tx/types';
-import { DefaultTxSender } from './tx/defaultTxSender';
 import { wrapInTx } from './tx/utils';
 import {
 	getClearingHouse,
@@ -250,12 +249,13 @@ export class ClearingHouse {
 			this.program.programId,
 			newProvider
 		);
-		const newTxSender = new DefaultTxSender(newProvider);
+
+		// Update provider for txSender with new wallet details
+		this.txSender.provider = newProvider;
 
 		this.wallet = newWallet;
 		this.provider = newProvider;
 		this.program = newProgram;
-		this.txSender = newTxSender;
 		this.userAccountPublicKey = undefined;
 		this.userAccount = undefined;
 	}

package/src/idl/clearing_house.json

@@ -1321,6 +1321,52 @@
         }
       ]
     },
+    {
+      "name": "initializeUserOrdersWithExplicitPayer",
+      "accounts": [
+        {
+          "name": "user",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "userOrders",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "payer",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "rent",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "systemProgram",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "userOrdersNonce",
+          "type": "u8"
+        }
+      ]
+    },
     {
       "name": "deleteUser",
       "accounts": [
@@ -3667,6 +3713,23 @@
         ]
       }
     },
+    {
+      "name": "LiquidationType",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "NONE"
+          },
+          {
+            "name": "PARTIAL"
+          },
+          {
+            "name": "FULL"
+          }
+        ]
+      }
+    },
     {
       "name": "OracleSource",
       "type": {
@@ -4064,6 +4127,11 @@
       "code": 6055,
       "name": "UserOrderIdAlreadyInUse",
       "msg": "User Order Id Already In Use"
+    },
+    {
+      "code": 6056,
+      "name": "NoPositionsLiquidatable",
+      "msg": "No positions liquidatable"
     }
   ]
 }

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './types';
 export * from './constants/markets';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
+export * from './accounts/bulkUserSubscription';
 export * from './accounts/pollingClearingHouseAccountSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/types';
@@ -31,6 +32,7 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
 

package/src/math/orders.ts

@@ -42,3 +42,36 @@ export function isOrderRiskIncreasing(
 
 	return false;
 }
+
+export function isOrderRiskIncreasingInSameDirection(
+	user: ClearingHouseUser,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getUserPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if no position exists, it's risk increasing
+	if (position.baseAssetAmount.eq(ZERO)) {
+		return true;
+	}
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return true;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return true;
+	}
+
+	return false;
+}

package/src/math/position.ts

@@ -47,7 +47,8 @@ export function calculateBaseAssetValue(
 			return newQuoteAssetReserve
 				.sub(market.amm.quoteAssetReserve)
 				.mul(market.amm.pegMultiplier)
-				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+				.add(ONE);
 	}
 }
 
@@ -74,7 +75,7 @@ export function calculatePositionPNL(
 	if (marketPosition.baseAssetAmount.gt(ZERO)) {
 		pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
 	} else {
-		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue).sub(ONE);
+		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
 	}
 
 	if (withFunding) {

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { Market, PositionDirection } from '../types';
+import { isVariant, Market, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -6,6 +6,7 @@ import {
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
+	ONE,
 } from '../constants/numericConstants';
 import { calculateMarkPrice } from './market';
 import {
@@ -114,16 +115,20 @@ export function calculateTradeAcquiredAmounts(
 		return [ZERO, ZERO];
 	}
 
+	const swapDirection = getSwapDirection(inputAssetType, direction);
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			inputAssetType,
 			amount,
-			getSwapDirection(inputAssetType, direction)
+			swapDirection
 		);
 
 	const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
-	const acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+	let acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+	if (inputAssetType === 'base' && isVariant(swapDirection, 'remove')) {
+		acquiredQuote = acquiredQuote.sub(ONE);
+	}
 
 	return [acquiredBase, acquiredQuote];
 }

package/src/orders.ts

@@ -3,16 +3,25 @@ import {
 	Market,
 	Order,
 	PositionDirection,
+	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import { BN } from '.';
+import {
+	BN,
+	calculateAmmReservesAfterSwap,
+	calculateBaseAssetValue,
+	ClearingHouseUser,
+	isOrderRiskIncreasingInSameDirection,
+	TEN_THOUSAND,
+} from '.';
 import {
 	calculateMarkPrice,
 	calculateNewMarketAfterTrade,
 } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -32,7 +41,10 @@ export function calculateNewStateAfterOrder(
 		return null;
 	}
 
-	const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
+		market,
+		order
+	);
 	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
 		return null;
 	}
@@ -157,7 +169,10 @@ function calculateAmountSwapped(
 	};
 }
 
-function calculateAmountToTrade(market: Market, order: Order): BN {
+export function calculateBaseAssetAmountMarketCanExecute(
+	market: Market,
+	order: Order
+): BN {
 	if (isVariant(order.orderType, 'limit')) {
 		return calculateAmountToTradeForLimit(market, order);
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
@@ -234,3 +249,41 @@ function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
 		return markPrice.lt(order.triggerPrice);
 	}
 }
+
+export function calculateBaseAssetAmountUserCanExecute(
+	market: Market,
+	order: Order,
+	user: ClearingHouseUser
+): BN {
+	const maxLeverage = user.getMaxLeverage('Initial');
+	const freeCollateral = user.getFreeCollateral();
+	let quoteAssetAmount: BN;
+	if (isOrderRiskIncreasingInSameDirection(user, order)) {
+		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
+	} else {
+		const position =
+			user.getUserPosition(order.marketIndex) ||
+			user.getEmptyPosition(order.marketIndex);
+		const positionValue = calculateBaseAssetValue(market, position);
+		quoteAssetAmount = freeCollateral
+			.mul(maxLeverage)
+			.div(TEN_THOUSAND)
+			.add(positionValue.mul(TWO));
+	}
+
+	if (quoteAssetAmount.lte(ZERO)) {
+		return ZERO;
+	}
+
+	const baseAssetReservesBefore = market.amm.baseAssetReserve;
+	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
+		market.amm,
+		'quote',
+		quoteAssetAmount,
+		isVariant(order.direction, 'long')
+			? SwapDirection.ADD
+			: SwapDirection.REMOVE
+	);
+
+	return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}