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

package/lib/math/repeg.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateReserveRebalanceCost = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const position_1 = require("./position");
+const amm_1 = require("./amm");
+const __1 = require("..");
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: numericConstants_1.ZERO,
+        openOrders: numericConstants_1.ZERO,
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    const marketNewK = Object.assign({}, market);
+    marketNewK.amm = Object.assign({}, market.amm);
+    marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
+        .mul(numerator)
+        .div(denomenator);
+    marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
+        .mul(numerator)
+        .div(denomenator);
+    marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const cost = (0, __1.calculatePositionPNL)(marketNewK, netUserPosition);
+    return cost;
+}
+exports.calculateAdjustKCost = calculateAdjustKCost;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateRepegCost(market, marketIndex, newPeg) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: numericConstants_1.ZERO,
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
+    const marketNewPeg = Object.assign({}, market);
+    marketNewPeg.amm = Object.assign({}, market.amm);
+    // const marketNewPeg = JSON.parse(JSON.stringify(market));
+    marketNewPeg.amm.pegMultiplier = newPeg;
+    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
+    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
+    return cost;
+}
+exports.calculateRepegCost = calculateRepegCost;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateReserveRebalanceCost(market, marketIndex) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: numericConstants_1.ZERO,
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
+    const marketNewPeg = Object.assign({}, market);
+    marketNewPeg.amm = Object.assign({}, market.amm);
+    // const marketNewPeg = JSON.parse(JSON.stringify(market));
+    const newPeg = (0, amm_1.calculateTerminalPrice)(market)
+        .mul(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.MARK_PRICE_PRECISION);
+    // const newPeg = prevMarketPrice.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION);
+    const newBaseReserve = market.amm.baseAssetReserve.add(market.baseAssetAmount);
+    const newQuoteReserve = market.amm.sqrtK
+        .mul(market.amm.sqrtK)
+        .div(newBaseReserve);
+    console.log('current reserves on close, quote:', (0, __1.convertToNumber)(newQuoteReserve, numericConstants_1.AMM_RESERVE_PRECISION), 'base:', (0, __1.convertToNumber)(newBaseReserve, numericConstants_1.AMM_RESERVE_PRECISION));
+    let newSqrtK;
+    if (newPeg.lt(market.amm.pegMultiplier)) {
+        newSqrtK = newBaseReserve;
+    }
+    else {
+        newSqrtK = newQuoteReserve;
+    }
+    marketNewPeg.amm.baseAssetReserve = newSqrtK.sub(market.baseAssetAmount); // newSqrtK.sub(market.baseAssetAmount);
+    marketNewPeg.amm.quoteAssetReserve = newSqrtK
+        .mul(newSqrtK)
+        .div(marketNewPeg.amm.baseAssetReserve);
+    marketNewPeg.amm.sqrtK = newSqrtK;
+    marketNewPeg.amm.pegMultiplier = newPeg;
+    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
+    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
+    return cost;
+}
+exports.calculateReserveRebalanceCost = calculateReserveRebalanceCost;
+function calculateBudgetedK(market, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const numer1 = y.mul(d).mul(Q).div(numericConstants_1.AMM_RESERVE_PRECISION).div(numericConstants_1.PEG_PRECISION);
+    const numer2 = C.mul(x.add(d)).div(numericConstants_1.QUOTE_PRECISION);
+    const denom1 = C.mul(x)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    const denom2 = y
+        .mul(d)
+        .mul(d)
+        .mul(Q)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION);
+    const numerator = d
+        .mul(numer1.add(numer2))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    const denominator = denom1
+        .add(denom2)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    console.log(numerator, denominator);
+    // const p = (numerator).div(denominator);
+    // const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+    // console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(market, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
+    // .mul(PEG_PRECISION)
+    // .div(QUOTE_PRECISION);
+    console.log(Q.toNumber(), 'change by', deltaPegMultiplier.toNumber() / numericConstants_1.MARK_PRICE_PRECISION.toNumber());
+    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/oracles/pythClient.js

