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

package/lib/admin.js

@@ -29,6 +29,7 @@ const types_1 = require("./types");
 const anchor_1 = require("@project-serum/anchor");
 const anchor = __importStar(require("@project-serum/anchor"));
 const pda_1 = require("./addresses/pda");
+const utils_1 = require("./math/utils");
 const spl_token_1 = require("@solana/spl-token");
 const clearingHouse_1 = require("./clearingHouse");
 const numericConstants_1 = require("./constants/numericConstants");
@@ -40,17 +41,16 @@ class Admin extends clearingHouse_1.ClearingHouse {
         if (stateAccountRPCResponse.value !== null) {
             throw new Error('Clearing house already initialized');
         }
-        const [insuranceVaultPublicKey] = await web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
-        const [insuranceVaultAuthority] = await web3_js_1.PublicKey.findProgramAddress([insuranceVaultPublicKey.toBuffer()], this.program.programId);
         const [clearingHouseStatePublicKey] = await (0, pda_1.getClearingHouseStateAccountPublicKeyAndNonce)(this.program.programId);
+        const [insuranceVaultPublicKey] = await web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
         const initializeTx = await this.program.transaction.initialize(adminControlsPrices, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: clearingHouseStatePublicKey,
                 quoteAssetMint: usdcMint,
-                insuranceVault: insuranceVaultPublicKey,
-                insuranceVaultAuthority: insuranceVaultAuthority,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                insuranceVault: insuranceVaultPublicKey,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 systemProgram: anchor.web3.SystemProgram.programId,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
@@ -58,23 +58,20 @@ class Admin extends clearingHouse_1.ClearingHouse {
         const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
         return [initializeTxSig];
     }
-    async initializeBank(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO) {
-        const bankIndex = this.getStateAccount().numberOfBanks;
-        const bank = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        const bankVault = await (0, pda_1.getBankVaultPublicKey)(this.program.programId, bankIndex);
-        const bankVaultAuthority = await (0, pda_1.getBankVaultAuthorityPublicKey)(this.program.programId, bankIndex);
-        const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, bankIndex);
-        const insuranceFundVaultAuthority = await (0, pda_1.getInsuranceFundVaultAuthorityPublicKey)(this.program.programId, bankIndex);
-        const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO) {
+        const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
+        const spotMarket = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
+        const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
+        const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, spotMarketIndex);
+        const initializeTx = await this.program.transaction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                bank,
-                bankVault,
-                bankVaultAuthority,
+                spotMarket,
+                spotMarketVault,
                 insuranceFundVault,
-                insuranceFundVaultAuthority,
-                bankMint: mint,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                spotMarketMint: mint,
                 oracle,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
@@ -82,13 +79,32 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
         const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
-        await this.accountSubscriber.addBank(bankIndex);
+        await this.accountSubscriber.addSpotMarket(spotMarketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
             publicKey: oracle,
         });
         return txSig;
     }
+    async initializeSerumFulfillmentConfig(marketIndex, serumMarket, serumProgram) {
+        const serumOpenOrders = (0, pda_1.getSerumOpenOrdersPublicKey)(this.program.programId, serumMarket);
+        const serumFulfillmentConfig = (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
+        return await this.program.rpc.initializeSerumFulfillmentConfig(marketIndex, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+                quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                serumProgram,
+                serumMarket,
+                serumOpenOrders,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                serumFulfillmentConfig,
+            },
+        });
+    }
     async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
         const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, {
@@ -102,20 +118,23 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
         const { txSig } = await this.txSender.send(initializeMarketTx, [], this.opts);
-        await this.accountSubscriber.addMarket(this.getStateAccount().numberOfMarkets);
+        await this.accountSubscriber.addPerpMarket(this.getStateAccount().numberOfMarkets);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
             publicKey: priceOracle,
         });
         return txSig;
     }
