@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.12

package/lib/clearingHouse.d.ts

@@ -72,17 +72,22 @@ export declare class ClearingHouse {
     getRemainingAccounts(params: {
         writableMarketIndex?: BN;
         writableBankIndex?: BN;
+        readableMarketIndex?: 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>;
+    private checkIfAccountExists;
+    private getSolWithdrawalIxs;
+    private getWrappedSolAccountCreationIxs;
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
      * @param amount
      * @param userTokenAccount
+     * @param bankIndex
+     * @param userId
+     * @param name
      * @param fromUserId
      * @returns
      */

package/lib/clearingHouse.js

@@ -44,6 +44,7 @@ const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketC
 const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
 const config_1 = require("./config");
+const banks_1 = require("./constants/banks");
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -284,8 +285,7 @@ class ClearingHouse {
                 marketAccountMap.set(marketIndexNum, {
                     pubkey: marketAccount.pubkey,
                     isSigner: false,
-                    // isWritable: false, // TODO
-                    isWritable: true,
+                    isWritable: false,
                 });
                 oracleAccountMap.set(marketAccount.pubkey.toString(), {
                     pubkey: marketAccount.amm.oracle,
@@ -294,6 +294,19 @@ class ClearingHouse {
                 });
             }
         }
+        if (params.readableMarketIndex) {
+            const marketAccount = this.getMarketAccount(params.readableMarketIndex.toNumber());
+            marketAccountMap.set(params.readableMarketIndex.toNumber(), {
+                pubkey: marketAccount.pubkey,
+                isSigner: false,
+                isWritable: true,
+            });
+            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                pubkey: marketAccount.amm.oracle,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
         if (params.writableMarketIndex) {
             const marketAccount = this.getMarketAccount(params.writableMarketIndex.toNumber());
             marketAccountMap.set(params.writableMarketIndex.toNumber(), {
@@ -355,9 +368,27 @@ class ClearingHouse {
         return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.userOrderId === userOrderId);
     }
     async deposit(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly = false) {
+        const tx = new web3_js_1.Transaction();
+        const additionalSigners = [];
+        const bank = this.getBankAccount(bankIndex);
+        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolBank && collateralAccountPublicKey.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
+            collateralAccountPublicKey = pubkey;
+            ixs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
         const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly, true);
-        const tx = new web3_js_1.Transaction().add(depositCollateralIx);
-        const { txSig } = await this.txSender.send(tx);
+        tx.add(depositCollateralIx);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, collateralAccountPublicKey, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
     async getDepositInstruction(amount, bankIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
@@ -399,24 +430,93 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async checkIfAccountExists(account) {
+        try {
+            const accountInfo = await this.connection.getAccountInfo(account);
+            return accountInfo && true;
+        }
+        catch (e) {
+            // Doesn't already exist
+            return false;
+        }
+    }
+    async getSolWithdrawalIxs(bankIndex, amount) {
+        const result = {
+            ixs: [],
+            signers: [],
+            pubkey: web3_js_1.PublicKey.default,
+        };
+        // Create a temporary wrapped SOL account to store the SOL that we're withdrawing
+        const authority = this.wallet.publicKey;
+        const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
+        result.pubkey = pubkey;
+        ixs.forEach((ix) => {
+            result.ixs.push(ix);
+        });
+        signers.forEach((ix) => {
+            result.signers.push(ix);
+        });
+        const withdrawIx = await this.getWithdrawIx(amount, bankIndex, pubkey, true);
+        result.ixs.push(withdrawIx);
+        result.ixs.push(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, pubkey, authority, authority, []));
+        return result;
+    }
+    async getWrappedSolAccountCreationIxs(amount) {
+        const wrappedSolAccount = new web3_js_1.Keypair();
+        const result = {
+            ixs: [],
+            signers: [],
+            pubkey: wrappedSolAccount.publicKey,
+        };
+        const rentSpaceLamports = new anchor_1.BN(web3_js_1.LAMPORTS_PER_SOL / 100);
+        const depositAmountLamports = amount.add(rentSpaceLamports);
+        const authority = this.wallet.publicKey;
+        result.ixs.push(web3_js_1.SystemProgram.createAccount({
+            fromPubkey: authority,
+            newAccountPubkey: wrappedSolAccount.publicKey,
+            lamports: depositAmountLamports.toNumber(),
+            space: 165,
+            programId: spl_token_1.TOKEN_PROGRAM_ID,
+        }));
+        result.ixs.push(spl_token_1.Token.createInitAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, banks_1.WRAPPED_SOL_MINT, wrappedSolAccount.publicKey, authority));
+        result.signers.push(wrappedSolAccount);
+        return result;
+    }
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
      * @param amount
      * @param userTokenAccount
+     * @param bankIndex
+     * @param userId
+     * @param name
      * @param fromUserId
      * @returns
      */
     async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, bankIndex = new anchor_1.BN(0), userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId) {
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
+        const additionalSigners = [];
+        const bank = this.getBankAccount(bankIndex);
+        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const tx = new web3_js_1.Transaction();
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolBank && userTokenAccount.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs: startIxs, signers, pubkey, } = await this.getWrappedSolAccountCreationIxs(amount);
+            userTokenAccount = pubkey;
+            startIxs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
         const depositCollateralIx = fromUserId != null
             ? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
             : await this.getDepositInstruction(amount, bankIndex, userTokenAccount, userId, false, false);
-        const tx = new web3_js_1.Transaction()
-            .add(initializeUserAccountIx)
-            .add(depositCollateralIx);
-        const { txSig } = await this.txSender.send(tx, []);
+        tx.add(initializeUserAccountIx).add(depositCollateralIx);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return [txSig, userAccountPublicKey];
     }
     async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, bankIndex, tokenFaucet, amount) {
@@ -432,7 +532,27 @@ class ClearingHouse {
         return [txSig, userAccountPublicKey];
     }
     async withdraw(amount, bankIndex, userTokenAccount, reduceOnly = false) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly)), [], this.opts);