@@ -33,7 +33,7 @@ class PythClient {
         return __awaiter(this, void 0, void 0, function* () {
             const priceData = (0, client_1.parsePriceData)(buffer);
             return {
-                price: convertPythPrice(priceData.price, priceData.exponent),
+                price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
                 slot: new anchor_1.BN(priceData.lastSlot.toString()),
                 confidence: convertPythPrice(priceData.confidence, priceData.exponent),
                 twap: convertPythPrice(priceData.twap.value, priceData.exponent),

package/lib/orderParams.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
 import { BN } from '@project-serum/anchor';
-export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number, postOnly?: boolean, oraclePriceOffset?: BN): OrderParams;
+export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number, postOnly?: boolean, oraclePriceOffset?: BN, immediateOrCancel?: boolean): OrderParams;
 export declare function getTriggerMarketOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
 export declare function getTriggerLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
 export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;

package/lib/orderParams.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
 const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO) {
+function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO, immediateOrCancel = false) {
     return {
         orderType: types_1.OrderType.LIMIT,
         userOrderId,
@@ -14,7 +14,7 @@ function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, red
         price,
         reduceOnly,
         postOnly,
-        immediateOrCancel: false,
+        immediateOrCancel,
         positionLimit: numericConstants_1.ZERO,
         padding0: true,
         padding1: numericConstants_1.ZERO,

package/lib/tx/retryTxSender.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import { TxSender } from './types';
-import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature } from '@solana/web3.js';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
 import { Provider } from '@project-serum/anchor';
 declare type ResolveReference = {
     resolve?: () => void;
@@ -8,12 +9,14 @@ export declare class RetryTxSender implements TxSender {
     provider: Provider;
     timeout: number;
     retrySleep: number;
-    constructor(provider: Provider, timeout?: number, retrySleep?: number);
+    additionalConnections: Connection[];
+    constructor(provider: Provider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
     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>;
+    sendToAdditionalConnections(rawTx: Buffer, opts: ConfirmOptions): void;
 }
 export {};

package/lib/tx/retryTxSender.js

@@ -18,10 +18,11 @@ const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
 class RetryTxSender {
-    constructor(provider, timeout, retrySleep) {
+    constructor(provider, timeout, retrySleep, additionalConnections = new Array()) {
         this.provider = provider;
         this.timeout = timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT;
         this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
+        this.additionalConnections = additionalConnections;
     }
     send(tx, additionalSigners, opts) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -35,6 +36,7 @@ class RetryTxSender {
             const rawTransaction = tx.serialize();
             const startTime = this.getTimestamp();
             const txid = yield this.provider.connection.sendRawTransaction(rawTransaction, opts);
+            this.sendToAdditionalConnections(rawTransaction, opts);
             let done = false;
             const resolveReference = {
                 resolve: undefined,
@@ -55,6 +57,7 @@ class RetryTxSender {
                             console.error(e);
                             stopWaiting();
                         });
+                        this.sendToAdditionalConnections(rawTransaction, opts);
                     }
                 }
             }))();
@@ -149,5 +152,15 @@ class RetryTxSender {
             return result;
         });
     }
+    sendToAdditionalConnections(rawTx, opts) {
+        this.additionalConnections.map((connection) => {
+            connection.sendRawTransaction(rawTx, opts).catch((e) => {
+                console.error(
+                // @ts-ignore
+                `error sending tx to additional connection ${connection._rpcEndpoint}`);
+                console.error(e);
+            });
+        });
+    }
 }
 exports.RetryTxSender = RetryTxSender;

package/package.json

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

package/src/accounts/bulkAccountLoader.ts

