@drift-labs/sdk 0.2.0-master.36 → 0.2.0-master.38

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>;
@@ -36,12 +36,15 @@ export declare class Admin extends ClearingHouse {
     updatePerpMarketOracle(perpMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
     updatePerpMarketStepSizeAndTickSize(perpMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionSignature>;
     updatePerpMarketMinOrderSize(perpMarketIndex: number, orderSize: BN): Promise<TransactionSignature>;
+    updateSpotMarketStepSizeAndTickSize(spotMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionSignature>;
+    updateSpotMarketMinOrderSize(spotMarketIndex: number, orderSize: BN): Promise<TransactionSignature>;
     updatePerpMarketExpiry(perpMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
     updateSpotMarketOracle(spotMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
     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>;
+    updateSpotMarketBorrowRate(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: 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, {
@@ -401,6 +401,24 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateSpotMarketStepSizeAndTickSize(spotMarketIndex, stepSize, tickSize) {
+        return await this.program.rpc.updateSpotMarketStepSizeAndTickSize(stepSize, tickSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketMinOrderSize(spotMarketIndex, orderSize) {
+        return await this.program.rpc.updateSpotMarketMinOrderSize(orderSize, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
     async updatePerpMarketExpiry(perpMarketIndex, expiryTs) {
         return await this.program.rpc.updatePerpMarketExpiry(expiryTs, {
             accounts: {
@@ -445,7 +463,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,
@@ -454,6 +472,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
+        return await this.program.rpc.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
     async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
         return await this.program.rpc.updateSpotMarketAssetTier(assetTier, {
             accounts: {

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);
@@ -167,6 +168,7 @@ export declare class ClearingHouse {
     getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
     fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
     getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    addSpotFulfillmentAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig?: SerumV3FulfillmentConfigAccount): void;
     addSerumRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: SerumV3FulfillmentConfigAccount): void;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
@@ -176,22 +178,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: {
@@ -1224,9 +1271,7 @@ class ClearingHouse {
         }
         const orderId = order.orderId;
         const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
-        if (fulfillmentConfig) {
-            this.addSerumRemainingAccounts(marketIndex, remainingAccounts, fulfillmentConfig);
-        }
+        this.addSpotFulfillmentAccounts(marketIndex, remainingAccounts, fulfillmentConfig);
         return await this.program.instruction.fillSpotOrder(orderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -1239,6 +1284,23 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    addSpotFulfillmentAccounts(marketIndex, remainingAccounts, fulfillmentConfig) {
+        if (fulfillmentConfig) {
+            this.addSerumRemainingAccounts(marketIndex, remainingAccounts, fulfillmentConfig);
+        }
+        else {
+            remainingAccounts.push({
+                pubkey: this.getSpotMarketAccount(marketIndex).vault,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.getQuoteSpotMarketAccount().vault,
+                isWritable: false,
+                isSigner: false,
+            });
+        }
+    }
     addSerumRemainingAccounts(marketIndex, remainingAccounts, fulfillmentConfig) {
         remainingAccounts.push({
             pubkey: fulfillmentConfig.pubkey,
@@ -1354,7 +1416,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 +1470,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 +1508,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) {
@@ -1491,9 +1555,7 @@ class ClearingHouse {
                 isSigner: false,
             });
         }
-        if (fulfillmentConfig) {
-            this.addSerumRemainingAccounts(orderParams.marketIndex, remainingAccounts, fulfillmentConfig);
-        }
+        this.addSpotFulfillmentAccounts(orderParams.marketIndex, remainingAccounts, fulfillmentConfig);
         return await this.program.instruction.placeAndTakeSpotOrder(orderParams, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -1504,11 +1566,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 +1596,9 @@ class ClearingHouse {
                 isSigner: false,
             });
         }
+        this.addSpotFulfillmentAccounts(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 +1629,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 +1705,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 +1724,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 +1737,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 +1765,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 +1792,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) {