@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.5

package/lib/accounts/types.d.ts

@@ -1,6 +1,5 @@
 /// <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,7 +14,7 @@ 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>;
@@ -38,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,
             },
         });
@@ -403,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,26 +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>;
     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>;
     getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
-    placeAndTake(orderParams: OrderParams, makerInfo?: MakerInfo): Promise<TransactionSignature>;
-    getPlaceAndTakeIx(orderParams: OrderParams, makerInfo?: MakerInfo): 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
@@ -482,17 +482,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 +509,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;
@@ -590,54 +582,6 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async cancelAllOrders(bestEffort) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelAllOrdersIx(bestEffort)), [], 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 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;
-            remainingAccounts.push({
-                pubkey: oracle,
-                isWritable: false,
-                isSigner: false,
-            });
-        }
-        return await this.program.instruction.cancelOrdersByMarketAndSide(bestEffort, marketIndexOnly, directionOnly, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                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);
         return txSig;
@@ -646,7 +590,6 @@ class ClearingHouse {
         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,
@@ -674,7 +617,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountInfos.push({
                     pubkey: market.pubkey,
-                    isWritable: false,
+                    isWritable: true,
                     isSigner: false,
                 });
                 oracleAccountInfos.push({
@@ -700,7 +643,6 @@ class ClearingHouse {
                 filler: fillerPublicKey,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
-                oracle: oracle,
             },
             remainingAccounts,
         });
@@ -768,9 +710,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,
@@ -789,7 +730,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,
         });
@@ -804,7 +772,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: '9jwr5nC2f9yAraXrg4UzHXmCX3vi9FQkjD6p9e8bRqNa',
+        CLEARING_HOUSE_PROGRAM_ID: 'BMow898PH56jD8z4EaqxicoGXkR1HhN17qrER6Uc4AYq',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         MARKETS: markets_1.DevnetMarkets,
         BANKS: banks_1.DevnetBanks,