-    async moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex) {
+    async moveAmmPrice(marketIndex, baseAssetReserve, quoteAssetReserve, sqrtK) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, {
+        if (sqrtK == undefined) {
+            sqrtK = (0, utils_1.squareRootBN)(baseAssetReserve.mul(quoteAssetReserve));
+        }
+        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                market: marketPublicKey,
+                perpMarket: marketPublicKey,
             },
         });
     }
@@ -125,27 +144,27 @@ class Admin extends clearingHouse_1.ClearingHouse {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                oracle: this.getMarketAccount(marketIndex).amm.oracle,
+                oracle: this.getPerpMarketAccount(marketIndex).amm.oracle,
             },
         });
     }
-    async moveAmmToPrice(marketIndex, targetPrice) {
-        const market = this.getMarketAccount(marketIndex);
+    async moveAmmToPrice(perpMarketIndex, targetPrice) {
+        const market = this.getPerpMarketAccount(perpMarketIndex);
         const [direction, tradeSize, _] = (0, trade_1.calculateTargetPriceTrade)(market, targetPrice, new anchor_1.BN(1000), 'quote', undefined //todo
         );
         const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, {
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, market.amm.sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
-                market: marketPublicKey,
+                perpMarket: marketPublicKey,
             },
         });
     }
     async repegAmmCurve(newPeg, marketIndex) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const ammData = this.getMarketAccount(marketIndex).amm;
