@drift-labs/sdk 0.2.0-master.35 → 0.2.0-master.37

package/lib/addresses/pda.js

@@ -38,7 +38,7 @@ async function getUserAccountPublicKeyAndNonce(programId, authority, subAccountI
     return web3_js_1.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('user')),
         authority.toBuffer(),
-        Uint8Array.from([subAccountId]),
+        new anchor.BN(subAccountId).toArrayLike(Buffer, 'le', 2),
     ], programId);
 }
 exports.getUserAccountPublicKeyAndNonce = getUserAccountPublicKeyAndNonce;
@@ -50,7 +50,7 @@ function getUserAccountPublicKeySync(programId, authority, subAccountId = 0) {
     return web3_js_1.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('user')),
         authority.toBuffer(),
-        Uint8Array.from([subAccountId]),
+        new anchor.BN(subAccountId).toArrayLike(Buffer, 'le', 2),
     ], programId)[0];
 }
 exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;

package/lib/admin.d.ts

@@ -5,9 +5,9 @@ import { BN } from '@project-serum/anchor';
 import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
     initialize(usdcMint: PublicKey, _adminControlsPrices: boolean): Promise<[TransactionSignature]>;
-    initializeSpotMarket(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN, activeStatus?: boolean): Promise<TransactionSignature>;
+    initializeSpotMarket(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number, liquidationFee?: number, activeStatus?: boolean): Promise<TransactionSignature>;
     initializeSerumFulfillmentConfig(marketIndex: number, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;
-    initializePerpMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN, activeStatus?: boolean, name?: string): Promise<TransactionSignature>;
+    initializePerpMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: number, activeStatus?: boolean, name?: string): Promise<TransactionSignature>;
     moveAmmPrice(perpMarketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
     updateK(perpMarketIndex: number, sqrtK: BN): Promise<TransactionSignature>;
     updatePerpMarketConcentrationScale(perpMarketIndex: number, concentrationScale: BN): Promise<TransactionSignature>;
@@ -41,7 +41,7 @@ export declare class Admin extends ClearingHouse {
     updateSpotMarketExpiry(spotMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
     updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
     updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
-    updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN): Promise<TransactionSignature>;
+    updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionSignature>;
     updateSpotMarketAssetTier(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionSignature>;
     updateSpotMarketStatus(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
     updatePerpMarketStatus(perpMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;

package/lib/admin.js

@@ -57,7 +57,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
         const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
         return [initializeTxSig];
     }
-    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO, activeStatus = true) {
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidationFee = 0, activeStatus = true) {
         const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
         const spotMarket = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
         const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
@@ -104,7 +104,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async initializePerpMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
+    async initializePerpMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = 0, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
         const nameBuffer = (0, userName_1.encodeName)(name);
         const initializeMarketTx = await this.program.transaction.initializePerpMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, activeStatus, nameBuffer, {
@@ -445,7 +445,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0)) {
+    async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0) {
         return await this.program.rpc.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,

package/lib/clearingHouse.d.ts

@@ -19,7 +19,7 @@ declare type RemainingAccountParams = {
     writablePerpMarketIndexes?: number[];
     writableSpotMarketIndexes?: number[];
     readablePerpMarketIndex?: number;
-    readableSpotMarketIndex?: number;
+    readableSpotMarketIndexes?: number[];
     useMarketLastSlotCache?: boolean;
 };
 /**
@@ -40,7 +40,8 @@ export declare class ClearingHouse {
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
     _isSubscribed: boolean;
     txSender: TxSender;
-    marketLastSlotCache: Map<number, number>;
+    perpMarketLastSlotCache: Map<number, number>;
+    spotMarketLastSlotCache: Map<number, number>;
     authority: PublicKey;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
@@ -176,22 +177,31 @@ export declare class ClearingHouse {
     getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeAndTakeSpotOrder(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
     getPlaceAndTakeSpotOrderIx(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
-    placeAndMakeSpotOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
-    getPlaceAndMakeSpotOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeAndMakeSpotOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getPlaceAndMakeSpotOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     /**
      * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
      * @param marketIndex
      * @returns
      */
     closePosition(marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
+    /**
+     * Modifies an open order by closing it and replacing it with a new order.
+     * @param orderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @returns
+     */
+    modifyPerpOrder(orderId: number, newBaseAmount?: BN, newLimitPrice?: BN, newOraclePriceOffset?: number): Promise<TransactionSignature>;
     settlePNLs(users: {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;
     }[], marketIndex: number): Promise<TransactionSignature>;
     settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
     settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
-    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN): Promise<TransactionSignature>;
-    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN): Promise<TransactionInstruction>;
+    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN): Promise<TransactionSignature>;
+    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN): Promise<TransactionInstruction>;
     liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
     getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
     liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;

package/lib/clearingHouse.js

@@ -57,7 +57,8 @@ class ClearingHouse {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         this.users = new Map();
         this._isSubscribed = false;
-        this.marketLastSlotCache = new Map();
+        this.perpMarketLastSlotCache = new Map();
+        this.spotMarketLastSlotCache = new Map();
         this.connection = config.connection;
         this.wallet = config.wallet;
         this.opts = config.opts || anchor_1.AnchorProvider.defaultOptions();
@@ -404,11 +405,11 @@ class ClearingHouse {
         var _a;
         const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } = this.getRemainingAccountMapsForUsers(params.userAccounts);
         if (params.useMarketLastSlotCache) {
-            const lastUserPositionsSlot = (_a = this.getUserAccountAndSlot()) === null || _a === void 0 ? void 0 : _a.slot;
-            for (const [marketIndex, slot] of this.marketLastSlotCache.entries()) {
+            const lastUserSlot = (_a = this.getUserAccountAndSlot()) === null || _a === void 0 ? void 0 : _a.slot;
+            for (const [marketIndex, slot,] of this.perpMarketLastSlotCache.entries()) {
                 // if cache has more recent slot than user positions account slot, add market to remaining accounts
                 // otherwise remove from slot
-                if (slot > lastUserPositionsSlot) {
+                if (slot > lastUserSlot) {
                     const marketAccount = this.getPerpMarketAccount(marketIndex);
                     perpMarketAccountMap.set(marketIndex, {
                         pubkey: marketAccount.pubkey,
@@ -422,7 +423,29 @@ class ClearingHouse {
                     });
                 }
                 else {
-                    this.marketLastSlotCache.delete(marketIndex);
+                    this.perpMarketLastSlotCache.delete(marketIndex);
+                }
+            }
+            for (const [marketIndex, slot,] of this.spotMarketLastSlotCache.entries()) {
+                // if cache has more recent slot than user positions account slot, add market to remaining accounts
+                // otherwise remove from slot
+                if (slot > lastUserSlot) {
+                    const marketAccount = this.getSpotMarketAccount(marketIndex);
+                    spotMarketAccountMap.set(marketIndex, {
+                        pubkey: marketAccount.pubkey,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                    if (!marketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                        oracleAccountMap.set(marketAccount.oracle.toString(), {
+                            pubkey: marketAccount.oracle,
+                            isSigner: false,
+                            isWritable: false,
+                        });
+                    }
+                }
+                else {
+                    this.spotMarketLastSlotCache.delete(marketIndex);
                 }
             }
         }
@@ -454,19 +477,21 @@ class ClearingHouse {
                 });
             }
         }
-        if (params.readableSpotMarketIndex !== undefined) {
-            const spotMarketAccount = this.getSpotMarketAccount(params.readableSpotMarketIndex);
-            spotMarketAccountMap.set(params.readableSpotMarketIndex, {
-                pubkey: spotMarketAccount.pubkey,
-                isSigner: false,
-                isWritable: false,
-            });
-            if (spotMarketAccount.marketIndex !== 0) {
-                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                    pubkey: spotMarketAccount.oracle,
+        if (params.readableSpotMarketIndexes !== undefined) {
+            for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
+                const spotMarketAccount = this.getSpotMarketAccount(readableSpotMarketIndex);
+                spotMarketAccountMap.set(readableSpotMarketIndex, {
+                    pubkey: spotMarketAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
+                if (spotMarketAccount.marketIndex !== 0) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
             }
         }
         if (params.writableSpotMarketIndexes !== undefined) {
@@ -512,6 +537,14 @@ class ClearingHouse {
                             isWritable: false,
                         });
                     }
+                    if (!spotPosition.openAsks.eq(numericConstants_1.ZERO) ||
+                        !spotPosition.openBids.eq(numericConstants_1.ZERO)) {
+                        spotMarketAccountMap.set(spotPosition.marketIndex, {
+                            pubkey: this.getQuoteSpotMarketAccount().pubkey,
+                            isSigner: false,
+                            isWritable: false,
+                        });
+                    }
                 }
             }
             for (const position of userAccount.perpPositions) {
@@ -569,7 +602,8 @@ class ClearingHouse {
         if (createWSOLTokenAccount) {
             tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, collateralAccountPublicKey, authority, authority, []));
         }
-        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
+        const { txSig, slot } = await this.txSender.send(tx, additionalSigners, this.opts);
+        this.spotMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
     async getDepositInstruction(amount, marketIndex, userTokenAccount, subAccountId, reduceOnly = false, userInitialized = true) {
@@ -679,7 +713,8 @@ class ClearingHouse {
         if (createWSOLTokenAccount) {
             tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
         }
-        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
+        const { txSig, slot } = await this.txSender.send(tx, additionalSigners, this.opts);
+        this.spotMarketLastSlotCache.set(marketIndex, slot);
         return [txSig, userAccountPublicKey];
     }
     async initializeUserAccountForDevnet(subAccountId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo) {
@@ -726,7 +761,8 @@ class ClearingHouse {
         if (createWSOLTokenAccount) {
             tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
         }
-        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
+        const { txSig, slot } = await this.txSender.send(tx, additionalSigners, this.opts);
+        this.spotMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
     async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false) {
@@ -735,6 +771,7 @@ class ClearingHouse {
             userAccounts: [this.getUserAccount()],
             useMarketLastSlotCache: true,
             writableSpotMarketIndexes: [marketIndex],
+            readableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         return await this.program.instruction.withdraw(marketIndex, amount, reduceOnly, {
@@ -753,7 +790,11 @@ class ClearingHouse {
         });
     }
     async transferDeposit(amount, marketIndex, fromSubAccountId, toSubAccountId) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, marketIndex, fromSubAccountId, toSubAccountId)), [], this.opts);
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, marketIndex, fromSubAccountId, toSubAccountId)), [], this.opts);
+        if (fromSubAccountId === this.activeSubAccountId ||
+            toSubAccountId === this.activeSubAccountId) {
+            this.spotMarketLastSlotCache.set(marketIndex, slot);
+        }
         return txSig;
     }
     async getTransferDepositIx(amount, marketIndex, fromSubAccountId, toSubAccountId) {
@@ -783,6 +824,7 @@ class ClearingHouse {
                 toUser,
                 userStats: this.getUserStatsAccountPublicKey(),
                 state: await this.getStatePublicKey(),
+                spotMarketVault: this.getQuoteSpotMarketAccount().vault,
             },
             remainingAccounts,
         });
