@drift-labs/sdk 0.2.0-master.9 → 0.2.0-temp.2

package/lib/admin.d.ts

@@ -5,8 +5,8 @@ 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, 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>;
+    initializeBank(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN): Promise<TransactionSignature>;
+    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN): Promise<TransactionSignature>;
     moveAmmPrice(baseAssetReserve: BN, quoteAssetReserve: BN, marketIndex: BN): Promise<TransactionSignature>;
     updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
     moveAmmToPrice(marketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;
@@ -18,7 +18,7 @@ export declare class Admin extends ClearingHouse {
     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>;
+    updateMarginRatio(marketIndex: BN, marginRatioInitial: 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>;

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, imfFactor = new anchor_1.BN(0)) {
+    async initializeBank(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO) {
         const bankIndex = this.getStateAccount().numberOfBanks;
         const bank = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
         const bankVault = await (0, pda_1.getBankVaultPublicKey)(this.program.programId, bankIndex);
         const bankVaultAuthority = await (0, pda_1.getBankVaultAuthorityPublicKey)(this.program.programId, bankIndex);
-        const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
+        const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -85,9 +85,9 @@ class Admin extends clearingHouse_1.ClearingHouse {
         });
         return txSig;
     }
-    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioPartial = 625, marginRatioMaintenance = 500) {
+    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
-        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
+        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -242,8 +242,8 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioPartial, marginRatioMaintenance) {
-        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioPartial, marginRatioMaintenance, {
+    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioMaintenance) {
+        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioMaintenance, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),

package/lib/clearingHouse.d.ts

@@ -3,7 +3,7 @@
 import { AnchorProvider, BN, Program } from '@project-serum/anchor';
 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 { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './accounts/types';
@@ -87,7 +87,7 @@ export declare class ClearingHouse {
      * @returns
      */
     initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, bankIndex?: BN, userId?: number, name?: string, fromUserId?: number): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(userId: number, name: string, mockUSDCFaucet: MockUSDCFaucet, amount: BN): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(userId: number, name: string, bankIndex: BN, tokenFaucet: TokenFaucet, amount: BN): Promise<[TransactionSignature, PublicKey]>;
     withdraw(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
     getWithdrawIx(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
     transferDeposit(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionSignature>;
@@ -124,8 +124,19 @@ export declare class ClearingHouse {
     }[], marketIndex: BN): Promise<TransactionSignature>;
     settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
     settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
-    liquidate(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getLiquidateIx(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN, maxBaseAssetAmount: BN): Promise<TransactionSignature>;
+    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN, maxBaseAssetAmount: BN): Promise<TransactionInstruction>;
+    liquidateBorrow(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetBankIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetBankIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionSignature>;
+    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionInstruction>;
+    getRemainingAccountsForLiquidation(params: {
+        userAccount: UserAccount;
+        writableMarketIndex?: BN;
+        writableBankIndexes?: BN[];
+    }): AccountMeta[];
     updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
     getUpdateFundingRateIx(oracle: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
     settleFundingPayment(userAccount: PublicKey): Promise<TransactionSignature>;

package/lib/clearingHouse.js

@@ -419,10 +419,10 @@ class ClearingHouse {
         const { txSig } = await this.txSender.send(tx, []);
         return [txSig, userAccountPublicKey];
     }
-    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, mockUSDCFaucet, amount) {
-        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
+    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, bankIndex, tokenFaucet, amount) {
+        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
-        const depositCollateralIx = await this.getDepositInstruction(amount, new anchor_1.BN(0), associateTokenPublicKey, userId, false, false);
+        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, associateTokenPublicKey, userId, false, false);
         const tx = new web3_js_1.Transaction()
             .add(createAssociatedAccountIx)
             .add(mintToIx)
@@ -891,54 +891,217 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidate(liquidateeUserAccountPublicKey) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);
+    async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)), [], this.opts);
         return txSig;
     }
-    async getLiquidateIx(liquidateeUserAccountPublicKey) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const liquidateeUserAccount = (await this.program.account.user.fetch(liquidateeUserAccountPublicKey));
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
+    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+            writableMarketIndex: marketIndex,
+            userAccount,
+        });
+        return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                liquidator: liquidatorPublicKey,
             },
