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

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.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

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/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/tx/retryTxSender.ts

@@ -0,0 +1,196 @@
+import { TxSender } from './types';
+import {
+	Commitment,
+	ConfirmOptions,
+	Context,
+	RpcResponseAndContext,
+	Signer,
+	SignatureResult,
+	Transaction,
+	TransactionSignature,
+} from '@solana/web3.js';
+import { Provider } from '@project-serum/anchor';
+import assert from 'assert';
+import bs58 from 'bs58';
+
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_RETRY = 8000;
+
+type ResolveReference = {
+	resolve?: () => void;
+};
+
+export class RetryTxSender implements TxSender {
+	provider: Provider;
+	timeout: number;
+	retrySleep: number;
+
+	public constructor(
+		provider: Provider,
+		timeout?: number,
+		retrySleep?: number
+	) {
+		this.provider = provider;
+		this.timeout = timeout ?? DEFAULT_TIMEOUT;
+		this.retrySleep = retrySleep ?? DEFAULT_RETRY;
+	}
+
+	async send(
+		tx: Transaction,
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions
+	): Promise<TransactionSignature> {
+		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: TransactionSignature =
+			await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+
+		let done = false;
+		const resolveReference: 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();
+						});
+				}
+			}
+		})();
+
+		try {
+			await this.confirmTransaction(txid, opts.commitment);
+		} catch (e) {
+			console.error(e);
+			throw e;
+		} finally {
+			stopWaiting();
+		}
+
+		return txid;
+	}
+
+	async prepareTx(
+		tx: Transaction,
+		additionalSigners: Array<Signer>,
+		opts: ConfirmOptions
+	): Promise<Transaction> {
+		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 is Signer => s !== undefined)
+			.forEach((kp) => {
+				tx.partialSign(kp);
+			});
+
+		return tx;
+	}
+
+	async confirmTransaction(
+		signature: TransactionSignature,
+		commitment?: Commitment
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		let decodedSignature;
+		try {
+			decodedSignature = bs58.decode(signature);
+		} catch (err) {
+			throw new Error('signature must be base58 encoded: ' + signature);
+		}
+
+		assert(decodedSignature.length === 64, 'signature has invalid length');
+
+		const start = Date.now();
+		const subscriptionCommitment = commitment || this.provider.opts.commitment;
+
+		let subscriptionId;
+		let response: RpcResponseAndContext<SignatureResult> | null = null;
+		const confirmPromise = new Promise((resolve, reject) => {
+			try {
+				subscriptionId = this.provider.connection.onSignature(
+					signature,
+					(result: SignatureResult, context: Context) => {
+						subscriptionId = undefined;
+						response = {
+							context,
+							value: result,
+						};
+						resolve(null);
+					},
+					subscriptionCommitment
+				);
+			} catch (err) {
+				reject(err);
+			}
+		});
+
+		try {
+			await 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(): number {
+		return new Date().getTime();
+	}
+
+	async sleep(reference: ResolveReference): Promise<void> {
+		return new Promise((resolve) => {
+			reference.resolve = resolve;
+			setTimeout(resolve, this.retrySleep);
+		});
+	}
+
+	promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null> {
+		let timeoutId: ReturnType<typeof setTimeout>;
+		const timeoutPromise: Promise<null> = new Promise((resolve) => {
+			timeoutId = setTimeout(() => resolve(null), timeoutMs);
+		});
+
+		return Promise.race([promise, timeoutPromise]).then((result: T | null) => {
+			clearTimeout(timeoutId);
+			return result;
+		});
+	}
+}

package/src/tx/types.ts

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