@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.26

package/lib/clearingHouse.js

@@ -37,15 +37,16 @@ const pda_1 = require("./addresses/pda");
 const utils_1 = require("./tx/utils");
 const numericConstants_1 = require("./constants/numericConstants");
 const position_1 = require("./math/position");
-const bankBalance_1 = require("./math/bankBalance");
+const spotBalance_1 = require("./math/spotBalance");
 const userName_1 = require("./userName");
 const pollingClearingHouseAccountSubscriber_1 = require("./accounts/pollingClearingHouseAccountSubscriber");
 const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketClearingHouseAccountSubscriber");
 const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
 const config_1 = require("./config");
-const banks_1 = require("./constants/banks");
+const spotMarkets_1 = require("./constants/spotMarkets");
 const clearingHouseUserStats_1 = require("./clearingHouseUserStats");
+const spotPosition_1 = require("./math/spotPosition");
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -80,20 +81,24 @@ class ClearingHouse {
                 accountSubscription: this.userAccountSubscriptionConfig,
             });
         }
-        let marketIndexes = config.marketIndexes;
-        let bankIndexes = config.bankIndexes;
+        let perpMarketIndexes = config.perpMarketIndexes;
+        let spotMarketIndexes = config.spotMarketIndexes;
         let oracleInfos = config.oracleInfos;
         if (config.env) {
-            const { marketIndexes: envMarketIndexes, bankIndexes: envBankIndexes, oracleInfos: envOralceInfos, } = (0, config_1.getMarketsBanksAndOraclesForSubscription)(config.env);
-            marketIndexes = marketIndexes ? marketIndexes : envMarketIndexes;
-            bankIndexes = bankIndexes ? bankIndexes : envBankIndexes;
+            const { perpMarketIndexes: envPerpMarketIndexes, spotMarketIndexes: envSpotMarketIndexes, oracleInfos: envOralceInfos, } = (0, config_1.getMarketsAndOraclesForSubscription)(config.env);
+            perpMarketIndexes = perpMarketIndexes
+                ? perpMarketIndexes
+                : envPerpMarketIndexes;
+            spotMarketIndexes = spotMarketIndexes
+                ? spotMarketIndexes
+                : envSpotMarketIndexes;
             oracleInfos = oracleInfos ? oracleInfos : envOralceInfos;
         }
         if (((_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.type) === 'polling') {
-            this.accountSubscriber = new pollingClearingHouseAccountSubscriber_1.PollingClearingHouseAccountSubscriber(this.program, config.accountSubscription.accountLoader, marketIndexes !== null && marketIndexes !== void 0 ? marketIndexes : [], bankIndexes !== null && bankIndexes !== void 0 ? bankIndexes : [], oracleInfos !== null && oracleInfos !== void 0 ? oracleInfos : []);
+            this.accountSubscriber = new pollingClearingHouseAccountSubscriber_1.PollingClearingHouseAccountSubscriber(this.program, config.accountSubscription.accountLoader, perpMarketIndexes !== null && perpMarketIndexes !== void 0 ? perpMarketIndexes : [], spotMarketIndexes !== null && spotMarketIndexes !== void 0 ? spotMarketIndexes : [], oracleInfos !== null && oracleInfos !== void 0 ? oracleInfos : []);
         }
         else {
-            this.accountSubscriber = new webSocketClearingHouseAccountSubscriber_1.WebSocketClearingHouseAccountSubscriber(this.program, (_e = config.marketIndexes) !== null && _e !== void 0 ? _e : [], (_f = config.bankIndexes) !== null && _f !== void 0 ? _f : [], (_g = config.oracleInfos) !== null && _g !== void 0 ? _g : []);
+            this.accountSubscriber = new webSocketClearingHouseAccountSubscriber_1.WebSocketClearingHouseAccountSubscriber(this.program, (_e = config.perpMarketIndexes) !== null && _e !== void 0 ? _e : [], (_f = config.spotMarketIndexes) !== null && _f !== void 0 ? _f : [], (_g = config.oracleInfos) !== null && _g !== void 0 ? _g : []);
         }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
         this.txSender = new retryTxSender_1.RetryTxSender(this.provider, (_h = config.txSenderConfig) === null || _h === void 0 ? void 0 : _h.timeout, (_j = config.txSenderConfig) === null || _j === void 0 ? void 0 : _j.retrySleep, (_k = config.txSenderConfig) === null || _k === void 0 ? void 0 : _k.additionalConnections);
@@ -169,27 +174,30 @@ class ClearingHouse {
     getStateAccount() {
         return this.accountSubscriber.getStateAccountAndSlot().data;
     }
-    getMarketAccount(marketIndex) {
+    getPerpMarketAccount(marketIndex) {
         var _a;
         marketIndex = marketIndex instanceof anchor_1.BN ? marketIndex : new anchor_1.BN(marketIndex);
         return (_a = this.accountSubscriber.getMarketAccountAndSlot(marketIndex)) === null || _a === void 0 ? void 0 : _a.data;
     }
-    getMarketAccounts() {
+    getPerpMarketAccounts() {
         return this.accountSubscriber
             .getMarketAccountsAndSlots()
             .map((value) => value.data);
     }
-    getBankAccount(bankIndex) {
-        bankIndex = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
-        return this.accountSubscriber.getBankAccountAndSlot(bankIndex).data;
+    getSpotMarketAccount(marketIndex) {
+        marketIndex = marketIndex instanceof anchor_1.BN ? marketIndex : new anchor_1.BN(marketIndex);
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
     }
-    getQuoteAssetBankAccount() {
-        return this.accountSubscriber.getBankAccountAndSlot(numericConstants_1.QUOTE_ASSET_BANK_INDEX)
-            .data;
+    getQuoteSpotMarketAccount() {
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).data;
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         return this.accountSubscriber.getOraclePriceDataAndSlot(oraclePublicKey);
     }
+    async getSerumV3FulfillmentConfig(serumMarket) {
+        const address = await (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
+        return (await this.program.account.serumV3FulfillmentConfig.fetch(address));
+    }
     /**
      * Update the wallet to use for clearing house transactions and linked user account
      * @param newWallet
@@ -279,6 +287,15 @@ class ClearingHouse {
             },
         });
     }
+    async updateUserName(name, userId = 0) {
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        return await this.program.rpc.updateUserName(userId, nameBuffer, {
+            accounts: {
+                user: await this.getUserAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+        });
+    }
     getUser(userId) {
         userId = userId !== null && userId !== void 0 ? userId : this.activeUserId;
         if (!this.users.has(userId)) {
@@ -308,14 +325,14 @@ class ClearingHouse {
     getUserAccountAndSlot(userId) {
         return this.getUser(userId).getUserAccountAndSlot();
     }
-    getUserBankBalance(bankIndex) {
-        const bankIndexBN = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
-        return this.getUserAccount().bankBalances.find((bankBalance) => bankBalance.bankIndex.eq(bankIndexBN));
+    getSpotPosition(marketIndex) {
+        const marketIndexBN = marketIndex instanceof anchor_1.BN ? marketIndex : new anchor_1.BN(marketIndex);
+        return this.getUserAccount().spotPositions.find((spotPosition) => spotPosition.marketIndex.eq(marketIndexBN));
     }
     getQuoteAssetTokenAmount() {
-        const bank = this.getBankAccount(numericConstants_1.QUOTE_ASSET_BANK_INDEX);
-        const userBankBalance = this.getUserBankBalance(numericConstants_1.QUOTE_ASSET_BANK_INDEX);
-        return (0, bankBalance_1.getTokenAmount)(userBankBalance.balance, bank, userBankBalance.balanceType);
+        const spotMarket = this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        const spotPosition = this.getSpotPosition(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        return (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarket, spotPosition.balanceType);
     }
     getRemainingAccounts(params) {
         const userAccountAndSlot = this.getUserAccountAndSlot();
@@ -324,14 +341,14 @@ class ClearingHouse {
         }
         const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
         const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
+        const spotMarketAccountMap = new Map();
+        const perpMarketAccountMap = new Map();
         for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
             // if cache has more recent slot than user positions account slot, add market to remaining accounts
             // otherwise remove from slot
             if (slot > lastUserPositionsSlot) {
-                const marketAccount = this.getMarketAccount(marketIndexNum);
-                marketAccountMap.set(marketIndexNum, {
+                const marketAccount = this.getPerpMarketAccount(marketIndexNum);
+                perpMarketAccountMap.set(marketIndexNum, {
                     pubkey: marketAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
@@ -346,11 +363,11 @@ class ClearingHouse {
                 this.marketLastSlotCache.delete(marketIndexNum);
             }
         }
-        for (const position of userAccount.positions) {
+        for (const position of userAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
                 const marketIndexNum = position.marketIndex.toNumber();
-                const marketAccount = this.getMarketAccount(marketIndexNum);
-                marketAccountMap.set(marketIndexNum, {
+                const marketAccount = this.getPerpMarketAccount(marketIndexNum);
+                perpMarketAccountMap.set(marketIndexNum, {
                     pubkey: marketAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
@@ -362,9 +379,9 @@ class ClearingHouse {
                 });
             }
         }
-        if (params.readableMarketIndex) {
-            const marketAccount = this.getMarketAccount(params.readableMarketIndex.toNumber());
-            marketAccountMap.set(params.readableMarketIndex.toNumber(), {
+        if (params.readablePerpMarketIndex) {
+            const marketAccount = this.getPerpMarketAccount(params.readablePerpMarketIndex.toNumber());
+            perpMarketAccountMap.set(params.readablePerpMarketIndex.toNumber(), {
                 pubkey: marketAccount.pubkey,
                 isSigner: false,
                 isWritable: true,
@@ -375,9 +392,9 @@ class ClearingHouse {
                 isWritable: false,
             });
         }
-        if (params.writableMarketIndex) {
-            const marketAccount = this.getMarketAccount(params.writableMarketIndex.toNumber());
-            marketAccountMap.set(params.writableMarketIndex.toNumber(), {
+        if (params.writablePerpMarketIndex) {
+            const marketAccount = this.getPerpMarketAccount(params.writablePerpMarketIndex.toNumber());
+            perpMarketAccountMap.set(params.writablePerpMarketIndex.toNumber(), {
                 pubkey: marketAccount.pubkey,
                 isSigner: false,
                 isWritable: true,
@@ -388,33 +405,48 @@ class ClearingHouse {
                 isWritable: false,
             });
         }
-        for (const userBankBalance of userAccount.bankBalances) {
-            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
+                if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
                         isSigner: false,
                         isWritable: false,
                     });
                 }
             }
         }
-        if (params.writableBankIndex) {
-            const bankAccount = this.getBankAccount(params.writableBankIndex);
-            bankAccountMap.set(params.writableBankIndex.toNumber(), {
-                pubkey: bankAccount.pubkey,
+        if (params.readableSpotMarketIndex) {
+            const spotMarketAccount = this.getSpotMarketAccount(params.readableSpotMarketIndex);
+            spotMarketAccountMap.set(params.readableSpotMarketIndex.toNumber(), {
+                pubkey: spotMarketAccount.pubkey,
+                isSigner: false,
+                isWritable: false,
+            });
+            if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                    pubkey: spotMarketAccount.oracle,
+                    isSigner: false,
+                    isWritable: false,
+                });
+            }
+        }
+        if (params.writableSpotMarketIndex) {
+            const spotMarketAccount = this.getSpotMarketAccount(params.writableSpotMarketIndex);
+            spotMarketAccountMap.set(params.writableSpotMarketIndex.toNumber(), {
+                pubkey: spotMarketAccount.pubkey,
                 isSigner: false,
                 isWritable: true,
             });
-            if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                oracleAccountMap.set(bankAccount.oracle.toString(), {
-                    pubkey: bankAccount.oracle,
+            if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                    pubkey: spotMarketAccount.oracle,
                     isSigner: false,
                     isWritable: false,
                 });
@@ -422,8 +454,8 @@ class ClearingHouse {
         }
         return [
             ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...perpMarketAccountMap.values(),
         ];
     }
     getOrder(orderId) {
@@ -435,13 +467,13 @@ class ClearingHouse {
         var _a;
         return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.userOrderId === userOrderId);
     }
-    async deposit(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly = false) {
+    async deposit(amount, marketIndex, collateralAccountPublicKey, userId, reduceOnly = false) {
         const tx = new web3_js_1.Transaction();
         const additionalSigners = [];
-        const bank = this.getBankAccount(bankIndex);
-        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const authority = this.wallet.publicKey;
-        const createWSOLTokenAccount = isSolBank && collateralAccountPublicKey.equals(authority);
+        const createWSOLTokenAccount = isSolMarket && collateralAccountPublicKey.equals(authority);
         if (createWSOLTokenAccount) {
             const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
             collateralAccountPublicKey = pubkey;
@@ -450,7 +482,7 @@ class ClearingHouse {
             });
             signers.forEach((signer) => additionalSigners.push(signer));
         }
-        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly, true);
+        const depositCollateralIx = await this.getDepositInstruction(amount, marketIndex, collateralAccountPublicKey, userId, reduceOnly, true);
         tx.add(depositCollateralIx);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
@@ -459,37 +491,37 @@ class ClearingHouse {
         const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
-    async getDepositInstruction(amount, bankIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
+    async getDepositInstruction(amount, marketIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
         const userAccountPublicKey = userId
             ? await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId)
             : await this.getUserAccountPublicKey();
         let remainingAccounts = [];
         if (userInitialized) {
             remainingAccounts = this.getRemainingAccounts({
-                writableBankIndex: bankIndex,
+                writableSpotMarketIndex: marketIndex,
             });
         }
         else {
-            const bankAccount = this.getBankAccount(bankIndex);
-            if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+            const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+            if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
                 remainingAccounts.push({
-                    pubkey: bankAccount.oracle,
+                    pubkey: spotMarketAccount.oracle,
                     isSigner: false,
                     isWritable: false,
                 });
             }
             remainingAccounts.push({
-                pubkey: bankAccount.pubkey,
+                pubkey: spotMarketAccount.pubkey,
                 isSigner: false,
                 isWritable: true,
             });
         }
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.deposit(bankIndex, amount, reduceOnly, {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.deposit(marketIndex, amount, reduceOnly, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
-                bankVault: bank.vault,
+                spotMarket: spotMarketAccount.pubkey,
+                spotMarketVault: spotMarketAccount.vault,
                 user: userAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 userTokenAccount: userTokenAccount,
@@ -509,7 +541,7 @@ class ClearingHouse {
             return false;
         }
     }
-    async getSolWithdrawalIxs(bankIndex, amount) {
+    async getSolWithdrawalIxs(marketIndex, amount) {
         const result = {
             ixs: [],
             signers: [],
@@ -525,7 +557,7 @@ class ClearingHouse {
         signers.forEach((ix) => {
             result.signers.push(ix);
         });
-        const withdrawIx = await this.getWithdrawIx(amount, bankIndex, pubkey, true);
+        const withdrawIx = await this.getWithdrawIx(amount, marketIndex, pubkey, true);
         result.ixs.push(withdrawIx);
         result.ixs.push(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, pubkey, authority, authority, []));
         return result;
@@ -547,7 +579,7 @@ class ClearingHouse {
             space: 165,
             programId: spl_token_1.TOKEN_PROGRAM_ID,
         }));
-        result.ixs.push(spl_token_1.Token.createInitAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, banks_1.WRAPPED_SOL_MINT, wrappedSolAccount.publicKey, authority));
+        result.ixs.push(spl_token_1.Token.createInitAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, spotMarkets_1.WRAPPED_SOL_MINT, wrappedSolAccount.publicKey, authority));
         result.signers.push(wrappedSolAccount);
         return result;
     }
@@ -555,20 +587,20 @@ class ClearingHouse {
      * Creates the Clearing House User account for a user, and deposits some initial collateral
      * @param amount
      * @param userTokenAccount
-     * @param bankIndex
+     * @param marketIndex
      * @param userId
      * @param name
      * @param fromUserId
      * @returns
      */
-    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, bankIndex = new anchor_1.BN(0), userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId, referrerInfo) {
+    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = new anchor_1.BN(0), userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId, referrerInfo) {
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name, referrerInfo);
         const additionalSigners = [];
-        const bank = this.getBankAccount(bankIndex);
-        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const isSolMarket = spotMarket.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const tx = new web3_js_1.Transaction();
         const authority = this.wallet.publicKey;
-        const createWSOLTokenAccount = isSolBank && userTokenAccount.equals(authority);
+        const createWSOLTokenAccount = isSolMarket && userTokenAccount.equals(authority);
         if (createWSOLTokenAccount) {
             const { ixs: startIxs, signers, pubkey, } = await this.getWrappedSolAccountCreationIxs(amount);
             userTokenAccount = pubkey;
@@ -578,8 +610,8 @@ class ClearingHouse {
             signers.forEach((signer) => additionalSigners.push(signer));
         }
         const depositCollateralIx = fromUserId != null
-            ? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
-            : await this.getDepositInstruction(amount, bankIndex, userTokenAccount, userId, false, false);
+            ? await this.getTransferDepositIx(amount, marketIndex, fromUserId, userId)
+            : await this.getDepositInstruction(amount, marketIndex, userTokenAccount, userId, false, false);
         if (userId === 0) {
             tx.add(await this.getInitializeUserStatsIx());
         }
@@ -591,10 +623,10 @@ class ClearingHouse {
         const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return [txSig, userAccountPublicKey];
     }
-    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, bankIndex, tokenFaucet, amount, referrerInfo) {
+    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo) {
         const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name, referrerInfo);
-        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, associateTokenPublicKey, userId, false, false);
+        const depositCollateralIx = await this.getDepositInstruction(amount, marketIndex, associateTokenPublicKey, userId, false, false);
         const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToIx);
         if (userId === 0) {
             tx.add(await this.getInitializeUserStatsIx());
@@ -603,13 +635,13 @@ class ClearingHouse {
         const txSig = await this.program.provider.sendAndConfirm(tx, []);
         return [txSig, userAccountPublicKey];
     }
-    async withdraw(amount, bankIndex, userTokenAccount, reduceOnly = false) {
+    async withdraw(amount, marketIndex, userTokenAccount, reduceOnly = false) {
         const tx = new web3_js_1.Transaction();
         const additionalSigners = [];
-        const bank = this.getBankAccount(bankIndex);
-        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const authority = this.wallet.publicKey;
-        const createWSOLTokenAccount = isSolBank && userTokenAccount.equals(authority);
+        const createWSOLTokenAccount = isSolMarket && userTokenAccount.equals(authority);
         if (createWSOLTokenAccount) {
             const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
             userTokenAccount = pubkey;
@@ -618,7 +650,7 @@ class ClearingHouse {
             });
             signers.forEach((signer) => additionalSigners.push(signer));
         }
-        const withdrawCollateral = await this.getWithdrawIx(amount, bank.bankIndex, userTokenAccount, reduceOnly);
+        const withdrawCollateral = await this.getWithdrawIx(amount, spotMarketAccount.marketIndex, userTokenAccount, reduceOnly);
         tx.add(withdrawCollateral);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
@@ -627,17 +659,17 @@ class ClearingHouse {
         const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
-    async getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly = false) {
+    async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.withdraw(bankIndex, amount, reduceOnly, {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.withdraw(marketIndex, amount, reduceOnly, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
-                bankVault: bank.vault,
+                spotMarket: spotMarketAccount.pubkey,
+                spotMarketVault: spotMarketAccount.vault,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 user: userAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
@@ -648,17 +680,17 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async transferDeposit(amount, bankIndex, fromUserId, toUserId) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, bankIndex, fromUserId, toUserId)), [], this.opts);
+    async transferDeposit(amount, marketIndex, fromUserId, toUserId) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, marketIndex, fromUserId, toUserId)), [], this.opts);
         return txSig;
     }
-    async getTransferDepositIx(amount, bankIndex, fromUserId, toUserId) {
+    async getTransferDepositIx(amount, marketIndex, fromUserId, toUserId) {
         const fromUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, fromUserId);
         const toUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, toUserId);
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        return await this.program.instruction.transferDeposit(bankIndex, amount, {
+        return await this.program.instruction.transferDeposit(marketIndex, amount, {
             accounts: {
                 authority: this.wallet.publicKey,
                 fromUser,
@@ -669,15 +701,15 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async updateBankCumulativeInterest(bankIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.updateBankCumulativeInterestIx(bankIndex)), [], this.opts);
+    async updateSpotMarketCumulativeInterest(marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.updateSpotMarketCumulativeInterestIx(marketIndex)), [], this.opts);
         return txSig;
     }
-    async updateBankCumulativeInterestIx(bankIndex) {
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.updateBankCumulativeInterest({
+    async updateSpotMarketCumulativeInterestIx(marketIndex) {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.updateSpotMarketCumulativeInterest({
             accounts: {
-                bank: bank.pubkey,
+                spotMarket: spotMarket.pubkey,
             },
         });
     }
@@ -687,7 +719,7 @@ class ClearingHouse {
     }
     async settleLPIx(settleeUserAccountPublicKey, marketIndex) {
         const settleeUserAccount = (await this.program.account.user.fetch(settleeUserAccountPublicKey));
-        const userPositions = settleeUserAccount.positions;
+        const userPositions = settleeUserAccount.perpPositions;
         const remainingAccounts = [];
         let foundMarket = false;
         for (const position of userPositions) {
@@ -721,12 +753,12 @@ class ClearingHouse {
     async getRemoveLiquidityIx(marketIndex, sharesToBurn) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: marketIndex,
+            writablePerpMarketIndex: marketIndex,
         });
         if (sharesToBurn == undefined) {
             const userAccount = this.getUserAccount();
-            const marketPosition = userAccount.positions.filter((position) => position.marketIndex.eq(marketIndex))[0];
-            sharesToBurn = marketPosition.lpShares;
+            const perpPosition = userAccount.perpPositions.filter((position) => position.marketIndex.eq(marketIndex))[0];
+            sharesToBurn = perpPosition.lpShares;
             console.log('burning lp shares:', sharesToBurn.toString());
         }
         return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
@@ -746,7 +778,7 @@ class ClearingHouse {
     async getAddLiquidityIx(amount, marketIndex) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: marketIndex,
+            writablePerpMarketIndex: marketIndex,
         });
         return this.program.instruction.addLiquidity(amount, marketIndex, {
             accounts: {
@@ -766,19 +798,51 @@ class ClearingHouse {
             price: limitPrice,
         });
     }
+    async sendSignedTx(tx) {
+        const { txSig } = await this.txSender.send(tx, undefined, this.opts, true);
+        return txSig;
+    }
+    /**
+     * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
+     * @param orderParams
+     * @param userAccountPublicKey
+     * @param userAccount
+     * @returns
+     */
+    async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount) {
+        const marketIndex = orderParams.marketIndex;
+        const orderId = userAccount.nextOrderId;
+        const marketOrderTx = (0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams));
+        const fillTx = (0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, userAccount, {
+            orderId,
+            marketIndex,
+        }));
+        // Apply the latest blockhash to the txs so that we can sign before sending them
+        const currentBlockHash = (await this.connection.getLatestBlockhash('finalized')).blockhash;
+        marketOrderTx.recentBlockhash = currentBlockHash;
+        fillTx.recentBlockhash = currentBlockHash;
+        marketOrderTx.feePayer = userAccount.authority;
+        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.toNumber(), slot);
+        return { txSig, signedFillTx };
+    }
     async placeOrder(orderParams) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams)), [], this.opts);
         this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
         return txSig;
     }