@@ -871,7 +913,7 @@ class ClearingHouse {
     }
     async addPerpLpShares(amount, marketIndex) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getAddPerpLpSharesIx(amount, marketIndex)), [], this.opts);
-        this.marketLastSlotCache.set(marketIndex, slot);
+        this.perpMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
     async getAddPerpLpSharesIx(amount, marketIndex) {
@@ -926,12 +968,12 @@ class ClearingHouse {
         fillTx.feePayer = userAccount.authority;
         const [signedMarketOrderTx, signedFillTx] = await this.provider.wallet.signAllTransactions([marketOrderTx, fillTx]);
         const { txSig, slot } = await this.txSender.send(signedMarketOrderTx, [], this.opts, true);
-        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return { txSig, signedFillTx };
     }
     async placePerpOrder(orderParams) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlacePerpOrderIx(orderParams)), [], this.opts);
-        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
     getOrderParams(optionalOrderParams, marketType) {
@@ -1158,7 +1200,9 @@ class ClearingHouse {
         });
     }
     async placeSpotOrder(orderParams) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceSpotOrderIx(orderParams)), [], this.opts);
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceSpotOrderIx(orderParams)), [], this.opts);
+        this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
     async getPlaceSpotOrderIx(orderParams) {
@@ -1167,7 +1211,10 @@ class ClearingHouse {
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [this.getUserAccount()],
             useMarketLastSlotCache: true,
-            readableSpotMarketIndex: orderParams.marketIndex,
+            readableSpotMarketIndexes: [
+                orderParams.marketIndex,
+                numericConstants_1.QUOTE_SPOT_MARKET_INDEX,
+            ],
         });
         return await this.program.instruction.placeSpotOrder(orderParams, {
             accounts: {
@@ -1354,7 +1401,7 @@ class ClearingHouse {
     }
     async placeAndTakePerpOrder(orderParams, makerInfo, referrerInfo) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo)), [], this.opts);
