@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.10

package/lib/accounts/types.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
+/// <reference types="node" />
 import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';

package/lib/admin.d.ts

@@ -5,7 +5,7 @@ import { BN } from '@project-serum/anchor';
 import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
     initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature]>;
-    initializeBank(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN): Promise<TransactionSignature>;
+    initializeBank(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN): Promise<TransactionSignature>;
     initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioPartial?: number, marginRatioMaintenance?: number): Promise<TransactionSignature>;
     moveAmmPrice(baseAssetReserve: BN, quoteAssetReserve: BN, marketIndex: BN): Promise<TransactionSignature>;
     updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
@@ -14,12 +14,13 @@ export declare class Admin extends ClearingHouse {
     updateAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
     resetAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
     withdrawFromInsuranceVault(amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFees(marketIndex: BN, amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
+    withdrawFromMarketToInsuranceVault(marketIndex: BN, amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
     withdrawFromInsuranceVaultToMarket(marketIndex: BN, amount: BN): Promise<TransactionSignature>;
     updateAdmin(admin: PublicKey): Promise<TransactionSignature>;
     updateCurveUpdateIntensity(marketIndex: BN, curveUpdateIntensity: number): Promise<TransactionSignature>;
     updateMarginRatio(marketIndex: BN, marginRatioInitial: number, marginRatioPartial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
     updateMarketBaseSpread(marketIndex: BN, baseSpread: number): Promise<TransactionSignature>;
+    updateMarketMaxSpread(marketIndex: BN, maxSpread: number): Promise<TransactionSignature>;
     updatePartialLiquidationClosePercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updatePartialLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updateFullLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
@@ -37,5 +38,7 @@ export declare class Admin extends ClearingHouse {
     updateFundingPaused(fundingPaused: boolean): Promise<TransactionSignature>;
     updateExchangePaused(exchangePaused: boolean): Promise<TransactionSignature>;
     disableAdminControlsPrices(): Promise<TransactionSignature>;
-    updateOrderAuctionTime(time: BN | number): Promise<TransactionSignature>;
+    updateAuctionDuration(minDuration: BN | number, maxDuration: BN | number): Promise<TransactionSignature>;
+    updateMaxBaseAssetAmountRatio(marketIndex: BN, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
+    updateMaxSlippageRatio(marketIndex: BN, maxSlippageRatio: number): Promise<TransactionSignature>;
 }

package/lib/admin.js

@@ -58,12 +58,12 @@ 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) {
+    async initializeBank(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0)) {
         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 initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, {
+        const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -177,10 +177,12 @@ class Admin extends clearingHouse_1.ClearingHouse {
     }
     async withdrawFromInsuranceVault(amount, recipient) {
         const state = await this.getStateAccount();
+        const bank = this.getQuoteAssetBankAccount();
         return await this.program.rpc.withdrawFromInsuranceVault(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
                 insuranceVault: state.insuranceVault,
                 insuranceVaultAuthority: state.insuranceVaultAuthority,
                 recipient: recipient,
@@ -188,10 +190,10 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async withdrawFees(marketIndex, amount, recipient) {
+    async withdrawFromMarketToInsuranceVault(marketIndex, amount, recipient) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
         const bank = this.getQuoteAssetBankAccount();
-        return await this.program.rpc.withdrawFees(amount, {
+        return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -206,6 +208,7 @@ class Admin extends clearingHouse_1.ClearingHouse {
     }
     async withdrawFromInsuranceVaultToMarket(marketIndex, amount) {
         const state = await this.getStateAccount();
+        const bank = this.getQuoteAssetBankAccount();
         return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
@@ -213,7 +216,9 @@ class Admin extends clearingHouse_1.ClearingHouse {
                 market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
                 insuranceVault: state.insuranceVault,
                 insuranceVaultAuthority: state.insuranceVaultAuthority,
-                bankVault: this.getQuoteAssetBankAccount().vault,
+                bank: bank.pubkey,
+                bankVault: bank.vault,
+                bankVaultAuthority: bank.vaultAuthority,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
@@ -255,6 +260,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateMarketMaxSpread(marketIndex, maxSpread) {
+        return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
     async updatePartialLiquidationClosePercentage(numerator, denominator) {
         return await this.program.rpc.updatePartialLiquidationClosePercentage(numerator, denominator, {
             accounts: {
@@ -394,11 +408,29 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateOrderAuctionTime(time) {
-        return await this.program.rpc.updateOrderAuctionTime(typeof time === 'number' ? time : time.toNumber, {
+    async updateAuctionDuration(minDuration, maxDuration) {
+        return await this.program.rpc.updateAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(), {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateMaxBaseAssetAmountRatio(marketIndex, maxBaseAssetAmountRatio) {
+        return await this.program.rpc.updateMaxBaseAssetAmountRatio(maxBaseAssetAmountRatio, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: this.getMarketAccount(marketIndex).pubkey,
+            },
+        });
+    }
+    async updateMaxSlippageRatio(marketIndex, maxSlippageRatio) {
+        return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                market: this.getMarketAccount(marketIndex).pubkey,
             },
         });
     }

package/lib/clearingHouse.d.ts

@@ -1,7 +1,7 @@
 /// <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 } from './types';
+import { StateAccount, IWallet, PositionDirection, UserAccount, MarketAccount, OrderParams, Order, BankAccount, UserBankBalance, MakerInfo, TakerInfo, OptionalOrderParams } from './types';
 import { Connection, PublicKey, TransactionSignature, ConfirmOptions, TransactionInstruction, AccountMeta } from '@solana/web3.js';
 import { MockUSDCFaucet } from './mockUSDCFaucet';
 import { EventEmitter } from 'events';
@@ -95,24 +95,23 @@ export declare class ClearingHouse {
     updateBankCumulativeInterest(bankIndex: BN): Promise<TransactionSignature>;
     updateBankCumulativeInterestIx(bankIndex: BN): Promise<TransactionInstruction>;
     openPosition(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN): Promise<TransactionSignature>;
-    placeOrder(orderParams: OrderParams): Promise<TransactionSignature>;
-    getPlaceOrderIx(orderParams: OrderParams): Promise<TransactionInstruction>;
-    expireOrders(userAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getExpireOrdersIx(userAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    placeOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
+    getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams;
+    getPlaceOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
     updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature>;
     getUpdateAMMsIx(marketIndexes: BN[]): Promise<TransactionInstruction>;
-    cancelOrder(orderId: BN): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId: BN): Promise<TransactionInstruction>;
+    cancelOrder(orderId?: BN): Promise<TransactionSignature>;
+    getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
-    cancelAllOrders(bestEffort?: boolean): Promise<TransactionSignature>;
-    getCancelAllOrdersIx(bestEffort?: boolean): Promise<TransactionInstruction>;
-    cancelOrdersByMarketAndSide(bestEffort?: boolean, marketIndexOnly?: BN, directionOnly?: PositionDirection): Promise<TransactionSignature>;
-    getCancelOrdersByMarketAndSideIx(bestEffort?: boolean, marketIndexOnly?: BN, directionOnly?: PositionDirection): Promise<TransactionInstruction>;
-    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order, makerInfo?: MakerInfo): Promise<TransactionSignature>;
+    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, makerInfo?: MakerInfo): Promise<TransactionSignature>;
     getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
-    placeAndTake(orderParams: OrderParams, makerInfo?: MakerInfo): Promise<TransactionSignature>;
-    getPlaceAndTakeIx(orderParams: OrderParams, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
+    triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
+    getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
+    placeAndTake(orderParams: OptionalOrderParams, makerInfo?: MakerInfo): Promise<TransactionSignature>;
+    getPlaceAndTakeIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
+    placeAndMake(orderParams: OptionalOrderParams, takerInfo: TakerInfo): Promise<TransactionSignature>;
+    getPlaceAndMakeIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo): Promise<TransactionInstruction>;
     /**
      * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
      * @param marketIndex

package/lib/clearingHouse.js

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClearingHouse = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const spl_token_1 = require("@solana/spl-token");
+const types_1 = require("./types");
 const anchor = __importStar(require("@project-serum/anchor"));
 const clearing_house_json_1 = __importDefault(require("./idl/clearing_house.json"));
 const web3_js_1 = require("@solana/web3.js");
@@ -42,7 +43,6 @@ const pollingClearingHouseAccountSubscriber_1 = require("./accounts/pollingClear
 const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketClearingHouseAccountSubscriber");
 const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
-const orderParams_1 = require("./orderParams");
 const config_1 = require("./config");
 /**
  * # ClearingHouse
@@ -371,13 +371,19 @@ class ClearingHouse {
             });
         }
         else {
-            remainingAccounts = [
-                {
-                    pubkey: this.getBankAccount(bankIndex).pubkey,
+            const bankAccount = this.getBankAccount(bankIndex);
+            if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                remainingAccounts.push({
+                    pubkey: bankAccount.oracle,
                     isSigner: false,
-                    isWritable: true,
-                },
-            ];
+                    isWritable: false,
+                });
+            }
+            remainingAccounts.push({
+                pubkey: bankAccount.pubkey,
+                isSigner: false,
+                isWritable: true,
+            });
         }
         const bank = this.getBankAccount(bankIndex);
         return await this.program.instruction.deposit(bankIndex, amount, reduceOnly, {
@@ -482,17 +488,25 @@ class ClearingHouse {
         });
     }
     async openPosition(direction, amount, marketIndex, limitPrice) {
-        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, direction, numericConstants_1.ZERO, amount, false, limitPrice));
+        return await this.placeAndTake({
+            orderType: types_1.OrderType.MARKET,
+            marketIndex,
+            direction,
+            baseAssetAmount: amount,
+            price: limitPrice,
+        });
     }
     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);
+    }
     async getPlaceOrderIx(orderParams) {
+        orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-            .oracle;
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
         });
@@ -501,26 +515,10 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
-                oracle: priceOracle,
             },
             remainingAccounts,
         });
     }
-    async expireOrders(userAccountPublicKey) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getExpireOrdersIx(userAccountPublicKey)), [], this.opts);
-        return txSig;
-    }
-    async getExpireOrdersIx(userAccountPublicKey) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
-        return await this.program.instruction.expireOrders({
-            accounts: {
-                state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-            },
-        });
-    }
     async updateAMMs(marketIndexes) {
         const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateAMMsIx(marketIndexes)), [], this.opts);
         return txSig;
@@ -561,15 +559,12 @@ class ClearingHouse {
     }
     async getCancelOrderIx(orderId) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const order = this.getOrder(orderId);
-        const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
         const remainingAccounts = this.getRemainingAccounts({});
-        return await this.program.instruction.cancelOrder(orderId, {
+        return await this.program.instruction.cancelOrder(orderId !== null && orderId !== void 0 ? orderId : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
-                oracle,
             },
             remainingAccounts,
         });
@@ -593,117 +588,150 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async cancelAllOrders(bestEffort) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelAllOrdersIx(bestEffort)), [], this.opts);
+    async fillOrder(userAccountPublicKey, user, order, makerInfo) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)), [], this.opts);
         return txSig;
     }
-    async getCancelAllOrdersIx(bestEffort) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccounts({});
-        for (const order of this.getUserAccount().orders) {
-            const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-            remainingAccounts.push({
-                pubkey: oracle,
-                isWritable: false,
-                isSigner: false,
-            });
-        }
-        return await this.program.instruction.cancelAllOrders(bestEffort, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-            },
-            remainingAccounts,
+    async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const marketIndex = order.marketIndex;
+        const marketAccount = this.getMarketAccount(marketIndex);
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        marketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: marketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
         });
-    }
-    async cancelOrdersByMarketAndSide(bestEffort, marketIndexOnly, directionOnly) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrdersByMarketAndSideIx(bestEffort, marketIndexOnly, directionOnly)), [], this.opts);
-        return txSig;
-    }
-    async getCancelOrdersByMarketAndSideIx(bestEffort, marketIndexOnly, directionOnly) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccounts({});
-        for (const order of this.getUserAccount().orders) {
-            const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+            pubkey: marketAccount.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        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,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
+        for (const position of userAccount.positions) {
+            if (!(0, position_1.positionIsAvailable)(position) &&
+                !position.marketIndex.eq(order.marketIndex)) {
+                const market = this.getMarketAccount(position.marketIndex);
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: true,
+                    isSigner: false,
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
+        if (makerInfo) {
             remainingAccounts.push({
-                pubkey: oracle,
-                isWritable: false,
+                pubkey: makerInfo.maker,
+                isWritable: true,
                 isSigner: false,
             });
         }
-        return await this.program.instruction.cancelOrdersByMarketAndSide(bestEffort, marketIndexOnly, directionOnly, {
+        const orderId = order.orderId;
+        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+        return await this.program.instruction.fillOrder(orderId, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async fillOrder(userAccountPublicKey, user, order, makerInfo) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)), [], this.opts);
+    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;
     }
-    async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo) {
+    async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
         const fillerPublicKey = await this.getUserAccountPublicKey();
         const marketIndex = order.marketIndex;
         const marketAccount = this.getMarketAccount(marketIndex);
-        const oracle = marketAccount.amm.oracle;
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
-            },
-        ];
-        const marketAccountInfos = [
-            {
-                pubkey: marketAccount.pubkey,
-                isWritable: true,
-                isSigner: false,
-            },
-        ];
-        const oracleAccountInfos = [
-            {
-                pubkey: marketAccount.amm.oracle,
-                isWritable: false,
-                isSigner: false,
-            },
-        ];
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        marketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: marketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+            pubkey: marketAccount.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        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,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
         for (const position of userAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position) &&
                 !position.marketIndex.eq(order.marketIndex)) {
                 const market = this.getMarketAccount(position.marketIndex);
-                marketAccountInfos.push({
+                marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: false,
+                    isWritable: true,
                     isSigner: false,
                 });
-                oracleAccountInfos.push({
+                oracleAccountMap.set(market.amm.oracle.toString(), {
                     pubkey: market.amm.oracle,
                     isWritable: false,
                     isSigner: false,
                 });
             }
         }
-        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
-        if (makerInfo) {
-            remainingAccounts.push({
-                pubkey: makerInfo.maker,
-                isWritable: true,
-                isSigner: false,
-            });
-        }
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
         const orderId = order.orderId;
-        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
-        return await this.program.instruction.fillOrder(orderId, makerOrderId, {
+        return await this.program.instruction.triggerOrder(orderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 filler: fillerPublicKey,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
-                oracle: oracle,
             },
             remainingAccounts,
         });
@@ -714,9 +742,8 @@ class ClearingHouse {
         return txSig;
     }
     async getPlaceAndTakeIx(orderParams, makerInfo) {
+        orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-            .oracle;
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
             writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
@@ -735,7 +762,34 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
-                oracle: priceOracle,
+            },
+            remainingAccounts,
+        });
+    }
+    async placeAndMake(orderParams, takerInfo) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakeIx(orderParams, takerInfo)), [], this.opts);
+        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+        return txSig;
+    }
+    async getPlaceAndMakeIx(orderParams, takerInfo) {
+        orderParams = this.getOrderParams(orderParams);
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            writableMarketIndex: orderParams.marketIndex,
+            writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
+        });
+        const takerOrderId = takerInfo.order.orderId;
+        remainingAccounts.push({
+            pubkey: takerInfo.taker,
+            isSigner: false,
+            isWritable: true,
+        });
+        return await this.program.instruction.placeAndMake(orderParams, takerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                taker: takerInfo.taker,
+                authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
@@ -750,7 +804,13 @@ class ClearingHouse {
         if (!userPosition) {
             throw Error(`No position in market ${marketIndex.toString()}`);
         }
-        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, (0, position_1.findDirectionToClose)(userPosition), numericConstants_1.ZERO, userPosition.baseAssetAmount, true, undefined));
+        return await this.placeAndTake({
+            orderType: types_1.OrderType.MARKET,
+            marketIndex,
+            direction: (0, position_1.findDirectionToClose)(userPosition),
+            baseAssetAmount: userPosition.baseAssetAmount,
+            reduceOnly: true,
+        });
     }
     async settlePNLs(users, marketIndex) {
         const ixs = [];

package/lib/config.js

@@ -7,7 +7,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: 'GCuH76fb1rXc7bjFXNcnNvWSekLgzpsnMbc1Ng4FsGSs',
+        CLEARING_HOUSE_PROGRAM_ID: 'BMow898PH56jD8z4EaqxicoGXkR1HhN17qrER6Uc4AYq',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         MARKETS: markets_1.DevnetMarkets,
         BANKS: banks_1.DevnetBanks,

package/lib/constants/banks.js

@@ -12,8 +12,15 @@ exports.DevnetBanks = [
         mint: new web3_js_1.PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
     },
     {
-        symbol: 'BTC',
+        symbol: 'SOL',
         bankIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey('So11111111111111111111111111111111111111112'),
+    },
+    {
+        symbol: 'BTC',
+        bankIndex: new __1.BN(2),
         oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
         oracleSource: __1.OracleSource.PYTH,
         mint: new web3_js_1.PublicKey('Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr'),

package/lib/constants/numericConstants.d.ts

@@ -29,6 +29,7 @@ export declare const AMM_RESERVE_PRECISION: BN;
 export declare const BASE_PRECISION: BN;
 export declare const BASE_PRECISION_EXP: BN;
 export declare const AMM_TO_QUOTE_PRECISION_RATIO: BN;
+export declare const PRICE_DIV_PEG: BN;
 export declare const PRICE_TO_QUOTE_PRECISION: BN;
 export declare const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO: BN;
 export declare const MARGIN_PRECISION: BN;

package/lib/constants/numericConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QUOTE_ASSET_BANK_INDEX = exports.ONE_YEAR = exports.BID_ASK_SPREAD_PRECISION = exports.MARGIN_PRECISION = exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.PRICE_TO_QUOTE_PRECISION = exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.BASE_PRECISION_EXP = exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION = exports.PEG_PRECISION = exports.FUNDING_PAYMENT_PRECISION = exports.MARK_PRICE_PRECISION = exports.QUOTE_PRECISION = exports.BANK_BALANCE_PRECISION = exports.BANK_BALANCE_PRECISION_EXP = exports.BANK_WEIGHT_PRECISION = exports.BANK_RATE_PRECISION = exports.BANK_UTILIZATION_PRECISION = exports.BANK_CUMULATIVE_INTEREST_PRECISION = exports.BANK_INTEREST_PRECISION = exports.AMM_RESERVE_PRECISION_EXP = exports.PEG_PRECISION_EXP = exports.FUNDING_RATE_PRECISION_EXP = exports.MARK_PRICE_PRECISION_EXP = exports.FUNDING_PAYMENT_PRECISION_EXP = exports.QUOTE_PRECISION_EXP = exports.MAX_LEVERAGE = exports.TEN_MILLION = exports.BN_MAX = exports.TEN_THOUSAND = exports.TEN = exports.TWO = exports.ONE = exports.ZERO = void 0;
+exports.QUOTE_ASSET_BANK_INDEX = exports.ONE_YEAR = exports.BID_ASK_SPREAD_PRECISION = exports.MARGIN_PRECISION = exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.PRICE_TO_QUOTE_PRECISION = exports.PRICE_DIV_PEG = exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.BASE_PRECISION_EXP = exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION = exports.PEG_PRECISION = exports.FUNDING_PAYMENT_PRECISION = exports.MARK_PRICE_PRECISION = exports.QUOTE_PRECISION = exports.BANK_BALANCE_PRECISION = exports.BANK_BALANCE_PRECISION_EXP = exports.BANK_WEIGHT_PRECISION = exports.BANK_RATE_PRECISION = exports.BANK_UTILIZATION_PRECISION = exports.BANK_CUMULATIVE_INTEREST_PRECISION = exports.BANK_INTEREST_PRECISION = exports.AMM_RESERVE_PRECISION_EXP = exports.PEG_PRECISION_EXP = exports.FUNDING_RATE_PRECISION_EXP = exports.MARK_PRICE_PRECISION_EXP = exports.FUNDING_PAYMENT_PRECISION_EXP = exports.QUOTE_PRECISION_EXP = exports.MAX_LEVERAGE = exports.TEN_MILLION = exports.BN_MAX = exports.TEN_THOUSAND = exports.TEN = exports.TWO = exports.ONE = exports.ZERO = void 0;
 const __1 = require("../");
 exports.ZERO = new __1.BN(0);
 exports.ONE = new __1.BN(1);
@@ -31,6 +31,7 @@ exports.AMM_RESERVE_PRECISION = new __1.BN(10).pow(exports.AMM_RESERVE_PRECISION
 exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION;
 exports.BASE_PRECISION_EXP = exports.AMM_RESERVE_PRECISION_EXP;
 exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.AMM_RESERVE_PRECISION.div(exports.QUOTE_PRECISION); // 10^7
+exports.PRICE_DIV_PEG = exports.MARK_PRICE_PRECISION.div(exports.PEG_PRECISION); //10^7
 exports.PRICE_TO_QUOTE_PRECISION = exports.MARK_PRICE_PRECISION.div(exports.QUOTE_PRECISION);
 exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.AMM_RESERVE_PRECISION.mul(exports.PEG_PRECISION).div(exports.QUOTE_PRECISION); // 10^10
 exports.MARGIN_PRECISION = exports.TEN_THOUSAND;