-    getOrderParams(optionalOrderParams) {
-        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams);
+    getOrderParams(optionalOrderParams, marketType) {
+        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams, {
+            marketType,
+        });
     }
     async getPlaceOrderIx(orderParams) {
-        orderParams = this.getOrderParams(orderParams);
+        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            readableMarketIndex: orderParams.marketIndex,
+            readablePerpMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placeOrder(orderParams, {
             accounts: {
@@ -802,7 +866,7 @@ class ClearingHouse {
         const oracleAccountInfos = [];
         for (const marketIndex of marketIndexes) {
             if (!marketIndex.eq(new anchor_1.BN(100))) {
-                const market = this.getMarketAccount(marketIndex);
+                const market = this.getPerpMarketAccount(marketIndex);
                 marketAccountInfos.push({
                     pubkey: market.pubkey,
                     isWritable: true,
@@ -824,6 +888,41 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async settleExpiredMarket(marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleExpiredMarketIx(marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getSettleExpiredMarketIx(marketIndex) {
+        const marketAccountInfos = [];
+        const oracleAccountInfos = [];
+        const spotMarketAccountInfos = [];
+        const market = this.getPerpMarketAccount(marketIndex);
+        marketAccountInfos.push({
+            pubkey: market.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        oracleAccountInfos.push({
+            pubkey: market.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        spotMarketAccountInfos.push({
+            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
+            isSigner: false,
+            isWritable: true,
+        });
+        const remainingAccounts = oracleAccountInfos
+            .concat(spotMarketAccountInfos)
+            .concat(marketAccountInfos);
+        return await this.program.instruction.settleExpiredMarket(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async cancelOrder(orderId) {
         const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrderIx(orderId)), [], this.opts);
         return txSig;
@@ -847,7 +946,7 @@ class ClearingHouse {
     async getCancelOrderByUserIdIx(userOrderId) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const order = this.getOrderByUserId(userOrderId);
-        const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+        const oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
         const remainingAccounts = this.getRemainingAccounts({});
         return await this.program.instruction.cancelOrderByUserId(userOrderId, {
             accounts: {
@@ -870,32 +969,32 @@ class ClearingHouse {
         const marketIndex = order
             ? order.marketIndex
             : userAccount.orders.find((order) => order.orderId.eq(userAccount.nextOrderId.sub(numericConstants_1.ONE))).marketIndex;
-        const marketAccount = this.getMarketAccount(marketIndex);
+        const marketAccount = this.getPerpMarketAccount(marketIndex);
         const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
-        for (const bankBalance of userAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
+        const spotMarketAccountMap = new Map();
+        const perpMarketAccountMap = new Map();
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
+                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
                         isSigner: false,
                         isWritable: false,
                     });
                 }
             }
         }
-        for (const position of userAccount.positions) {
+        for (const position of userAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position) &&
                 !position.marketIndex.eq(order.marketIndex)) {
-                const market = this.getMarketAccount(position.marketIndex);
-                marketAccountMap.set(position.marketIndex.toNumber(), {
+                const market = this.getPerpMarketAccount(position.marketIndex);
+                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
                     isWritable: false,
                     isSigner: false,
@@ -907,7 +1006,7 @@ class ClearingHouse {
                 });
             }
         }
-        marketAccountMap.set(marketIndex.toNumber(), {
+        perpMarketAccountMap.set(marketIndex.toNumber(), {
             pubkey: marketAccount.pubkey,
             isWritable: true,
             isSigner: false,
@@ -919,8 +1018,8 @@ class ClearingHouse {
         });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...perpMarketAccountMap.values(),
         ];
         if (makerInfo) {
             remainingAccounts.push({
@@ -960,6 +1059,212 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async placeSpotOrder(orderParams) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceSpotOrderIx(orderParams)), [], this.opts);
+        return txSig;
+    }
+    async getPlaceSpotOrderIx(orderParams) {
+        orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            readableSpotMarketIndex: orderParams.marketIndex,
+        });
+        return await this.program.instruction.placeSpotOrder(orderParams, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
+    async fillSpotOrder(userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillSpotOrderIx(userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo)), [], this.opts);
+        return txSig;
+    }
+    async getFillSpotOrderIx(userAccountPublicKey, userAccount, order, fulfillmentConfig, makerInfo, referrerInfo) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const marketIndex = order
+            ? order.marketIndex
+            : userAccount.orders.find((order) => order.orderId.eq(userAccount.nextOrderId.sub(numericConstants_1.ONE))).marketIndex;
+        const oracleAccountMap = new Map();
+        const spotMarketAccountMap = new Map();
+        const perpMarketAccountMap = new Map();
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarket.pubkey,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                if (!spotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarket.oracle.toString(), {
+                        pubkey: spotMarket.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
+        for (const position of userAccount.perpPositions) {
+            if (!(0, position_1.positionIsAvailable)(position) &&
+                !position.marketIndex.eq(order.marketIndex)) {
+                const market = this.getPerpMarketAccount(position.marketIndex);
+                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
+                    isSigner: false,
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        spotMarketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: spotMarketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+            oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                pubkey: spotMarketAccount.oracle,
+                isWritable: false,
+                isSigner: false,
+            });
+        }
+        const quoteMarketAccount = this.getQuoteSpotMarketAccount();
+        spotMarketAccountMap.set(quoteMarketAccount.marketIndex.toNumber(), {
+            pubkey: quoteMarketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...perpMarketAccountMap.values(),
+        ];
+        if (makerInfo) {
+            remainingAccounts.push({
+                pubkey: makerInfo.maker,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        const orderId = order.orderId;
+        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+        if (fulfillmentConfig) {
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.pubkey,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumProgramId,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumMarket,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumRequestQueue,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumEventQueue,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumBids,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumAsks,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumBaseVault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumQuoteVault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumOpenOrders,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getSerumSignerPublicKey)(fulfillmentConfig.serumProgramId, fulfillmentConfig.serumMarket, fulfillmentConfig.serumSignerNonce),
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.getSignerPublicKey(),
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: spl_token_1.TOKEN_PROGRAM_ID,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: spotMarketAccount.vault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: quoteMarketAccount.vault,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        return await this.program.instruction.fillSpotOrder(orderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                fillerStats: fillerStatsPublicKey,
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async triggerOrder(userAccountPublicKey, user, order) {
         const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTriggerOrderIx(userAccountPublicKey, user, order)), [], this.opts);
         return txSig;
@@ -967,32 +1272,32 @@ class ClearingHouse {
     async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
         const fillerPublicKey = await this.getUserAccountPublicKey();
         const marketIndex = order.marketIndex;
-        const marketAccount = this.getMarketAccount(marketIndex);
+        const marketAccount = this.getPerpMarketAccount(marketIndex);
         const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
-        for (const bankBalance of userAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
+        const spotMarketAccountMap = new Map();
+        const perpMarketAccountMap = new Map();
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
+                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
                         isSigner: false,
                         isWritable: false,
                     });
                 }
             }
         }
-        for (const position of userAccount.positions) {
+        for (const position of userAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position) &&
                 !position.marketIndex.eq(order.marketIndex)) {
-                const market = this.getMarketAccount(position.marketIndex);
-                marketAccountMap.set(position.marketIndex.toNumber(), {
+                const market = this.getPerpMarketAccount(position.marketIndex);
+                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
                     isWritable: false,
                     isSigner: false,
@@ -1004,7 +1309,7 @@ class ClearingHouse {
                 });
             }
         }
-        marketAccountMap.set(marketIndex.toNumber(), {
+        perpMarketAccountMap.set(marketIndex.toNumber(), {
             pubkey: marketAccount.pubkey,
             isWritable: true,
             isSigner: false,
@@ -1016,8 +1321,8 @@ class ClearingHouse {
         });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...perpMarketAccountMap.values(),
         ];
         const orderId = order.orderId;
         return await this.program.instruction.triggerOrder(orderId, {
@@ -1030,18 +1335,94 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async triggerSpotOrder(userAccountPublicKey, user, order) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTriggerSpotOrderIx(userAccountPublicKey, user, order)), [], this.opts);
+        return txSig;
+    }
+    async getTriggerSpotOrderIx(userAccountPublicKey, userAccount, order) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const marketIndex = order.marketIndex;
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const oracleAccountMap = new Map();
+        const spotMarketAccountMap = new Map();
+        const perpMarketAccountMap = new Map();
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
+        for (const position of userAccount.perpPositions) {
+            if (!(0, position_1.positionIsAvailable)(position) &&
+                !position.marketIndex.eq(order.marketIndex)) {
+                const market = this.getPerpMarketAccount(position.marketIndex);
+                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
+                    isSigner: false,
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        const quoteSpotMarket = this.getQuoteSpotMarketAccount();
+        spotMarketAccountMap.set(quoteSpotMarket.marketIndex.toNumber(), {
+            pubkey: quoteSpotMarket.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        spotMarketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: spotMarketAccount.pubkey,
+            isWritable: false,
+            isSigner: false,
+        });
+        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+            pubkey: spotMarketAccount.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...perpMarketAccountMap.values(),
+        ];
+        const orderId = order.orderId;
+        return await this.program.instruction.triggerSpotOrder(orderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async placeAndTake(orderParams, makerInfo, referrerInfo) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakeIx(orderParams, makerInfo, referrerInfo)), [], this.opts);
         this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
         return txSig;
     }
     async getPlaceAndTakeIx(orderParams, makerInfo, referrerInfo) {
-        orderParams = this.getOrderParams(orderParams);
+        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: orderParams.marketIndex,
-            writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
+            writablePerpMarketIndex: orderParams.marketIndex,
+            writableSpotMarketIndex: numericConstants_1.QUOTE_SPOT_MARKET_INDEX,
         });
         let makerOrderId = null;
         if (makerInfo) {
@@ -1085,13 +1466,13 @@ class ClearingHouse {
         return txSig;
     }
     async getPlaceAndMakeIx(orderParams, takerInfo, referrerInfo) {
-        orderParams = this.getOrderParams(orderParams);
+        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         // todo merge this with getRemainingAccounts
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             counterPartyUserAccount: takerInfo.takerUserAccount,
-            writableMarketIndex: orderParams.marketIndex,
+            writablePerpMarketIndex: orderParams.marketIndex,
         });
         if (referrerInfo) {
             remainingAccounts.push({
@@ -1156,12 +1537,82 @@ class ClearingHouse {
         return txSig;
     }
     async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        const perpMarketAccountMap = new Map();
+        const oracleAccountMap = new Map();
+        const spotMarketAccountMap = new Map();
+        for (const position of settleeUserAccount.perpPositions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                const market = this.getPerpMarketAccount(position.marketIndex);
+                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
+                    isSigner: false,
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        for (const spotPosition of settleeUserAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
+        const marketAccount = this.getPerpMarketAccount(marketIndex.toNumber());
+        perpMarketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: marketAccount.pubkey,
+            isSigner: false,
+            isWritable: true,
+        });
+        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+            pubkey: marketAccount.amm.oracle,
+            isSigner: false,
+            isWritable: false,
+        });
+        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX.toNumber(), {
+            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
+            isSigner: false,
+            isWritable: true,
+        });
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...perpMarketAccountMap.values(),
+        ];
+        return await this.program.instruction.settlePnl(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: settleeUserAccountPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async settleExpiredPosition(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleExpiredPositionIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getSettleExpiredPositionIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
         const marketAccountMap = new Map();
         const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        for (const position of settleeUserAccount.positions) {
+        const spotMarketAccountMap = new Map();
+        for (const position of settleeUserAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(position.marketIndex);
+                const market = this.getPerpMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
                     isWritable: false,
@@ -1174,15 +1625,15 @@ class ClearingHouse {
                 });
             }
         }
-        for (const userBankBalance of settleeUserAccount.bankBalances) {
-            if (!userBankBalance.balance.eq(numericConstants_1.QUOTE_ASSET_BANK_INDEX)) {
-                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
+        for (const userBankBalance of settleeUserAccount.spotPositions) {
+            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
+                const bankAccount = this.getSpotMarketAccount(userBankBalance.marketIndex);
+                spotMarketAccountMap.set(userBankBalance.marketIndex.toNumber(), {
                     pubkey: bankAccount.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
+                if (!bankAccount.marketIndex.eq(numericConstants_1.ZERO)) {
                     oracleAccountMap.set(bankAccount.oracle.toString(), {
                         pubkey: bankAccount.oracle,
                         isSigner: false,
@@ -1191,7 +1642,7 @@ class ClearingHouse {
                 }
             }
         }
-        const marketAccount = this.getMarketAccount(marketIndex.toNumber());
+        const marketAccount = this.getPerpMarketAccount(marketIndex.toNumber());
         marketAccountMap.set(marketIndex.toNumber(), {
             pubkey: marketAccount.pubkey,
             isSigner: false,
@@ -1202,17 +1653,17 @@ class ClearingHouse {
             isSigner: false,
             isWritable: false,
         });
-        bankAccountMap.set(numericConstants_1.QUOTE_ASSET_BANK_INDEX.toNumber(), {
-            pubkey: this.getBankAccount(numericConstants_1.QUOTE_ASSET_BANK_INDEX).pubkey,
+        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX.toNumber(), {
+            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
             isSigner: false,
             isWritable: true,
         });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
+            ...spotMarketAccountMap.values(),
             ...marketAccountMap.values(),
         ];
-        return await this.program.instruction.settlePnl(marketIndex, {
+        return await this.program.instruction.settleExpiredPosition(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
@@ -1222,7 +1673,8 @@ class ClearingHouse {
         });
     }
     async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)), [], this.opts);
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)), [], this.opts);
+        this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
         return txSig;
     }
     async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
@@ -1230,7 +1682,7 @@ class ClearingHouse {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            writableMarketIndex: marketIndex,
+            writablePerpMarketIndex: marketIndex,
             counterPartyUserAccount: userAccount,
         });
         return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
@@ -1245,17 +1697,17 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidateBorrow(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer)), [], this.opts);
+    async liquidateBorrow(userAccountPublicKey, userAccount, assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer)), [], this.opts);
         return txSig;
     }
-    async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
+    async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             counterPartyUserAccount: userAccount,
-            writableBankIndexes: [liabilityBankIndex, assetBankIndex],
+            writableSpotMarketIndexes: [liabilitymarketIndex, assetmarketIndex],
         });
-        return await this.program.instruction.liquidateBorrow(assetBankIndex, liabilityBankIndex, maxLiabilityTransfer, {
+        return await this.program.instruction.liquidateBorrow(assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
@@ -1265,18 +1717,19 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer)), [], this.opts);
+    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.toNumber(), slot);
         return txSig;
     }
-    async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
+    async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             counterPartyUserAccount: userAccount,
-            writableMarketIndex: perpMarketIndex,
-            writableBankIndexes: [liabilityBankIndex],
+            writablePerpMarketIndex: perpMarketIndex,
+            writableSpotMarketIndexes: [liabilitymarketIndex],
         });
-        return await this.program.instruction.liquidateBorrowForPerpPnl(perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer, {
+        return await this.program.instruction.liquidateBorrowForPerpPnl(perpMarketIndex, liabilitymarketIndex, maxLiabilityTransfer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
@@ -1286,18 +1739,19 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer)), [], this.opts);
+    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.toNumber(), slot);
         return txSig;
     }
-    async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
+    async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             counterPartyUserAccount: userAccount,
-            writableMarketIndex: perpMarketIndex,
-            writableBankIndexes: [assetBankIndex],
+            writablePerpMarketIndex: perpMarketIndex,
+            writableSpotMarketIndexes: [assetMarketIndex],
         });
-        return await this.program.instruction.liquidatePerpPnlForDeposit(perpMarketIndex, assetBankIndex, maxPnlTransfer, {
+        return await this.program.instruction.liquidatePerpPnlForDeposit(perpMarketIndex, assetMarketIndex, maxPnlTransfer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
@@ -1307,51 +1761,51 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, bankIndex, marketIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, bankIndex, marketIndex)), [], this.opts);
+    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
         return txSig;
     }
-    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, bankIndex, marketIndex) {
+    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            writableMarketIndex: marketIndex,
-            writableBankIndexes: [bankIndex],
+            writablePerpMarketIndex: marketIndex,
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
             counterPartyUserAccount: userAccount,
         });
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.resolvePerpBankruptcy(bankIndex, marketIndex, {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.resolvePerpBankruptcy(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 liquidator: liquidatorPublicKey,
-                bankVault: bank.vault,
-                insuranceFundVault: bank.insuranceFundVault,
+                spotMarketVault: spotMarket.vault,
+                insuranceFundVault: spotMarket.insuranceFundVault,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async resolveBorrowBankruptcy(userAccountPublicKey, userAccount, bankIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex)), [], this.opts);
+    async resolveBorrowBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
         return txSig;
     }
