@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.6

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,8 +95,9 @@ 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>;
+    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>;
@@ -107,8 +108,10 @@ export declare class ClearingHouse {
     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
@@ -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,14 +488,24 @@ 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 remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
@@ -580,44 +596,57 @@ class ClearingHouse {
         const fillerPublicKey = await this.getUserAccountPublicKey();
         const marketIndex = order.marketIndex;
         const marketAccount = this.getMarketAccount(marketIndex);
-        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: false,
+                });
+                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));
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
         if (makerInfo) {
             remainingAccounts.push({
                 pubkey: makerInfo.maker,
@@ -700,6 +729,7 @@ class ClearingHouse {
         return txSig;
     }
     async getPlaceAndTakeIx(orderParams, makerInfo) {
+        orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
@@ -723,6 +753,34 @@ class ClearingHouse {
             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,
+        });
+    }
     /**
      * 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
@@ -733,7 +791,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,