-        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
     async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo) {
@@ -1408,7 +1455,7 @@ class ClearingHouse {
     }
     async placeAndMakePerpOrder(orderParams, takerInfo, referrerInfo) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo)), [], this.opts);
-        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
     async getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo) {
@@ -1446,7 +1493,9 @@ class ClearingHouse {
         });
     }
     async placeAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo)), [], this.opts);
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo)), [], this.opts);
+        this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
     async getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo) {
@@ -1504,11 +1553,13 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async placeAndMakeSpotOrder(orderParams, takerInfo, referrerInfo) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, referrerInfo)), [], this.opts);
+    async placeAndMakeSpotOrder(orderParams, takerInfo, fulfillmentConfig, referrerInfo) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo)), [], this.opts);
+        this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
+        this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
-    async getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, referrerInfo) {
+    async getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo) {
         orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
@@ -1532,8 +1583,11 @@ class ClearingHouse {
                 isSigner: false,
             });
         }
+        if (fulfillmentConfig) {
+            this.addSerumRemainingAccounts(orderParams.marketIndex, remainingAccounts, fulfillmentConfig);
+        }
         const takerOrderId = takerInfo.order.orderId;
-        return await this.program.instruction.placeAndMakeSpotOrder(orderParams, takerOrderId, {
+        return await this.program.instruction.placeAndMakeSpotOrder(orderParams, takerOrderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
@@ -1564,6 +1618,53 @@ class ClearingHouse {
             price: limitPrice,
         });
     }
+    /**
+     * Modifies an open order by closing it and replacing it with a new order.
+     * @param orderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @returns
+     */
+    async modifyPerpOrder(orderId, newBaseAmount, newLimitPrice, newOraclePriceOffset) {
+        if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
+            throw new Error(`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`);
+        }
+        const openOrder = this.getUser().getOrder(orderId);
+        if (!openOrder) {
+            throw new Error(`No open order with id ${orderId.toString()}`);
+        }
+        const cancelOrderIx = await this.getCancelOrderIx(orderId);
+        const newOrderParams = {
+            orderType: openOrder.orderType,
+            marketType: openOrder.marketType,
+            direction: openOrder.direction,
+            baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
+            price: newLimitPrice || openOrder.price,
+            marketIndex: openOrder.marketIndex,
+            reduceOnly: openOrder.reduceOnly,
+            postOnly: openOrder.postOnly,
+            immediateOrCancel: openOrder.immediateOrCancel,
+            triggerPrice: openOrder.triggerPrice,
+            triggerCondition: openOrder.triggerCondition,
+            oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
+            auctionDuration: openOrder.auctionDuration,
+            maxTs: openOrder.maxTs,
+            auctionStartPrice: openOrder.auctionStartPrice,
+            auctionEndPrice: openOrder.auctionEndPrice,
+        };
+        const placeOrderIx = await this.getPlacePerpOrderIx(newOrderParams);
+        const tx = new web3_js_1.Transaction();
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: 1000000,
+            additionalFee: 0,
+        }));
+        tx.add(cancelOrderIx);
+        tx.add(placeOrderIx);
+        const { txSig, slot } = await this.txSender.send(tx, [], this.opts);
+        this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+        return txSig;
+    }
     async settlePNLs(users, marketIndex) {
         const ixs = [];
         for (const { settleeUserAccountPublicKey, settleeUserAccount } of users) {
@@ -1593,16 +1694,17 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: settleeUserAccountPublicKey,
+                spotMarketVault: this.getQuoteSpotMarketAccount().vault,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
-        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)), [], this.opts);
-        this.marketLastSlotCache.set(marketIndex, slot);
+    async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice)), [], this.opts);
+        this.perpMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
-    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
@@ -1611,7 +1713,7 @@ class ClearingHouse {
             useMarketLastSlotCache: true,
             writablePerpMarketIndexes: [marketIndex],
         });