+        const ammData = this.getPerpMarketAccount(marketIndex).amm;
         return await this.program.rpc.repegAmmCurve(newPeg, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -156,7 +175,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
         });
     }
     async updateAmmOracleTwap(marketIndex) {
-        const ammData = this.getMarketAccount(marketIndex).amm;
+        const ammData = this.getPerpMarketAccount(marketIndex).amm;
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
         return await this.program.rpc.updateAmmOracleTwap({
             accounts: {
@@ -168,7 +187,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
         });
     }
     async resetAmmOracleTwap(marketIndex) {
-        const ammData = this.getMarketAccount(marketIndex).amm;
+        const ammData = this.getPerpMarketAccount(marketIndex).amm;
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
         return await this.program.rpc.resetAmmOracleTwap({
             accounts: {
@@ -181,14 +200,14 @@ class Admin extends clearingHouse_1.ClearingHouse {
     }
     async withdrawFromInsuranceVault(amount, recipient) {
         const state = await this.getStateAccount();
-        const bank = this.getQuoteAssetBankAccount();
+        const spotMarket = this.getQuoteSpotMarketAccount();
         return await this.program.rpc.withdrawFromInsuranceVault(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
+                spotMarket: spotMarket.pubkey,
                 insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 recipient: recipient,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
@@ -196,15 +215,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
     }
     async withdrawFromMarketToInsuranceVault(marketIndex, amount, recipient) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const bank = this.getQuoteAssetBankAccount();
+        const spotMarket = this.getQuoteSpotMarketAccount();
         return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 market: marketPublicKey,
-                bank: bank.pubkey,
-                bankVault: bank.vault,
-                bankVaultAuthority: bank.vaultAuthority,
+                spotMarket: spotMarket.pubkey,
+                spotMarketVault: spotMarket.vault,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 recipient: recipient,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
@@ -212,17 +231,16 @@ class Admin extends clearingHouse_1.ClearingHouse {
     }
     async withdrawFromInsuranceVaultToMarket(marketIndex, amount) {
         const state = await this.getStateAccount();
-        const bank = this.getQuoteAssetBankAccount();
+        const spotMarket = this.getQuoteSpotMarketAccount();
         return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
                 insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
-                bank: bank.pubkey,
-                bankVault: bank.vault,
-                bankVaultAuthority: bank.vaultAuthority,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                quoteSpotMarket: spotMarket.pubkey,
+                spotMarketVault: spotMarket.vault,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
@@ -346,30 +364,30 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateBankWithdrawGuardThreshold(bankIndex, withdrawGuardThreshold) {
-        return await this.program.rpc.updateBankWithdrawGuardThreshold(withdrawGuardThreshold, {
+    async updateWithdrawGuardThreshold(marketIndex, withdrawGuardThreshold) {
+        return await this.program.rpc.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                bank: await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
             },
         });
     }
-    async updateBankIfFactor(bankIndex, userIfFactor, totalIfFactor, liquidationIfFactor) {
-        return await this.program.rpc.updateBankIfFactor(bankIndex, userIfFactor, totalIfFactor, liquidationIfFactor, {
+    async updateSpotMarketIfFactor(marketIndex, userIfFactor, totalIfFactor, liquidationIfFactor) {
+        return await this.program.rpc.updateSpotMarketIfFactor(marketIndex, userIfFactor, totalIfFactor, liquidationIfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                bank: await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
             },
         });
     }
-    async updateBankInsuranceWithdrawEscrowPeriod(bankIndex, insuranceWithdrawEscrowPeriod) {
-        return await this.program.rpc.updateBankInsuranceWithdrawEscrowPeriod(insuranceWithdrawEscrowPeriod, {
+    async updateInsuranceWithdrawEscrowPeriod(marketIndex, insuranceWithdrawEscrowPeriod) {
+        return await this.program.rpc.updateInsuranceWithdrawEscrowPeriod(insuranceWithdrawEscrowPeriod, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                bank: await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
             },
         });
     }
@@ -409,6 +427,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateMarketExpiry(perpMarketIndex, expiryTs) {
+        return await this.program.rpc.updateMarketExpiry(expiryTs, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
+            },
+        });
+    }
     async updateWhitelistMint(whitelistMint) {
         return await this.program.rpc.updateWhitelistMint(whitelistMint, {
             accounts: {
@@ -470,7 +497,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: this.getMarketAccount(marketIndex).pubkey,
+                market: this.getPerpMarketAccount(marketIndex).pubkey,
             },
         });
     }
@@ -479,7 +506,16 @@ class Admin extends clearingHouse_1.ClearingHouse {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
-                market: this.getMarketAccount(marketIndex).pubkey,
+                market: this.getPerpMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async updateMarketMaxImbalances(marketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
+        return await this.program.rpc.updateMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
             },
         });
     }

package/lib/clearingHouse.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 import { AnchorProvider, BN, Program } from '@project-serum/anchor';
-import { StateAccount, IWallet, PositionDirection, UserAccount, MarketAccount, OrderParams, Order, BankAccount, UserBankBalance, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo } from './types';
-import { Connection, PublicKey, TransactionSignature, ConfirmOptions, TransactionInstruction, AccountMeta } from '@solana/web3.js';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, SerumV3FulfillmentConfigAccount } from './types';
+import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
@@ -47,12 +47,15 @@ export declare class ClearingHouse {
     unsubscribeUsers(): Promise<void>[];
     statePublicKey?: PublicKey;
     getStatePublicKey(): Promise<PublicKey>;
+    signerPublicKey?: PublicKey;
+    getSignerPublicKey(): PublicKey;
     getStateAccount(): StateAccount;
-    getMarketAccount(marketIndex: BN | number): MarketAccount | undefined;
-    getMarketAccounts(): MarketAccount[];
-    getBankAccount(bankIndex: BN | number): BankAccount | undefined;
-    getQuoteAssetBankAccount(): BankAccount;
+    getPerpMarketAccount(marketIndex: BN | number): PerpMarketAccount | undefined;
+    getPerpMarketAccounts(): PerpMarketAccount[];
+    getSpotMarketAccount(marketIndex: BN | number): SpotMarketAccount | undefined;
+    getQuoteSpotMarketAccount(): SpotMarketAccount;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
+    getSerumV3FulfillmentConfig(serumMarket: PublicKey): Promise<SerumV3FulfillmentConfigAccount>;
     /**
      * Update the wallet to use for clearing house transactions and linked user account
      * @param newWallet
@@ -65,6 +68,7 @@ export declare class ClearingHouse {
     initializeUserAccount(userId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
     getInitializeUserInstructions(userId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[PublicKey, TransactionInstruction]>;
     getInitializeUserStatsIx(): Promise<TransactionInstruction>;
+    updateUserName(name: string, userId?: number): Promise<TransactionSignature>;
     getUser(userId?: number): ClearingHouseUser;
     getUsers(): ClearingHouseUser[];
     getUserStats(): ClearingHouseUserStats;
@@ -73,17 +77,18 @@ export declare class ClearingHouse {
     getUserAccountPublicKey(): Promise<PublicKey>;
     getUserAccount(userId?: number): UserAccount | undefined;
     getUserAccountAndSlot(userId?: number): DataAndSlot<UserAccount> | undefined;
-    getUserBankBalance(bankIndex: number | BN): UserBankBalance | undefined;
+    getSpotPosition(marketIndex: number | BN): SpotPosition | undefined;
     getQuoteAssetTokenAmount(): BN;
     getRemainingAccounts(params: {
-        writableMarketIndex?: BN;
-        writableBankIndex?: BN;
-        readableMarketIndex?: BN;
+        writablePerpMarketIndex?: BN;
+        writableSpotMarketIndex?: BN;
+        readablePerpMarketIndex?: BN;
+        readableSpotMarketIndex?: BN;
     }): AccountMeta[];
     getOrder(orderId: BN | number): Order | undefined;
     getOrderByUserId(userOrderId: number): Order | undefined;
-    deposit(amount: BN, bankIndex: BN, collateralAccountPublicKey: PublicKey, userId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
-    getDepositInstruction(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, userId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
+    deposit(amount: BN, marketIndex: BN, collateralAccountPublicKey: PublicKey, userId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
+    getDepositInstruction(amount: BN, marketIndex: BN, userTokenAccount: PublicKey, userId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
     private checkIfAccountExists;
     private getSolWithdrawalIxs;
     private getWrappedSolAccountCreationIxs;
@@ -91,20 +96,20 @@ export declare 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
      */
-    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, bankIndex?: BN, userId?: number, name?: string, fromUserId?: number, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(userId: number, name: string, bankIndex: BN, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
-    withdraw(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
-    getWithdrawIx(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
-    transferDeposit(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionSignature>;
-    getTransferDepositIx(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionInstruction>;
-    updateBankCumulativeInterest(bankIndex: BN): Promise<TransactionSignature>;
-    updateBankCumulativeInterestIx(bankIndex: BN): Promise<TransactionInstruction>;
+    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: BN, userId?: number, name?: string, fromUserId?: number, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(userId: number, name: string, marketIndex: BN, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    withdraw(amount: BN, marketIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
+    getWithdrawIx(amount: BN, marketIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
+    transferDeposit(amount: BN, marketIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionSignature>;
+    getTransferDepositIx(amount: BN, marketIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionInstruction>;
+    updateSpotMarketCumulativeInterest(marketIndex: BN): Promise<TransactionSignature>;
+    updateSpotMarketCumulativeInterestIx(marketIndex: BN): Promise<TransactionInstruction>;
     settleLP(settleeUserAccountPublicKey: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
     settleLPIx(settleeUserAccountPublicKey: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
     removeLiquidity(marketIndex: BN, sharesToBurn?: BN): Promise<TransactionSignature>;
@@ -112,19 +117,39 @@ export declare class ClearingHouse {
     addLiquidity(amount: BN, marketIndex: BN): Promise<TransactionSignature>;
     getAddLiquidityIx(amount: BN, marketIndex: BN): Promise<TransactionInstruction>;
     openPosition(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN): Promise<TransactionSignature>;
+    sendSignedTx(tx: Transaction): Promise<TransactionSignature>;
+    /**
+     * 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
+     */
+    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<{
+        txSig: TransactionSignature;
+        signedFillTx: Transaction;
+    }>;
     placeOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
-    getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams;
+    getOrderParams(optionalOrderParams: OptionalOrderParams, marketType: MarketType): OrderParams;
     getPlaceOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
     updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature>;
     getUpdateAMMsIx(marketIndexes: BN[]): Promise<TransactionInstruction>;
+    settleExpiredMarket(marketIndex: BN): Promise<TransactionSignature>;
+    getSettleExpiredMarketIx(marketIndex: BN): Promise<TransactionInstruction>;
     cancelOrder(orderId?: BN): Promise<TransactionSignature>;
     getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
     fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
-    getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    placeSpotOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
+    triggerSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
+    getTriggerSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
     placeAndTake(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
     getPlaceAndTakeIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeAndMake(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
@@ -141,22 +166,24 @@ export declare class ClearingHouse {
     }[], marketIndex: BN): Promise<TransactionSignature>;
     settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
     settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
+    settleExpiredPosition(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
+    getSettleExpiredPositionIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
     liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN, maxBaseAssetAmount: BN): Promise<TransactionSignature>;
     getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN, maxBaseAssetAmount: BN): Promise<TransactionInstruction>;
-    liquidateBorrow(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetBankIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
-    getLiquidateBorrowIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetBankIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
-    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
-    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
-    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionSignature>;
-    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionInstruction>;
-    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN, marketIndex: BN): Promise<TransactionSignature>;
-    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN, marketIndex: BN): Promise<TransactionInstruction>;
-    resolveBorrowBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionSignature>;
-    getResolveBorrowBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionInstruction>;
+    liquidateBorrow(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetmarketIndex: BN, liabilitymarketIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetmarketIndex: BN, liabilitymarketIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilitymarketIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilitymarketIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetMarketIndex: BN, maxPnlTransfer: BN): Promise<TransactionSignature>;
+    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetMarketIndex: BN, maxPnlTransfer: BN): Promise<TransactionInstruction>;
+    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
+    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
+    resolveBorrowBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
+    getResolveBorrowBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
     getRemainingAccountsWithCounterparty(params: {
         counterPartyUserAccount: UserAccount;
-        writableMarketIndex?: BN;
-        writableBankIndexes?: BN[];
+        writablePerpMarketIndex?: BN;
+        writableSpotMarketIndexes?: BN[];
     }): AccountMeta[];
     updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
     getUpdateFundingRateIx(oracle: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
@@ -164,11 +191,13 @@ export declare class ClearingHouse {
     getSettleFundingPaymentIx(userAccount: PublicKey): Promise<TransactionInstruction>;
     triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any): void;
     getOracleDataForMarket(marketIndex: BN): OraclePriceData;
-    initializeInsuranceFundStake(bankIndex: BN): Promise<TransactionSignature>;
-    getInitializeInsuranceFundStakeIx(bankIndex: BN): Promise<TransactionInstruction>;
-    addInsuranceFundStake(bankIndex: BN, amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    requestRemoveInsuranceFundStake(bankIndex: BN, amount: BN): Promise<TransactionSignature>;
-    cancelRequestRemoveInsuranceFundStake(bankIndex: BN): Promise<TransactionSignature>;
-    removeInsuranceFundStake(bankIndex: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    settleRevenueToInsuranceFund(bankIndex: BN): Promise<TransactionSignature>;
+    initializeInsuranceFundStake(marketIndex: BN): Promise<TransactionSignature>;
+    getInitializeInsuranceFundStakeIx(marketIndex: BN): Promise<TransactionInstruction>;
+    addInsuranceFundStake(marketIndex: BN, amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    requestRemoveInsuranceFundStake(marketIndex: BN, amount: BN): Promise<TransactionSignature>;
+    cancelRequestRemoveInsuranceFundStake(marketIndex: BN): Promise<TransactionSignature>;
+    removeInsuranceFundStake(marketIndex: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    settleRevenueToInsuranceFund(marketIndex: BN): Promise<TransactionSignature>;
+    resolvePerpPnlDeficit(spotMarketIndex: BN, perpMarketIndex: BN): Promise<TransactionSignature>;
+    getResolvePerpPnlDeficitIx(spotMarketIndex: BN, perpMarketIndex: BN): Promise<TransactionInstruction>;
 }