-    async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex) {
+    async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            writableBankIndexes: [bankIndex],
+            writableSpotMarketIndexes: [marketIndex],
             counterPartyUserAccount: userAccount,
         });
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.resolveBorrowBankruptcy(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 liquidator: liquidatorPublicKey,
-                bankVault: bank.vault,
-                insuranceFundVault: bank.insuranceFundVault,
+                spotMarketVault: spotMarket.vault,
+                insuranceFundVault: spotMarket.insuranceFundVault,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
@@ -1361,28 +1815,28 @@ class ClearingHouse {
     getRemainingAccountsWithCounterparty(params) {
         const counterPartyUserAccount = params.counterPartyUserAccount;
         const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
+        const spotMarketAccountMap = new Map();
         const marketAccountMap = new Map();
-        for (const bankBalance of counterPartyUserAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
+        for (const spotPosition of counterPartyUserAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarket.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
+                if (!spotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarket.oracle.toString(), {
+                        pubkey: spotMarket.oracle,
                         isSigner: false,
                         isWritable: false,
                     });
                 }
             }
         }
-        for (const position of counterPartyUserAccount.positions) {
+        for (const position of counterPartyUserAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(position.marketIndex);
+                const market = this.getPerpMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
                     isWritable: false,
@@ -1404,7 +1858,7 @@ class ClearingHouse {
             // if cache has more recent slot than user positions account slot, add market to remaining accounts
             // otherwise remove from slot
             if (slot > lastUserPositionsSlot) {
-                const marketAccount = this.getMarketAccount(marketIndexNum);
+                const marketAccount = this.getPerpMarketAccount(marketIndexNum);
                 marketAccountMap.set(marketIndexNum, {
                     pubkey: marketAccount.pubkey,
                     isSigner: false,
@@ -1420,26 +1874,26 @@ class ClearingHouse {
                 this.marketLastSlotCache.delete(marketIndexNum);
             }
         }
-        for (const bankBalance of userAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarket.pubkey,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
+                if (!spotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarket.oracle.toString(), {
+                        pubkey: spotMarket.oracle,
                         isSigner: false,
                         isWritable: false,
                     });
                 }
             }
         }
-        for (const position of userAccount.positions) {
+        for (const position of userAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(position.marketIndex);
+                const market = this.getPerpMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
                     isWritable: false,
@@ -1452,8 +1906,8 @@ class ClearingHouse {
                 });
             }
         }
-        if (params.writableMarketIndex) {
-            const market = this.getMarketAccount(params.writableMarketIndex);
+        if (params.writablePerpMarketIndex) {
+            const market = this.getPerpMarketAccount(params.writablePerpMarketIndex);
             marketAccountMap.set(market.marketIndex.toNumber(), {
                 pubkey: market.pubkey,
                 isSigner: false,
@@ -1465,17 +1919,17 @@ class ClearingHouse {
                 isWritable: false,
             });
         }
-        if (params.writableBankIndexes) {
-            for (const writableBankIndex of params.writableBankIndexes) {
-                const bank = this.getBankAccount(writableBankIndex);
-                bankAccountMap.set(bank.bankIndex.toNumber(), {
-                    pubkey: bank.pubkey,
+        if (params.writableSpotMarketIndexes) {
+            for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
+                const spotMarketAccount = this.getSpotMarketAccount(writableSpotMarketIndex);
+                spotMarketAccountMap.set(spotMarketAccount.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
                     isSigner: false,
                     isWritable: true,
                 });
-                if (!bank.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bank.oracle.toString(), {
-                        pubkey: bank.oracle,
+                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
                         isSigner: false,
                         isWritable: false,
                     });
@@ -1484,7 +1938,7 @@ class ClearingHouse {
         }
         return [
             ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
+            ...spotMarketAccountMap.values(),
             ...marketAccountMap.values(),
         ];
     }
@@ -1507,7 +1961,7 @@ class ClearingHouse {
     }
     async getSettleFundingPaymentIx(userAccount) {
         const user = (await this.program.account.user.fetch(userAccount));
-        const userPositions = user.positions;
+        const userPositions = user.perpPositions;
         const remainingAccounts = [];
         for (const position of userPositions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
@@ -1531,20 +1985,20 @@ class ClearingHouse {
         this.eventEmitter.emit(eventName, data);
     }
     getOracleDataForMarket(marketIndex) {
-        const oracleKey = this.getMarketAccount(marketIndex).amm.oracle;
+        const oracleKey = this.getPerpMarketAccount(marketIndex).amm.oracle;
         const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
         return oracleData;
     }
-    async initializeInsuranceFundStake(bankIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getInitializeInsuranceFundStakeIx(bankIndex)), [], this.opts);
+    async initializeInsuranceFundStake(marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getInitializeInsuranceFundStakeIx(marketIndex)), [], this.opts);
         return txSig;
     }
-    async getInitializeInsuranceFundStakeIx(bankIndex) {
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
-        return await this.program.instruction.initializeInsuranceFundStake(bankIndex, {
+    async getInitializeInsuranceFundStakeIx(marketIndex) {
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        return await this.program.instruction.initializeInsuranceFundStake(marketIndex, {
             accounts: {
                 insuranceFundStake: ifStakeAccountPublicKey,
-                bank: this.getBankAccount(bankIndex).pubkey,
+                spotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
                 payer: this.wallet.publicKey,
@@ -1554,80 +2008,80 @@ class ClearingHouse {
             },
         });
     }
-    async addInsuranceFundStake(bankIndex, amount, collateralAccountPublicKey) {
-        const bank = this.getBankAccount(bankIndex);
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+    async addInsuranceFundStake(marketIndex, amount, collateralAccountPublicKey) {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        return await this.program.rpc.addInsuranceFundStake(bankIndex, amount, {
+        return await this.program.rpc.addInsuranceFundStake(marketIndex, amount, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
+                spotMarket: spotMarket.pubkey,
                 insuranceFundStake: ifStakeAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
-                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVault: spotMarket.insuranceFundVault,
                 userTokenAccount: collateralAccountPublicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
             remainingAccounts,
         });
     }
-    async requestRemoveInsuranceFundStake(bankIndex, amount) {
-        const bank = this.getBankAccount(bankIndex);
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+    async requestRemoveInsuranceFundStake(marketIndex, amount) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        return await this.program.rpc.requestRemoveInsuranceFundStake(bankIndex, amount, {
+        return await this.program.rpc.requestRemoveInsuranceFundStake(marketIndex, amount, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
+                spotMarket: spotMarketAccount.pubkey,
                 insuranceFundStake: ifStakeAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
-                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
                 // userTokenAccount: collateralAccountPublicKey,
                 // tokenProgram: TOKEN_PROGRAM_ID,
             },
             remainingAccounts,
         });
     }
-    async cancelRequestRemoveInsuranceFundStake(bankIndex) {
-        const bank = this.getBankAccount(bankIndex);
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+    async cancelRequestRemoveInsuranceFundStake(marketIndex) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(bankIndex, {
+        return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
+                spotMarket: spotMarketAccount.pubkey,
                 insuranceFundStake: ifStakeAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
-                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
                 // userTokenAccount: collateralAccountPublicKey,
                 // tokenProgram: TOKEN_PROGRAM_ID,
             },
             remainingAccounts,
         });
     }
-    async removeInsuranceFundStake(bankIndex, collateralAccountPublicKey) {
-        const bank = this.getBankAccount(bankIndex);
-        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+    async removeInsuranceFundStake(marketIndex, collateralAccountPublicKey) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        return await this.program.rpc.removeInsuranceFundStake(bankIndex, {
+        return await this.program.rpc.removeInsuranceFundStake(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
+                spotMarket: spotMarketAccount.pubkey,
                 insuranceFundStake: ifStakeAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
-                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 userTokenAccount: collateralAccountPublicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
@@ -1635,22 +2089,44 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async settleRevenueToInsuranceFund(bankIndex) {
-        const bank = this.getBankAccount(bankIndex);
+    async settleRevenueToInsuranceFund(marketIndex) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            writableSpotMarketIndex: marketIndex,
         });
-        return await this.program.rpc.settleRevenueToInsuranceFund(bankIndex, {
+        return await this.program.rpc.settleRevenueToInsuranceFund(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
-                bankVault: bank.vault,
+                spotMarket: spotMarketAccount.pubkey,
+                spotMarketVault: spotMarketAccount.vault,
                 clearingHouseSigner: this.getSignerPublicKey(),
-                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
             remainingAccounts,
         });
     }
+    async resolvePerpPnlDeficit(spotMarketIndex, perpMarketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex) {
+        const remainingAccounts = this.getRemainingAccounts({
+            writablePerpMarketIndex: perpMarketIndex,
+            writableSpotMarketIndex: spotMarketIndex,
+        });
+        const spotMarket = this.getSpotMarketAccount(spotMarketIndex);
+        return await this.program.instruction.resolvePerpPnlDeficit(spotMarketIndex, perpMarketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                spotMarketVault: spotMarket.vault,
+                insuranceFundVault: spotMarket.insuranceFundVault,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
 }
 exports.ClearingHouse = ClearingHouse;