@drift-labs/sdk 0.1.22 → 0.1.23-master.3

package/lib/orders.js

@@ -1,26 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
+const _1 = require(".");
 const market_1 = require("./math/market");
 const numericConstants_1 = require("./constants/numericConstants");
 const amm_1 = require("./math/amm");
 const position_1 = require("./math/position");
 function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if (types_1.isVariant(order.status, 'init')) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
         return null;
     }
-    const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
     if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
         return null;
     }
     const userAccountAfter = Object.assign({}, userAccount);
     const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
+    const currentPositionDirection = (0, position_1.positionCurrentDirection)(userPosition);
     const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
         isSameDirection(order.direction, currentPositionDirection);
     if (increasePosition) {
-        const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+        const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
         const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
         userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
         userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
@@ -29,10 +30,10 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
     else {
         const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
         if (reversePosition) {
-            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
+            const intermediateMarket = (0, market_1.calculateNewMarketAfterTrade)(userPosition.baseAssetAmount, (0, position_1.findDirectionToClose)(userPosition), market);
             const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
             let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
+            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
                 pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
             }
             else {
@@ -40,20 +41,20 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
             }
             userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
             const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
+            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountLeft, order.direction, intermediateMarket);
             const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
             userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
             userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
             return [userAccountAfter, userPositionAfter, marketAfter];
         }
         else {
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
             const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
             const costBasisRealized = userPosition.quoteAssetAmount
                 .mul(baseAssetAmountSwapped.abs())
                 .div(userPosition.baseAssetAmount.abs());
             let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
+            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
                 pnl = baseAssetValue.sub(costBasisRealized);
             }
             else {
@@ -79,14 +80,14 @@ function calculateAmountSwapped(marketBefore, marketAfter) {
         baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
     };
 }