@@ -43,10 +43,15 @@ export class BulkAccountLoader {
 		const existingSize = this.accountsToLoad.size;
 
 		const callbackId = uuidv4();
+		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<string, (buffer: Buffer) => void>();
 			callbacks.set(callbackId, callback);
 			const newAccountToLoad = {
@@ -67,6 +72,9 @@ export class BulkAccountLoader {
 	}
 
 	public removeAccount(publicKey: PublicKey, callbackId: string): void {
+		this.log(
+			`Removing account ${publicKey.toString()} callback id ${callbackId}`
+		);
 		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
 		if (existingAccountToLoad) {
 			existingAccountToLoad.callbacks.delete(callbackId);
@@ -99,17 +107,21 @@ export class BulkAccountLoader {
 
 	public async load(): Promise<void> {
 		if (this.loadPromise) {
+			this.log(`Load promise exists. Returning early`);
 			return this.loadPromise;
 		}
 		this.loadPromise = new Promise((resolver) => {
 			this.loadPromiseResolver = resolver;
 		});
 
+		this.log(`Loading`);
+
 		try {
 			const chunks = this.chunks(
 				Array.from(this.accountsToLoad.values()),
 				GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
 			);
+			this.log(`${chunks.length} chunks`);
 
 			await Promise.all(
 				chunks.map((chunk) => {
@@ -122,17 +134,17 @@ export 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.log(
+					"Haven't seen updated account in five minutes. Bulk account loader creating new Connection Object"
+				);
 				this.connection = new Connection(
 					// @ts-ignore
 					this.connection._rpcEndpoint,
@@ -144,6 +156,7 @@ export class BulkAccountLoader {
 
 	async loadChunk(accountsToLoad: AccountToLoad[]): Promise<void> {
 		if (accountsToLoad.length === 0) {
+			this.log(`no accounts in chunk`);
 			return;
 		}
 
@@ -161,8 +174,8 @@ export class BulkAccountLoader {
 		);
 
 		const oneMinuteSinceLastUpdate = Date.now() - this.lastUpdate > oneMinute;
-		if (this.loggingEnabled && oneMinuteSinceLastUpdate) {
-			console.log('rpcResponse', JSON.stringify(rpcResponse));
+		if (oneMinuteSinceLastUpdate) {
+			this.log('rpcResponse ' + JSON.stringify(rpcResponse));
 		}
 
 		const newSlot = rpcResponse.result.context.slot;
@@ -179,11 +192,12 @@ export class BulkAccountLoader {
 				newBuffer = Buffer.from(raw, dataType);
 			}
 
-			if (this.loggingEnabled && oneMinuteSinceLastUpdate) {
-				console.log('oldRPCResponse', oldRPCResponse);
+			if (oneMinuteSinceLastUpdate) {
+				this.log('oldRPCResponse' + oldRPCResponse);
 			}
 
 			if (!oldRPCResponse) {
+				this.log('No old rpc response, updating account data');
 				this.accountData.set(key, {
 					slot: newSlot,
 					buffer: newBuffer,
@@ -194,25 +208,34 @@ export class BulkAccountLoader {
 			}
 
 			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 {
+				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: AccountToLoad, buffer: Buffer): void {
+		this.log('handling account callbacks');
 		for (const [_, callback] of accountToLoad.callbacks) {
 			callback(buffer);
 		}
+		this.log('finished account callbacks');
 	}
 
 	public getAccountData(publicKey: PublicKey): Buffer | undefined {
@@ -225,9 +248,7 @@ export class BulkAccountLoader {
 			return;
 		}
 
-		if (this.loggingEnabled) {
-			console.log(`startPolling`);
-		}
+		this.log('startPolling');
 
 		this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
 	}
@@ -237,9 +258,13 @@ export class BulkAccountLoader {
 			clearInterval(this.intervalId);
 			this.intervalId = undefined;
 
-			if (this.loggingEnabled) {
-				console.log(`stopPolling`);
-			}
+			this.log('stopPolling');
+		}
+	}
+
+	public log(msg: string): void {
+		if (this.loggingEnabled) {
+			console.log(msg);
 		}
 	}
 }

package/src/clearingHouse.ts

@@ -21,6 +21,7 @@ import {
 	OrderParams,
 	Order,
 	ExtendedCurveHistoryAccount,
+	UserPositionsAccount,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -922,6 +923,51 @@ export class ClearingHouse {
 		});
 	}
 
+	public async cancelAllOrders(
+		oracles?: PublicKey[]
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(await this.getCancelAllOrdersIx(oracles)),
+			[],
+			this.opts
+		);
+	}
+
+	public async getCancelAllOrdersIx(
+		oracles: PublicKey[]
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccount = await 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 await this.program.instruction.cancelAllOrders({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				markets: state.markets,
+				userOrders: await this.getUserOrdersAccountPublicKey(),
+				userPositions: userAccount.positions,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+				fundingRateHistory: state.fundingRateHistory,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+			},
+			remainingAccounts,
+		});
+	}
+
 	public async fillOrder(
 		userAccountPublicKey: PublicKey,
 		userOrdersAccountPublicKey: PublicKey,
@@ -1160,6 +1206,31 @@ export class ClearingHouse {
 		);
 	}
 
+	public async closeAllPositions(
+		userPositionsAccount: UserPositionsAccount,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionSignature> {
+		const ixs: TransactionInstruction[] = [];
+		for (const userPosition of userPositionsAccount.positions) {
+			if (userPosition.baseAssetAmount.eq(ZERO)) {
+				continue;
+			}
+
+			ixs.push(
+				await this.getClosePositionIx(
+					userPosition.marketIndex,
+					discountToken,
+					referrer
+				)
+			);
+		}
+
+		const tx = new Transaction().add(...ixs);
+
+		return this.txSender.send(tx, [], this.opts);
+	}
+
 	public async liquidate(
 		liquidateeUserAccountPublicKey: PublicKey
 	): Promise<TransactionSignature> {

package/src/constants/markets.ts

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

package/src/idl/clearing_house.json

@@ -677,6 +677,57 @@
         }
       ]
     },
+    {
+      "name": "cancelAllOrders",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "orderState",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "markets",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "userPositions",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userOrders",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "fundingPaymentHistory",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "orderHistory",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
     {
       "name": "expireOrders",
       "accounts": [
@@ -1444,6 +1495,11 @@
           "isMut": true,
           "isSigner": false
         },
+        {
+          "name": "userOrders",
+          "isMut": true,
+          "isSigner": false
+        },
         {
           "name": "authority",
           "isMut": false,
@@ -3236,8 +3292,8 @@
             "type": "u128"
           },
           {
-            "name": "padding1",
-            "type": "u64"
+            "name": "netRevenueSinceLastFunding",
+            "type": "i64"
           },
           {
             "name": "padding2",
@@ -4244,6 +4300,11 @@
       "code": 6060,
       "name": "CantExpireOrders",
       "msg": "CantExpireOrders"
+    },
+    {
+      "code": 6061,
+      "name": "InvalidRepegPriceImpact",
+      "msg": "AMM repeg mark price impact vs oracle too large"
     }
   ]
 }

package/src/index.ts

@@ -29,6 +29,7 @@ export * from './math/position';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
+export * from './math/repeg';
 export * from './orders';
 export * from './orderParams';
 export * from './wallet';