@drift-labs/sdk 0.1.29-master.1 → 0.1.30-master.1

package/lib/accounts/bulkAccountLoader.d.ts

@@ -16,7 +16,7 @@ export declare class BulkAccountLoader {
     loadPromise?: Promise<void>;
     loadPromiseResolver: () => void;
     loggingEnabled: boolean;
-    lastUpdate: number;
+    lastTimeLoadingPromiseCleared: number;
     constructor(connection: Connection, commitment: Commitment, pollingFrequency: number);
     addAccount(publicKey: PublicKey, callback: (buffer: Buffer) => void): string;
     removeAccount(publicKey: PublicKey, callbackId: string): void;
@@ -29,5 +29,6 @@ export declare class BulkAccountLoader {
     getAccountData(publicKey: PublicKey): Buffer | undefined;
     startPolling(): void;
     stopPolling(): void;
+    log(msg: string, force?: boolean): void;
 }
 export {};

package/lib/accounts/bulkAccountLoader.js

@@ -10,18 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BulkAccountLoader = void 0;
-const web3_js_1 = require("@solana/web3.js");
 const uuid_1 = require("uuid");
+const promiseTimeout_1 = require("../util/promiseTimeout");
 const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
 const oneMinute = 60 * 1000;
-const fiveMinutes = 5 * 60 * 1000;
 class BulkAccountLoader {
     constructor(connection, commitment, pollingFrequency) {
         this.accountsToLoad = new Map();
         this.accountData = new Map();
         this.errorCallbacks = new Map();
         this.loggingEnabled = false;
-        this.lastUpdate = Date.now();
+        this.lastTimeLoadingPromiseCleared = Date.now();
         this.connection = connection;
         this.commitment = commitment;
         this.pollingFrequency = pollingFrequency;
@@ -29,11 +28,14 @@ class BulkAccountLoader {
     addAccount(publicKey, callback) {
         const existingSize = this.accountsToLoad.size;
         const callbackId = (0, uuid_1.v4)();
+        this.log(`Adding account ${publicKey.toString()} callback id ${callbackId}`);
         const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
         if (existingAccountToLoad) {
+            this.log(`account already exists`);
             existingAccountToLoad.callbacks.set(callbackId, callback);
         }
         else {
+            this.log(`account doesn't already exist. creating new callback map`);
             const callbacks = new Map();
             callbacks.set(callbackId, callback);
             const newAccountToLoad = {
@@ -50,6 +52,7 @@ class BulkAccountLoader {
         return callbackId;
     }
     removeAccount(publicKey, callbackId) {
+        this.log(`Removing account ${publicKey.toString()} callback id ${callbackId}`);
         const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
         if (existingAccountToLoad) {
             existingAccountToLoad.callbacks.delete(callbackId);
@@ -78,13 +81,24 @@ class BulkAccountLoader {
     load() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.loadPromise) {
-                return this.loadPromise;
+                const now = Date.now();
+                if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+                    this.log(`Load promise hasnt been clearing for one minute. Clearing.`);
+                    this.loadPromise = undefined;
+                }
+                else {
+                    this.log(`Load promise exists. Returning early`);
+                    return this.loadPromise;
+                }
             }
             this.loadPromise = new Promise((resolver) => {
                 this.loadPromiseResolver = resolver;
             });
+            this.lastTimeLoadingPromiseCleared = Date.now();
+            this.log(`Loading`);
             try {
                 const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+                this.log(`${chunks.length} chunks`);
                 yield Promise.all(chunks.map((chunk) => {
                     return this.loadChunk(chunk);
                 }));
@@ -95,25 +109,19 @@ class BulkAccountLoader {
                 for (const [_, callback] of this.errorCallbacks) {
                     callback(e);
                 }
+                this.log('finished error callbacks');
             }
             finally {
+                this.log(`resetting load promise`);
                 this.loadPromiseResolver();
                 this.loadPromise = undefined;
-                const now = Date.now();
-                if (now - this.lastUpdate > fiveMinutes) {
-                    if (this.loggingEnabled) {
-                        console.log("Haven't seen updated account in five minutes. Bulk account loader creating new Connection Object");
-                    }
-                    this.connection = new web3_js_1.Connection(
-                    // @ts-ignore
-                    this.connection._rpcEndpoint, this.connection.commitment);
-                }
             }
         });
     }
     loadChunk(accountsToLoad) {
         return __awaiter(this, void 0, void 0, function* () {
             if (accountsToLoad.length === 0) {
+                this.log(`no accounts in chunk`);
                 return;
             }
             const args = [
@@ -122,11 +130,13 @@ class BulkAccountLoader {
                 }),
                 { commitment: this.commitment },
             ];
+            const rpcResponse = yield (0, promiseTimeout_1.promiseTimeout)(
             // @ts-ignore
-            const rpcResponse = yield this.connection._rpcRequest('getMultipleAccounts', args);
-            const oneMinuteSinceLastUpdate = Date.now() - this.lastUpdate > oneMinute;
-            if (this.loggingEnabled && oneMinuteSinceLastUpdate) {
-                console.log('rpcResponse', JSON.stringify(rpcResponse));
+            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
+            );
+            if (rpcResponse === null) {
+                this.log('request to rpc timed out', true);
+                return;
             }
             const newSlot = rpcResponse.result.context.slot;
             for (const i in accountsToLoad) {
@@ -139,42 +149,43 @@ class BulkAccountLoader {
                     const dataType = rpcResponse.result.value[i].data[1];
                     newBuffer = Buffer.from(raw, dataType);
                 }
-                if (this.loggingEnabled && oneMinuteSinceLastUpdate) {
-                    console.log('oldRPCResponse', oldRPCResponse);
-                }
                 if (!oldRPCResponse) {
+                    this.log('No old rpc response, updating account data');
                     this.accountData.set(key, {
                         slot: newSlot,
                         buffer: newBuffer,
                     });
                     this.handleAccountCallbacks(accountToLoad, newBuffer);
-                    this.lastUpdate = Date.now();
                     continue;
                 }
                 if (newSlot <= oldRPCResponse.slot) {
+                    this.log(`new slot ${newSlot} old slot ${oldRPCResponse.slot}`);
                     continue;
                 }
                 const oldBuffer = oldRPCResponse.buffer;
                 if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.log('new buffer, updating account data');
                     this.accountData.set(key, {
                         slot: newSlot,
                         buffer: newBuffer,
                     });
                     this.handleAccountCallbacks(accountToLoad, newBuffer);
-                    this.lastUpdate = Date.now();
                 }
-                else if (this.loggingEnabled) {
-                    console.log('unable to update account for newest slot');
-                    console.log('oldBuffer', oldBuffer);
-                    console.log('newBuffer', newBuffer);
+                else {
+                    this.log('unable to update account for newest slot');
+                    this.log('oldBuffer ' + oldBuffer);
+                    this.log('newBuffer ' + newBuffer);
+                    this.log('buffers equal ' + newBuffer.equals(oldBuffer));
                 }
             }
         });
     }
     handleAccountCallbacks(accountToLoad, buffer) {
+        this.log('handling account callbacks');
         for (const [_, callback] of accountToLoad.callbacks) {
             callback(buffer);
         }
+        this.log('finished account callbacks');
     }
     getAccountData(publicKey) {
         const accountData = this.accountData.get(publicKey.toString());
@@ -184,18 +195,19 @@ class BulkAccountLoader {
         if (this.intervalId) {
             return;
         }
-        if (this.loggingEnabled) {
-            console.log(`startPolling`);
-        }
+        this.log('startPolling');
         this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
     }
     stopPolling() {
         if (this.intervalId) {
             clearInterval(this.intervalId);
             this.intervalId = undefined;
-            if (this.loggingEnabled) {
-                console.log(`stopPolling`);
-            }
+            this.log('stopPolling');
+        }
+    }
+    log(msg, force = false) {
+        if (this.loggingEnabled || force) {
+            console.log(msg);
         }
     }
 }

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts

@@ -6,6 +6,7 @@ import { EventEmitter } from 'events';
 import { DepositHistoryAccount, ExtendedCurveHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, LiquidationHistoryAccount, MarketsAccount, OrderHistoryAccount, OrderStateAccount, StateAccount, TradeHistoryAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { PublicKey } from '@solana/web3.js';
 export declare class PollingClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
@@ -31,6 +32,7 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     constructor(program: Program, accountLoader: BulkAccountLoader);
     subscribe(optionalSubscriptions?: ClearingHouseAccountTypes[]): Promise<boolean>;
     updateAccountsToPoll(): Promise<void>;
+    getClearingHouseAccounts(): Promise<ClearingHouseAccounts>;
     addToAccountLoader(): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
@@ -47,3 +49,16 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     getLiquidationHistoryAccount(): LiquidationHistoryAccount;
     getOrderHistoryAccount(): OrderHistoryAccount;
 }
+declare type ClearingHouseAccounts = {
+    state: PublicKey;
+    markets: PublicKey;
+    orderState: PublicKey;
+    tradeHistory?: PublicKey;
+    depositHistory?: PublicKey;
+    fundingPaymentHistory?: PublicKey;
+    fundingRateHistory?: PublicKey;
+    extendedCurveHistory?: PublicKey;
+    liquidationHistory?: PublicKey;
+    orderHistory?: PublicKey;
+};
+export {};

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -14,6 +14,7 @@ const types_1 = require("./types");
 const events_1 = require("events");
 const addresses_1 = require("../addresses");
 const utils_1 = require("./utils");
+const accounts_1 = require("../constants/accounts");
 class PollingClearingHouseAccountSubscriber {
     constructor(program, accountLoader) {
         this.accountsToPoll = new Map();
@@ -54,75 +55,101 @@ class PollingClearingHouseAccountSubscriber {
             if (this.accountsToPoll.size > 0) {
                 return;
             }
-            const statePublicKey = yield (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-            const state = (yield this.program.account.state.fetch(statePublicKey));
-            this.accountsToPoll.set(statePublicKey.toString(), {
+            const accounts = yield this.getClearingHouseAccounts();
+            this.accountsToPoll.set(accounts.state.toString(), {
                 key: 'state',
-                publicKey: statePublicKey,
+                publicKey: accounts.state,
                 eventType: 'stateAccountUpdate',
             });
-            this.accountsToPoll.set(state.markets.toString(), {
+            this.accountsToPoll.set(accounts.markets.toString(), {
                 key: 'markets',
-                publicKey: state.markets,
+                publicKey: accounts.markets,
                 eventType: 'marketsAccountUpdate',
             });
-            this.accountsToPoll.set(state.orderState.toString(), {
+            this.accountsToPoll.set(accounts.orderState.toString(), {
                 key: 'orderState',
-                publicKey: state.orderState,
+                publicKey: accounts.orderState,
                 eventType: 'orderStateAccountUpdate',
             });
             if ((_a = this.optionalExtraSubscriptions) === null || _a === void 0 ? void 0 : _a.includes('tradeHistoryAccount')) {
-                this.accountsToPoll.set(state.tradeHistory.toString(), {
+                this.accountsToPoll.set(accounts.tradeHistory.toString(), {
                     key: 'tradeHistory',
-                    publicKey: state.tradeHistory,
+                    publicKey: accounts.tradeHistory,
                     eventType: 'tradeHistoryAccountUpdate',
                 });
             }
             if ((_b = this.optionalExtraSubscriptions) === null || _b === void 0 ? void 0 : _b.includes('depositHistoryAccount')) {
-                this.accountsToPoll.set(state.depositHistory.toString(), {
+                this.accountsToPoll.set(accounts.depositHistory.toString(), {
                     key: 'depositHistory',
-                    publicKey: state.depositHistory,
+                    publicKey: accounts.depositHistory,
                     eventType: 'depositHistoryAccountUpdate',
                 });
             }
             if ((_c = this.optionalExtraSubscriptions) === null || _c === void 0 ? void 0 : _c.includes('fundingPaymentHistoryAccount')) {
-                this.accountsToPoll.set(state.fundingPaymentHistory.toString(), {
+                this.accountsToPoll.set(accounts.fundingPaymentHistory.toString(), {
                     key: 'fundingPaymentHistory',
-                    publicKey: state.fundingPaymentHistory,
+                    publicKey: accounts.fundingPaymentHistory,
                     eventType: 'fundingPaymentHistoryAccountUpdate',
                 });
             }
             if ((_d = this.optionalExtraSubscriptions) === null || _d === void 0 ? void 0 : _d.includes('fundingRateHistoryAccount')) {
-                this.accountsToPoll.set(state.fundingRateHistory.toString(), {
+                this.accountsToPoll.set(accounts.fundingRateHistory.toString(), {
                     key: 'fundingRateHistory',
-                    publicKey: state.fundingRateHistory,
+                    publicKey: accounts.fundingRateHistory,
                     eventType: 'fundingRateHistoryAccountUpdate',
                 });
             }
             if ((_e = this.optionalExtraSubscriptions) === null || _e === void 0 ? void 0 : _e.includes('curveHistoryAccount')) {
-                this.accountsToPoll.set(state.extendedCurveHistory.toString(), {
+                this.accountsToPoll.set(accounts.extendedCurveHistory.toString(), {
                     key: 'extendedCurveHistory',
-                    publicKey: state.extendedCurveHistory,
+                    publicKey: accounts.extendedCurveHistory,
                     eventType: 'curveHistoryAccountUpdate',
                 });
             }
             if ((_f = this.optionalExtraSubscriptions) === null || _f === void 0 ? void 0 : _f.includes('liquidationHistoryAccount')) {
-                this.accountsToPoll.set(state.liquidationHistory.toString(), {
+                this.accountsToPoll.set(accounts.liquidationHistory.toString(), {
                     key: 'liquidationHistory',
-                    publicKey: state.liquidationHistory,
+                    publicKey: accounts.liquidationHistory,
                     eventType: 'liquidationHistoryAccountUpdate',
                 });
             }
             if ((_g = this.optionalExtraSubscriptions) === null || _g === void 0 ? void 0 : _g.includes('orderHistoryAccount')) {
-                const orderState = (yield this.program.account.orderState.fetch(state.orderState));
-                this.accountsToPoll.set(orderState.orderHistory.toString(), {
+                this.accountsToPoll.set(accounts.orderHistory.toString(), {
                     key: 'orderHistory',
-                    publicKey: orderState.orderHistory,
+                    publicKey: accounts.orderHistory,
                     eventType: 'orderHistoryAccountUpdate',
                 });
             }
         });
     }
+    getClearingHouseAccounts() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Skip extra calls to rpc if we already know all the accounts
+            if (accounts_1.CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()]) {
+                return accounts_1.CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()];
+            }
+            const statePublicKey = yield (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
+            const state = (yield this.program.account.state.fetch(statePublicKey));
+            const accounts = {
+                state: statePublicKey,
+                markets: state.markets,
+                orderState: state.orderState,
+                tradeHistory: state.tradeHistory,
+                depositHistory: state.depositHistory,
+                fundingPaymentHistory: state.fundingPaymentHistory,
+                fundingRateHistory: state.fundingRateHistory,
+                extendedCurveHistory: state.extendedCurveHistory,
+                liquidationHistory: state.liquidationHistory,
+                orderHistory: undefined,
+            };
+            if ((_a = this.optionalExtraSubscriptions) === null || _a === void 0 ? void 0 : _a.includes('orderHistoryAccount')) {
+                const orderState = (yield this.program.account.orderState.fetch(state.orderState));
+                accounts.orderHistory = orderState.orderHistory;
+            }
+            return accounts;
+        });
+    }
     addToAccountLoader() {
         return __awaiter(this, void 0, void 0, function* () {
             for (const [_, accountToPoll] of this.accountsToPoll) {

package/lib/clearingHouse.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 import { BN, Program, Provider } from '@project-serum/anchor';
-import { MarketsAccount, StateAccount, DepositHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, IWallet, LiquidationHistoryAccount, PositionDirection, TradeHistoryAccount, UserAccount, Market, OrderHistoryAccount, OrderStateAccount, OrderParams, Order, ExtendedCurveHistoryAccount } from './types';
+import { MarketsAccount, StateAccount, DepositHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, IWallet, LiquidationHistoryAccount, PositionDirection, TradeHistoryAccount, UserAccount, Market, OrderHistoryAccount, OrderStateAccount, OrderParams, Order, ExtendedCurveHistoryAccount, UserPositionsAccount } from './types';
 import { Connection, PublicKey, TransactionSignature, Keypair, ConfirmOptions, TransactionInstruction } from '@solana/web3.js';
 import { MockUSDCFaucet } from './mockUSDCFaucet';
 import { EventEmitter } from 'events';
@@ -113,7 +113,6 @@ export declare class ClearingHouse {
      */
     initializeUserAccountAndDepositCollateral(amount: BN, collateralAccountPublicKey: PublicKey): Promise<[TransactionSignature, PublicKey]>;
     initializeUserAccountForDevnet(mockUSDCFaucet: MockUSDCFaucet, amount: BN): Promise<[TransactionSignature, PublicKey]>;
-    deleteUser(): Promise<TransactionSignature>;
     withdrawCollateral(amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
     getWithdrawCollateralIx(amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
     openPosition(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
@@ -127,6 +126,8 @@ export declare class ClearingHouse {
     getCancelOrderIx(orderId: BN, oracle?: PublicKey): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number, oracle?: PublicKey): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number, oracle?: PublicKey): Promise<TransactionInstruction>;
+    cancelAllOrders(oracles?: PublicKey[]): Promise<TransactionSignature>;
+    getCancelAllOrdersIx(oracles: PublicKey[]): Promise<TransactionInstruction>;
     fillOrder(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey, order: Order): Promise<TransactionSignature>;
     getFillOrderIx(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey, order: Order): Promise<TransactionInstruction>;
     initializeUserOrdersThenPlaceAndFillOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
@@ -141,6 +142,7 @@ export declare class ClearingHouse {
      */
     closePosition(marketIndex: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
     getClosePositionIx(marketIndex: BN, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionInstruction>;
+    closeAllPositions(userPositionsAccount: UserPositionsAccount, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
     liquidate(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionSignature>;
     getLiquidateIx(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
     updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;

package/lib/clearingHouse.js

@@ -371,20 +371,6 @@ class ClearingHouse {
             return [txSig, userAccountPublicKey];
         });
     }
-    deleteUser() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const user = yield this.program.account.user.fetch(userAccountPublicKey);
-            const deleteUserTx = yield this.program.transaction.deleteUser({
-                accounts: {
-                    user: userAccountPublicKey,
-                    userPositions: user.positions,
-                    authority: this.wallet.publicKey,
-                },
-            });
-            return this.txSender.send(deleteUserTx, [], this.opts);
-        });
-    }
     withdrawCollateral(amount, collateralAccountPublicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.txSender.send((0, utils_1.wrapInTx)(yield this.getWithdrawCollateralIx(amount, collateralAccountPublicKey)), [], this.opts);
@@ -634,6 +620,42 @@ class ClearingHouse {
             });
         });
     }
+    cancelAllOrders(oracles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelAllOrdersIx(oracles)), [], this.opts);
+        });
+    }
+    getCancelAllOrdersIx(oracles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userAccountPublicKey = yield this.getUserAccountPublicKey();
+            const userAccount = yield this.getUserAccount();
+            const state = this.getStateAccount();
+            const orderState = this.getOrderStateAccount();
+            const remainingAccounts = [];
+            for (const oracle of oracles) {
+                remainingAccounts.push({
+                    pubkey: oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+            return yield this.program.instruction.cancelAllOrders({
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    user: userAccountPublicKey,
+                    authority: this.wallet.publicKey,
+                    markets: state.markets,
+                    userOrders: yield this.getUserOrdersAccountPublicKey(),
+                    userPositions: userAccount.positions,
+                    fundingPaymentHistory: state.fundingPaymentHistory,
+                    fundingRateHistory: state.fundingRateHistory,
+                    orderState: yield this.getOrderStatePublicKey(),
+                    orderHistory: orderState.orderHistory,
+                },
+                remainingAccounts,
+            });
+        });
+    }
     fillOrder(userAccountPublicKey, userOrdersAccountPublicKey, order) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getFillOrderIx(userAccountPublicKey, userOrdersAccountPublicKey, order)), [], this.opts);
@@ -801,6 +823,19 @@ class ClearingHouse {
             });
         });
     }
+    closeAllPositions(userPositionsAccount, discountToken, referrer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const userPosition of userPositionsAccount.positions) {
+                if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+                    continue;
+                }
+                ixs.push(yield this.getClosePositionIx(userPosition.marketIndex, discountToken, referrer));
+            }
+            const tx = new web3_js_1.Transaction().add(...ixs);
+            return this.txSender.send(tx, [], this.opts);
+        });
+    }
     liquidate(liquidateeUserAccountPublicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.txSender.send((0, utils_1.wrapInTx)(yield this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);

package/lib/constants/accounts.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from '@solana/web3.js';
+export declare const CLEARING_HOUSE_STATE_ACCOUNTS: {
+    dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN: {
+        state: PublicKey;
+        markets: PublicKey;
+        orderState: PublicKey;
+        tradeHistory: PublicKey;
+        depositHistory: PublicKey;
+        fundingPaymentHistory: PublicKey;
+        fundingRateHistory: PublicKey;
+        extendedCurveHistory: PublicKey;
+        liquidationHistory: PublicKey;
+        orderHistory: PublicKey;
+    };
+};

package/lib/constants/accounts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLEARING_HOUSE_STATE_ACCOUNTS = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.CLEARING_HOUSE_STATE_ACCOUNTS = {
+    dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN: {
+        state: new web3_js_1.PublicKey('FExhvPycCCwYnZGeDsVtLhpEQ3yEkVY2k1HuPyfLj91L'),
+        markets: new web3_js_1.PublicKey('773hq3SbGPKVj93TXi5qV5CREuhxobywfALjS3XVHhLH'),
+        orderState: new web3_js_1.PublicKey('4cC34bWwTPGncBaX2S6v5mH3Lj4Nb3byPMrxQSDcY985'),
+        tradeHistory: new web3_js_1.PublicKey('FCuCXEoQppoaCYdttA7rK3HNQfYkTNEGpwuBESzYcENp'),
+        depositHistory: new web3_js_1.PublicKey('C7rF2Qy2rnDGQLRijBRRArJyaeuQcFi81BXDrUCQ45ya'),
+        fundingPaymentHistory: new web3_js_1.PublicKey('895iPhzwT2tBufLnRpYtBG3gif1HDDUfpH2AqbS5joo4'),
+        fundingRateHistory: new web3_js_1.PublicKey('BWiJLMbmrwfqHVpcPJa8715XamNyNYamDDKQVQMnduEC'),
+        extendedCurveHistory: new web3_js_1.PublicKey('7vBbqvMdtZLQdTVdzt5y63pZdAFE5W42kP3avngSJKCk'),
+        liquidationHistory: new web3_js_1.PublicKey('CSFaaf8yVoTx6NcXUKtNPYAewv76CH2jATqSVRBvUWKM'),
+        orderHistory: new web3_js_1.PublicKey('DZ7XfUqyHoRKnJLRApxmJ943xHJ7NDBUTqpbooviEtbU'),
+    },
+};

package/lib/constants/markets.js

@@ -177,6 +177,17 @@ exports.Markets = [
         launchTs: 1648607439000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'Near',
+        category: ['L1', 'Infra'],
+        symbol: 'NEAR-PERP',
+        baseAssetSymbol: 'NEAR',
+        marketIndex: new __1.BN(16),
+        devnetPublicKey: '3gnSbT7bhoTdGkFVZc1dW1PvjreWzpUNUD5ppXwv1N59',
+        mainnetPublicKey: 'ECSFWQ1bnnpqPVvoy9237t2wddZAaHisW88mYxuEHKWf',
+        launchTs: 1649105516000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
     // {
     // 	symbol: 'mSOL-PERP',
     // 	baseAssetSymbol: 'mSOL',

package/lib/factory/clearingHouse.d.ts

@@ -1,7 +1,6 @@
 import { ConfirmOptions, Connection, PublicKey } from '@solana/web3.js';
 import { IWallet } from '../types';
 import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
-import { TxSender } from '../tx/types';
 import { ClearingHouse } from '../clearingHouse';
 import { Admin } from '../admin';
 export declare type ClearingHouseConfigType = 'websocket' | 'polling' | 'custom';
@@ -11,15 +10,26 @@ declare type BaseClearingHouseConfig = {
     wallet: IWallet;
     programID: PublicKey;
     opts?: ConfirmOptions;
-    txSender?: TxSender;
+    txSenderConfig?: TxSenderConfig;
 };
 declare type WebSocketClearingHouseConfiguration = BaseClearingHouseConfig;
 declare type PollingClearingHouseConfiguration = BaseClearingHouseConfig & {
     accountLoader: BulkAccountLoader;
 };
 declare type ClearingHouseConfig = PollingClearingHouseConfiguration | WebSocketClearingHouseConfiguration;
-export declare function getWebSocketClearingHouseConfig(connection: Connection, wallet: IWallet, programID: PublicKey, opts?: ConfirmOptions, txSender?: TxSender): WebSocketClearingHouseConfiguration;
-export declare function getPollingClearingHouseConfig(connection: Connection, wallet: IWallet, programID: PublicKey, accountLoader: BulkAccountLoader, opts?: ConfirmOptions, txSender?: TxSender): PollingClearingHouseConfiguration;
+export declare type TxSenderType = 'default' | 'retry';
+declare type BaseTxSenderConfig = {
+    type: TxSenderType;
+};
+declare type DefaultTxSenderConfig = BaseTxSenderConfig;
+declare type RetryTxSenderConfig = BaseTxSenderConfig & {
+    timeout?: number;
+    retrySleep?: number;
+    additionalConnections?: Connection[];
+};
+declare type TxSenderConfig = DefaultTxSenderConfig | RetryTxSenderConfig;
+export declare function getWebSocketClearingHouseConfig(connection: Connection, wallet: IWallet, programID: PublicKey, opts?: ConfirmOptions, txSenderConfig?: TxSenderConfig): WebSocketClearingHouseConfiguration;
+export declare function getPollingClearingHouseConfig(connection: Connection, wallet: IWallet, programID: PublicKey, accountLoader: BulkAccountLoader, opts?: ConfirmOptions, txSenderConfig?: TxSenderConfig): PollingClearingHouseConfiguration;
 export declare function getClearingHouse(config: ClearingHouseConfig): ClearingHouse;
 export declare function getAdmin(config: ClearingHouseConfig): Admin;
 export {};