-function calculateAmountToTrade(market, order) {
-    if (types_1.isVariant(order.orderType, 'limit')) {
+function calculateBaseAssetAmountMarketCanExecute(market, order) {
+    if ((0, types_1.isVariant)(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order);
     }
-    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
+    else if ((0, types_1.isVariant)(order.orderType, 'triggerLimit')) {
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
-    else if (types_1.isVariant(order.orderType, 'market')) {
+    else if ((0, types_1.isVariant)(order.orderType, 'market')) {
         // should never be a market order queued
         return numericConstants_1.ZERO;
     }
@@ -94,8 +95,9 @@ function calculateAmountToTrade(market, order) {
         return calculateAmountToTradeForTriggerMarket(market, order);
     }
 }
+exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
 function calculateAmountToTradeForLimit(market, order) {
-    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, order.price);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, order.price);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {
@@ -117,8 +119,8 @@ function calculateAmountToTradeForTriggerLimit(market, order) {
 }
 exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
 function isSameDirection(firstDirection, secondDirection) {
-    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
-        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
+    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
+        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function calculateAmountToTradeForTriggerMarket(market, order) {
     return isTriggerConditionSatisfied(market, order)
@@ -126,11 +128,37 @@ function calculateAmountToTradeForTriggerMarket(market, order) {
         : numericConstants_1.ZERO;
 }
 function isTriggerConditionSatisfied(market, order) {
-    const markPrice = market_1.calculateMarkPrice(market);
-    if (types_1.isVariant(order.triggerCondition, 'above')) {
+    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('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)) {
+        return numericConstants_1.ZERO;
+    }
+    const baseAssetReservesBefore = market.amm.baseAssetReserve;
+    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(market.amm, 'quote', quoteAssetAmount, (0, types_1.isVariant)(order.direction, 'long')
+        ? types_1.SwapDirection.ADD
+        : types_1.SwapDirection.REMOVE);
+    return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}
+exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/pythClient.js

@@ -18,7 +18,7 @@ class PythClient {
     getPriceData(pricePublicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const account = yield this.connection.getAccountInfo(pricePublicKey);
-            return client_1.parsePriceData(account.data);
+            return (0, client_1.parsePriceData)(account.data);
         });
     }
 }

package/lib/tx/retryTxSender.d.ts

@@ -0,0 +1,19 @@
+import { TxSender } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature } from '@solana/web3.js';
+import { Provider } from '@project-serum/anchor';
+declare type ResolveReference = {
+    resolve?: () => void;
+};
+export declare class RetryTxSender implements TxSender {
+    provider: Provider;
+    timeout: number;
+    retrySleep: number;
+    constructor(provider: Provider, timeout?: number, retrySleep?: number);
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
+    confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getTimestamp(): number;
+    sleep(reference: ResolveReference): Promise<void>;
+    promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null>;
+}
+export {};

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.22",
+	"version": "0.1.23-master.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkUserSubscription.ts

@@ -1,6 +1,9 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
+import { UserAccount, UserOrdersAccount } from '../types';
+import { UserPublicKeys } from './types';
+import { ProgramAccount } from '@project-serum/anchor';
 
 /**
  * @param users
@@ -10,11 +13,58 @@ export async function bulkPollingUserSubscribe(
 	users: ClearingHouseUser[],
 	accountLoader: BulkAccountLoader
 ): Promise<void> {
+	if (users.length === 0) {
+		await accountLoader.load();
+		return;
+	}
+
+	// Fetch all the accounts first
+	const program = users[0].clearingHouse.program;
+	let userProgramAccounts: ProgramAccount[];
+	let orderProgramAccounts: ProgramAccount[];
+	await Promise.all([
+		(async () => {
+			userProgramAccounts = await program.account.user.all();
+		})(),
+		(async () => {
+			orderProgramAccounts = await program.account.userOrders.all();
+		})(),
+	]);
+
+	// Create a map of the authority to keys
+	const authorityToKeys = new Map<string, UserPublicKeys>();
+	const userToAuthority = new Map<string, string>();
+	for (const userProgramAccount of userProgramAccounts) {
+		const userAccountPublicKey = userProgramAccount.publicKey;
+		const userAccount = userProgramAccount.account as UserAccount;
+
+		authorityToKeys.set(userAccount.authority.toString(), {
+			user: userAccountPublicKey,
+			userPositions: userAccount.positions,
+			userOrders: undefined,
+		});
+
+		userToAuthority.set(
+			userAccountPublicKey.toString(),
+			userAccount.authority.toString()
+		);
+	}
+	for (const orderProgramAccount of orderProgramAccounts) {
+		const userOrderAccountPublicKey = orderProgramAccount.publicKey;
+		const userOrderAccount = orderProgramAccount.account as UserOrdersAccount;
+
+		const authority = userToAuthority.get(userOrderAccount.user.toString());
+		const userPublicKeys = authorityToKeys.get(authority);
+		userPublicKeys.userOrders = userOrderAccountPublicKey;
+	}
+
 	await Promise.all(
 		users.map((user) => {
+			// Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
+			const userPublicKeys = authorityToKeys.get(user.authority.toString());
 			return (
 				user.accountSubscriber as PollingUserAccountSubscriber
-			).addToAccountLoader();
+			).addToAccountLoader(userPublicKeys);
 		})
 	);
 

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -3,6 +3,7 @@ import {
 	NotSubscribedError,
 	UserAccountEvents,
 	UserAccountSubscriber,
+	UserPublicKeys,
 } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
@@ -58,55 +59,73 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		return true;
 	}
 
-	async addToAccountLoader(): Promise<void> {
+	async addToAccountLoader(userPublicKeys?: UserPublicKeys): Promise<void> {
 		if (this.accountsToPoll.size > 0) {
 			return;
 		}
 
-		const userPublicKey = await getUserAccountPublicKey(
-			this.program.programId,
-			this.authority
-		);
+		if (!userPublicKeys) {
+			const userPublicKey = await getUserAccountPublicKey(
+				this.program.programId,
+				this.authority
+			);
 
-		const userAccount = (await this.program.account.user.fetch(
-			userPublicKey
-		)) as UserAccount;
+			const userAccount = (await this.program.account.user.fetch(
+				userPublicKey
+			)) as UserAccount;
 
-		this.accountsToPoll.set(userPublicKey.toString(), {
-			key: 'user',
-			publicKey: userPublicKey,
-			eventType: 'userAccountData',
-		});
+			this.accountsToPoll.set(userPublicKey.toString(), {
+				key: 'user',
+				publicKey: userPublicKey,
+				eventType: 'userAccountData',
+			});
 
-		this.accountsToPoll.set(userAccount.positions.toString(), {
-			key: 'userPositions',
-			publicKey: userAccount.positions,
-			eventType: 'userPositionsData',
-		});
+			this.accountsToPoll.set(userAccount.positions.toString(), {
+				key: 'userPositions',
+				publicKey: userAccount.positions,
+				eventType: 'userPositionsData',
+			});
+
+			const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
+				this.program.programId,
+				userPublicKey
+			);
 
-		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
-			this.program.programId,
-			userPublicKey
-		);
-
-		const userOrdersExist =
-			(
-				await this.program.provider.connection.getParsedAccountInfo(
-					userOrdersPublicKey
-				)
-			).value !== null;
-		if (userOrdersExist) {
 			this.accountsToPoll.set(userOrdersPublicKey.toString(), {
 				key: 'userOrders',
 				publicKey: userOrdersPublicKey,
 				eventType: 'userOrdersData',
 			});
+		} else {
+			this.accountsToPoll.set(userPublicKeys.user.toString(), {
+				key: 'user',
+				publicKey: userPublicKeys.user,
+				eventType: 'userAccountData',
+			});
+
+			this.accountsToPoll.set(userPublicKeys.userPositions.toString(), {
+				key: 'userPositions',
+				publicKey: userPublicKeys.userPositions,
+				eventType: 'userPositionsData',
+			});
+
+			if (userPublicKeys.userOrders) {
+				this.accountsToPoll.set(userPublicKeys.userOrders.toString(), {
+					key: 'userOrders',
+					publicKey: userPublicKeys.userOrders,
+					eventType: 'userOrdersData',
+				});
+			}
 		}
 
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			accountToPoll.callbackId = this.accountLoader.addAccount(
 				accountToPoll.publicKey,
 				(buffer) => {
+					if (!buffer) {
+						return;
+					}
+
 					const account = this.program.account[
 						accountToPoll.key
 					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);

package/src/accounts/types.ts

@@ -82,6 +82,12 @@ export interface ClearingHouseAccountSubscriber {
 	type: ClearingHouseConfigType;
 }
 
+export type UserPublicKeys = {
+	user: PublicKey;
+	userPositions: PublicKey;
+	userOrders: PublicKey | undefined;
+};
+
 export interface UserAccountEvents {
 	userAccountData: (payload: UserAccount) => void;
 	userPositionsData: (payload: UserPositionsAccount) => void;

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';