-        ];
-        const marketAccountInfos = [];
-        const oracleAccountInfos = [];
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async liquidateBorrow(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer)), [], this.opts);
+        return txSig;
+    }
+    async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+            userAccount,
+            writableBankIndexes: [liabilityBankIndex, assetBankIndex],
+        });
+        return await this.program.instruction.liquidateBorrow(assetBankIndex, liabilityBankIndex, maxLiabilityTransfer, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                liquidator: liquidatorPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer)), [], this.opts);
+        return txSig;
+    }
+    async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+            userAccount,
+            writableMarketIndex: perpMarketIndex,
+            writableBankIndexes: [liabilityBankIndex],
+        });
+        return await this.program.instruction.liquidateBorrowForPerpPnl(perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                liquidator: liquidatorPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer)), [], this.opts);
+        return txSig;
+    }
+    async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+            userAccount,
+            writableMarketIndex: perpMarketIndex,
+            writableBankIndexes: [assetBankIndex],
+        });
+        return await this.program.instruction.liquidatePerpPnlForDeposit(perpMarketIndex, assetBankIndex, maxPnlTransfer, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                liquidator: liquidatorPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    getRemainingAccountsForLiquidation(params) {
+        const liquidateeUserAccount = params.userAccount;
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        for (const bankBalance of liquidateeUserAccount.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 liquidateeUserAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
                 const market = this.getMarketAccount(position.marketIndex);
-                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
-                marketAccountInfos.push({
-                    pubkey: marketPublicKey,
-                    isWritable: true,
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
                     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 state = this.getStateAccount();
-        const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
-        return await this.program.instruction.liquidate({
-            accounts: {
-                state: await this.getStatePublicKey(),
-                authority: this.wallet.publicKey,
-                user: liquidateeUserAccountPublicKey,
-                liquidator: userAccountPublicKey,
-                bankVault: quoteAssetBankAccount.vault,
-                bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
-                insuranceVault: state.insuranceVault,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-            remainingAccounts: remainingAccounts,
-        });
+        const userAccountAndSlot = this.getUserAccountAndSlot();
+        if (!userAccountAndSlot) {
+            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
+        }
+        const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
+        for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
+            // if cache has more recent slot than user positions account slot, add market to remaining accounts
+            // otherwise remove from slot
+            if (slot > lastUserPositionsSlot) {
+                const marketAccount = this.getMarketAccount(marketIndexNum);
+                marketAccountMap.set(marketIndexNum, {
+                    pubkey: marketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false,
+                });
+                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                    pubkey: marketAccount.amm.oracle,
+                    isSigner: false,
+                    isWritable: false,
+                });
+            }
+            else {
+                this.marketLastSlotCache.delete(marketIndexNum);
+            }
+        }
+        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)) {
+                const market = this.getMarketAccount(position.marketIndex);
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
+                    isSigner: false,
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        if (params.writableMarketIndex) {
+            const market = this.getMarketAccount(params.writableMarketIndex);
+            marketAccountMap.set(market.marketIndex.toNumber(), {
+                pubkey: market.pubkey,
+                isSigner: false,
+                isWritable: true,
+            });
+            oracleAccountMap.set(market.amm.oracle.toString(), {
+                pubkey: market.amm.oracle,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
+        if (params.writableBankIndexes) {
+            for (const writableBankIndex of params.writableBankIndexes) {
+                const bank = this.getBankAccount(writableBankIndex);
+                bankAccountMap.set(bank.bankIndex.toNumber(), {
+                    pubkey: bank.pubkey,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                if (!bank.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(bank.oracle.toString(), {
+                        pubkey: bank.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
+        return [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
     }
     async updateFundingRate(oracle, marketIndex) {
         const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateFundingRateIx(oracle, marketIndex)), [], this.opts);

package/lib/clearingHouseUser.d.ts

@@ -63,7 +63,7 @@ export declare class ClearingHouseUser {
     /**
      * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getPartialMarginRequirement(): BN;
+    getMaintenanceMarginRequirement(): BN;
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
@@ -132,7 +132,7 @@ export declare class ClearingHouseUser {
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPrice(marketPosition: Pick<UserPosition, 'marketIndex'>, positionBaseSizeChange?: BN, partial?: boolean): BN;
+    liquidationPrice(marketPosition: Pick<UserPosition, 'marketIndex'>, positionBaseSizeChange?: BN): BN;
     /**
      * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
      * @param positionMarketIndex

package/lib/clearingHouseUser.js

@@ -126,12 +126,12 @@ class ClearingHouseUser {
     /**
      * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getPartialMarginRequirement() {
+    getMaintenanceMarginRequirement() {
         return this.getUserAccount()
             .positions.reduce((marginRequirement, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
             return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex))
-                .mul(new _1.BN(market.marginRatioPartial))
+                .mul(new _1.BN(market.marginRatioMaintenance))
                 .div(numericConstants_1.MARGIN_PRECISION));
         }, numericConstants_1.ZERO)
             .add(this.getTotalLiability());
@@ -319,9 +319,6 @@ class ClearingHouseUser {
             case 'Maintenance':
                 marginRatioCategory = market.marginRatioMaintenance;
                 break;
-            case 'Partial':
-                marginRatioCategory = market.marginRatioPartial;
-                break;
             default:
                 marginRatioCategory = market.marginRatioInitial;
                 break;
@@ -342,7 +339,7 @@ class ClearingHouseUser {
     }
     canBeLiquidated() {
         const totalCollateral = this.getTotalCollateral();
-        const partialMaintenanceRequirement = this.getPartialMarginRequirement();
+        const partialMaintenanceRequirement = this.getMaintenanceMarginRequirement();
         const marginRatio = this.getMarginRatio();
         const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
         return [canLiquidate, marginRatio];
@@ -372,7 +369,7 @@ class ClearingHouseUser {
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
+    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO) {
         // solves formula for example canBeLiquidated below
         /* example: assume BTC price is $40k (examine 10% up/down)
 
@@ -413,9 +410,7 @@ class ClearingHouseUser {
                 const market = this.clearingHouse.getMarketAccount(position.marketIndex);
                 const positionValue = (0, _1.calculateBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
-                    .mul(partial
-                    ? new _1.BN(market.marginRatioPartial)
-                    : new _1.BN(market.marginRatioMaintenance))
+                    .mul(new _1.BN(market.marginRatioMaintenance))
                     .div(numericConstants_1.MARGIN_PRECISION);
                 totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
             }
@@ -428,14 +423,10 @@ class ClearingHouseUser {
             return new _1.BN(-1);
         }
         const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedMarketPositionValue
-            .mul(partial
-            ? new _1.BN(market.marginRatioPartial)
-            : new _1.BN(market.marginRatioMaintenance))
+            .mul(new _1.BN(market.marginRatioMaintenance))
             .div(numericConstants_1.MARGIN_PRECISION));
         const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
-        const marketMaxLeverage = partial
-            ? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-            : this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+        const marketMaxLeverage = this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
         let priceDelta;
         if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
             priceDelta = freeCollateralAfterTrade
@@ -486,7 +477,7 @@ class ClearingHouseUser {
             .neg();
         return this.liquidationPrice({
             marketIndex: positionMarketIndex,
-        }, closeBaseAmount, true);
+        }, closeBaseAmount);
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.

package/lib/config.js

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

package/lib/constants/banks.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Banks = exports.MainnetBanks = exports.DevnetBanks = void 0;
 const __1 = require("../");
 const web3_js_1 = require("@solana/web3.js");
-const token_instructions_1 = require("@project-serum/serum/lib/token-instructions");
 exports.DevnetBanks = [
     {
         symbol: 'USDC',
@@ -17,14 +16,14 @@ exports.DevnetBanks = [
         bankIndex: new __1.BN(1),
         oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
         oracleSource: __1.OracleSource.PYTH,
-        mint: token_instructions_1.WRAPPED_SOL_MINT,
+        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'),
+        mint: new web3_js_1.PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
     },
 ];
 exports.MainnetBanks = [

package/lib/constants/numericConstants.d.ts

@@ -21,6 +21,7 @@ export declare const BANK_RATE_PRECISION: BN;
 export declare const BANK_WEIGHT_PRECISION: BN;
 export declare const BANK_BALANCE_PRECISION_EXP: BN;
 export declare const BANK_BALANCE_PRECISION: BN;
+export declare const LIQUIDATION_FEE_PRECISION: BN;
 export declare const QUOTE_PRECISION: BN;
 export declare const MARK_PRICE_PRECISION: BN;
 export declare const FUNDING_PAYMENT_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.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;
+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.LIQUIDATION_FEE_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);
@@ -23,6 +23,7 @@ exports.BANK_RATE_PRECISION = new __1.BN(1000000);
 exports.BANK_WEIGHT_PRECISION = new __1.BN(100);
 exports.BANK_BALANCE_PRECISION_EXP = new __1.BN(6);
 exports.BANK_BALANCE_PRECISION = new __1.BN(10).pow(exports.BANK_BALANCE_PRECISION_EXP);
+exports.LIQUIDATION_FEE_PRECISION = new __1.BN(1000000);
 exports.QUOTE_PRECISION = new __1.BN(10).pow(exports.QUOTE_PRECISION_EXP);
 exports.MARK_PRICE_PRECISION = new __1.BN(10).pow(exports.MARK_PRICE_PRECISION_EXP);
 exports.FUNDING_PAYMENT_PRECISION = new __1.BN(10).pow(exports.FUNDING_PAYMENT_PRECISION_EXP);

package/lib/events/eventList.d.ts

@@ -17,6 +17,7 @@ export declare class EventList<Type extends EventType> {
     insert(event: EventMap[Type]): void;
     detach(): void;
     toArray(): EventMap[Type][];
+    countNode(): number;
     [Symbol.iterator](): Generator<EventMap[Type], void, unknown>;
 }
 export {};

package/lib/events/eventList.js

@@ -40,6 +40,9 @@ class EventList {
             if (currentNode.next !== undefined) {
                 newNode.next.prev = newNode;
             }
+            else {
+                this.tail = newNode;
+            }
             currentNode.next = newNode;
             newNode.prev = currentNode;
         }
@@ -66,6 +69,13 @@ class EventList {
     toArray() {
         return Array.from(this);
     }
+    countNode() {
+        let count = 0;
+        for (const _node of this) {
+            count++;
+        }
+        return count;
+    }
     *[Symbol.iterator]() {
         let node = this.head;
         while (node) {

package/lib/events/txEventCache.d.ts

@@ -19,6 +19,8 @@ export declare class TxEventCache {
     has(key: string): boolean;
     get(key: string): WrappedEvent<EventType>[] | undefined;
     detach(node: Node): void;
+    countNode(): number;
+    [Symbol.iterator](): Generator<WrappedEvent<keyof import("./types").EventMap>[], void, unknown>;
     clear(): void;
 }
 export {};

package/lib/events/txEventCache.js

@@ -61,6 +61,20 @@ class TxEventCache {
             this.tail = node.prev;
         }
     }
+    countNode() {
+        let count = 0;
+        for (const _node of this) {
+            count++;
+        }
+        return count;
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.value;
+            node = node.next;
+        }
+    }
     clear() {
         this.head = undefined;
         this.tail = undefined;