-        return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
+        return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, limitPrice !== null && limitPrice !== void 0 ? limitPrice : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
@@ -1624,7 +1726,9 @@ class ClearingHouse {
         });
     }
     async liquidateSpot(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer)), [], this.opts);
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer)), [], this.opts);
+        this.spotMarketLastSlotCache.set(assetMarketIndex, slot);
+        this.spotMarketLastSlotCache.set(liabilityMarketIndex, slot);
         return txSig;
     }
     async getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
@@ -1650,7 +1754,8 @@ class ClearingHouse {
     }
     async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer)), [], this.opts);
-        this.marketLastSlotCache.set(perpMarketIndex, slot);
+        this.perpMarketLastSlotCache.set(perpMarketIndex, slot);
+        this.spotMarketLastSlotCache.set(liabilityMarketIndex, slot);
         return txSig;
     }
     async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
@@ -1676,7 +1781,8 @@ class ClearingHouse {
     }
     async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer)), [], this.opts);
-        this.marketLastSlotCache.set(perpMarketIndex, slot);
+        this.perpMarketLastSlotCache.set(perpMarketIndex, slot);
+        this.spotMarketLastSlotCache.set(assetMarketIndex, slot);
         return txSig;
     }
     async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {

package/lib/clearingHouseUser.js

@@ -71,6 +71,7 @@ class ClearingHouseUser {
             marketIndex,
             quoteAssetAmount: numericConstants_1.ZERO,
             quoteEntryAmount: numericConstants_1.ZERO,
+            quoteBreakEvenAmount: numericConstants_1.ZERO,
             openOrders: 0,
             openBids: numericConstants_1.ZERO,
             openAsks: numericConstants_1.ZERO,
@@ -443,30 +444,9 @@ class ClearingHouseUser {
                 perpPosition.baseAssetAmount =
                     settledPosition.baseAssetAmount.add(dustBaa);
                 perpPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
-                // open orders
-                let openAsks;
-                if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
-                    openAsks = market.amm.maxBaseAssetReserve
-                        .sub(market.amm.baseAssetReserve)
-                        .mul(perpPosition.lpShares)
-                        .div(market.amm.sqrtK)
-                        .mul(new _1.BN(-1));
-                }
-                else {
-                    openAsks = numericConstants_1.ZERO;
-                }
-                let openBids;
-                if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
-                    openBids = market.amm.baseAssetReserve
-                        .sub(market.amm.minBaseAssetReserve)
-                        .mul(perpPosition.lpShares)
-                        .div(market.amm.sqrtK);
-                }
-                else {
-                    openBids = numericConstants_1.ZERO;
-                }
-                perpPosition.openAsks = perpPosition.openAsks.add(openAsks);
-                perpPosition.openBids = perpPosition.openBids.add(openBids);
+                const [totalOpenBids, totalOpenAsks] = this.getPerpBidAsks(market.marketIndex);
+                perpPosition.openAsks = totalOpenAsks;
+                perpPosition.openBids = totalOpenBids;
             }
             let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
             if ((0, types_1.isVariant)(market.status, 'settlement')) {
@@ -673,6 +653,7 @@ class ClearingHouseUser {
             remainderBaseAssetAmount: 0,
             quoteAssetAmount: new _1.BN(0),
             lastCumulativeFundingRate: numericConstants_1.ZERO,
+            quoteBreakEvenAmount: new _1.BN(0),
             quoteEntryAmount: new _1.BN(0),
             openOrders: 0,
             openBids: new _1.BN(0),
@@ -903,7 +884,7 @@ class ClearingHouseUser {
         const precisionIncrease = numericConstants_1.TEN.pow(new _1.BN(spotMarket.decimals - 6));
         const amountWithdrawable = freeCollateral
             .mul(numericConstants_1.MARGIN_PRECISION)
-            .div(spotMarket.initialAssetWeight)
+            .div(new _1.BN(spotMarket.initialAssetWeight))
             .mul(numericConstants_1.PRICE_PRECISION)
             .div(oracleData.price)
             .mul(precisionIncrease);
@@ -923,7 +904,7 @@ class ClearingHouseUser {
                 : freeCollateral;
             const maxLiabilityAllowed = freeCollatAfterWithdraw
                 .mul(numericConstants_1.MARGIN_PRECISION)
-                .div(spotMarket.initialLiabilityWeight)
+                .div(new _1.BN(spotMarket.initialLiabilityWeight))
                 .mul(numericConstants_1.PRICE_PRECISION)
                 .div(oracleData.price)
                 .mul(precisionIncrease);

package/lib/config.js

@@ -7,7 +7,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: 'BJG3o4CURrokB7huNyiHptYepAtHXj4YfefJiPgzUULV',
+        CLEARING_HOUSE_PROGRAM_ID: 'jAEeKs9twxAJmXZHqS2p459xW7FMDjoyvuqthRo9qGS',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         SERUM_V3: 'DESVgJVGajEgKGXhb6XmqDHGz3VjdgP7rEVESBgxmroY',
         V2_ALPHA_TICKET_MINT_ADDRESS: 'DeEiGWfCMP9psnLGkxGrBBMEAW5Jv8bBGMN8DCtFRCyB',

package/lib/factory/bigNum.d.ts

@@ -5,6 +5,7 @@ export declare class BigNum {
     precision: BN;
     static delim: string;
     static spacer: string;
+    static setLocale(locale: string): void;
     constructor(val: BN | number | string, precisionVal?: BN | number | string);
     private bigNumFromParam;
     add(bn: BigNum): BigNum;

package/lib/factory/bigNum.js

@@ -10,6 +10,10 @@ class BigNum {
         this.val = new anchor_1.BN(val);
         this.precision = new anchor_1.BN(precisionVal);
     }
+    static setLocale(locale) {
+        BigNum.delim = (1.1).toLocaleString(locale).slice(1, 2) || '.';
+        BigNum.spacer = (1000).toLocaleString(locale).slice(1, 2) || ',';
+    }
     bigNumFromParam(bn) {
         return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
     }
@@ -381,7 +385,21 @@ class BigNum {
      * @returns
      */
     toNum() {
-        return parseFloat(this.print());
+        let printedValue = this.print();
+        // Must convert any non-US delimiters and spacers to US format before using parseFloat
+        if (BigNum.delim !== '.' || BigNum.spacer !== ',') {
+            printedValue = printedValue
+                .split('')
+                .map((char) => {
+                if (char === BigNum.delim)
+                    return '.';
+                if (char === BigNum.spacer)
+                    return ',';
+                return char;
+            })
+                .join('');
+        }
+        return parseFloat(printedValue);
     }
     static fromJSON(json) {
         return BigNum.from(new anchor_1.BN(json.val), new anchor_1.BN(json.precision));
@@ -407,10 +425,14 @@ class BigNum {
         // Handle empty number edge cases
         if (!val)
             return BigNum.from(numericConstants_1.ZERO, precisionShift);
-        if (!val.replace(BigNum.delim, ''))
+        if (!val.replace(BigNum.delim, '')) {
             return BigNum.from(numericConstants_1.ZERO, precisionShift);
-        const [leftSide, rightSide] = val.split(BigNum.delim);
-        const rawBn = new anchor_1.BN(`${leftSide !== null && leftSide !== void 0 ? leftSide : ''}${rightSide !== null && rightSide !== void 0 ? rightSide : ''}`);
+        }
+        const sides = val.split(BigNum.delim);
+        const rightSide = sides[1];
+        const leftSide = sides[0].replace(/\D/g, '');
+        const bnInput = `${leftSide !== null && leftSide !== void 0 ? leftSide : ''}${rightSide !== null && rightSide !== void 0 ? rightSide : ''}`;
+        const rawBn = new anchor_1.BN(bnInput);
         const rightSideLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
         const totalShift = precisionShift
             ? precisionShift.sub(new anchor_1.BN(rightSideLength))