+        const tx = new web3_js_1.Transaction();
+        const additionalSigners = [];
+        const bank = this.getBankAccount(bankIndex);
+        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolBank && userTokenAccount.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
+            userTokenAccount = pubkey;
+            ixs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
+        const withdrawCollateral = await this.getWithdrawIx(amount, bank.bankIndex, userTokenAccount, reduceOnly);
+        tx.add(withdrawCollateral);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
     async getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly = false) {
@@ -508,7 +628,7 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: orderParams.marketIndex,
+            readableMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placeOrder(orderParams, {
             accounts: {
@@ -599,23 +719,13 @@ class ClearingHouse {
         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,
+                    isWritable: false,
                 });
                 if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
                     oracleAccountMap.set(bankAccount.oracle.toString(), {
@@ -632,7 +742,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: true,
+                    isWritable: false,
                     isSigner: false,
                 });
                 oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -642,6 +752,16 @@ class ClearingHouse {
                 });
             }
         }
+        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,
+        });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
             ...bankAccountMap.values(),
@@ -677,23 +797,13 @@ class ClearingHouse {
         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,
+                    isWritable: false,
                 });
                 if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
                     oracleAccountMap.set(bankAccount.oracle.toString(), {
@@ -710,7 +820,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: true,
+                    isWritable: false,
                     isSigner: false,
                 });
                 oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -720,6 +830,16 @@ class ClearingHouse {
                 });
             }
         }
+        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,
+        });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
             ...bankAccountMap.values(),
@@ -834,7 +954,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: true,
+                    isWritable: false,
                     isSigner: false,
                 });
                 oracleAccountMap.set(market.amm.oracle.toString(), {

package/lib/clearingHouseUser.d.ts

@@ -61,48 +61,43 @@ export declare class ClearingHouseUser {
     getFreeCollateral(): BN;
     getInitialMarginRequirement(): BN;
     /**
-     * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
      */
     getMaintenanceMarginRequirement(): BN;
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN;
-    /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getUnsettledPNL(marketIndex?: BN): BN;
+    getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates unrealized funding payment pnl
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex?: BN): BN;
-    getTotalLiability(): BN;
-    getCollateralValue(bankIndex?: BN): BN;
+    getBankLiabilityValue(bankIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
+    getBankAssetValue(bankIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
+    getNetBankValue(withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
-     * TODO: rename to total equity (for perpetuals swaps)
      * @returns : Precision QUOTE_PRECISION
      */
-    getTotalCollateral(): BN;
+    getTotalCollateral(marginCategory?: MarginCategory): BN;
     /**
-     * calculates sum of position value across all positions
+     * calculates sum of position value across all positions in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalPositionValue(): BN;
     /**
-     * calculates position value from closing 100%
+     * calculates position value in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getPositionValue(marketIndex: BN, oraclePriceData: OraclePriceData): BN;
     getPositionSide(currentPosition: Pick<UserPosition, 'baseAssetAmount'>): PositionDirection | undefined;
     /**
-     * calculates average exit price for closing 100% of position
+     * calculates average exit price (optionally for closing up to 100% of position)
      * @returns : Precision MARK_PRICE_PRECISION
      */
-    getPositionEstimatedExitPriceAndPnl(position: UserPosition, amountToClose?: BN): [BN, BN];
+    getPositionEstimatedExitPriceAndPnl(position: UserPosition, amountToClose?: BN, useAMMClose?: boolean): [BN, BN];
     /**
      * calculates current user leverage across all positions
      * @returns : Precision TEN_THOUSAND