@drift-labs/sdk 0.2.0-master.20 → 0.2.0-master.21

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, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';

package/lib/clearingHouse.d.ts

@@ -153,8 +153,8 @@ export declare class ClearingHouse {
     getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
     resolveBorrowBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionSignature>;
     getResolveBorrowBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionInstruction>;
-    getRemainingAccountsForLiquidation(params: {
-        userAccount: UserAccount;
+    getRemainingAccountsWithCounterparty(params: {
+        counterPartyUserAccount: UserAccount;
         writableMarketIndex?: BN;
         writableBankIndexes?: BN[];
     }): AccountMeta[];

package/lib/clearingHouse.js

@@ -133,9 +133,13 @@ class ClearingHouse {
      *	Forces the accountSubscriber to fetch account updates from rpc
      */
     async fetchAccounts() {
-        await Promise.all([...this.users.values()]
+        const promises = [...this.users.values()]
             .map((user) => user.fetchAccounts())
-            .concat(this.accountSubscriber.fetch()));
+            .concat(this.accountSubscriber.fetch());
+        if (this.userStats) {
+            promises.concat(this.userStats.fetchAccounts());
+        }
+        await Promise.all(promises);
     }
     async unsubscribe() {
         const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
@@ -1077,7 +1081,9 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams);
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccounts({
+        // todo merge this with getRemainingAccounts
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: takerInfo.takerUserAccount,
             writableMarketIndex: orderParams.marketIndex,
         });
         if (referrerInfo) {
@@ -1216,9 +1222,9 @@ class ClearingHouse {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             writableMarketIndex: marketIndex,
-            userAccount,
+            counterPartyUserAccount: userAccount,
         });
         return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
             accounts: {
@@ -1238,8 +1244,8 @@ class ClearingHouse {
     }
     async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: userAccount,
             writableBankIndexes: [liabilityBankIndex, assetBankIndex],
         });
         return await this.program.instruction.liquidateBorrow(assetBankIndex, liabilityBankIndex, maxLiabilityTransfer, {
@@ -1258,8 +1264,8 @@ class ClearingHouse {
     }
     async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: userAccount,
             writableMarketIndex: perpMarketIndex,
             writableBankIndexes: [liabilityBankIndex],
         });
@@ -1279,8 +1285,8 @@ class ClearingHouse {
     }
     async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: userAccount,
             writableMarketIndex: perpMarketIndex,
             writableBankIndexes: [assetBankIndex],
         });
@@ -1300,9 +1306,9 @@ class ClearingHouse {
     }
     async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             writableMarketIndex: marketIndex,
-            userAccount,
+            counterPartyUserAccount: userAccount,
         });
         return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
             accounts: {
@@ -1320,9 +1326,9 @@ class ClearingHouse {
     }
     async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             writableBankIndexes: [bankIndex],
-            userAccount,
+            counterPartyUserAccount: userAccount,
         });
         return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
             accounts: {
@@ -1334,12 +1340,12 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    getRemainingAccountsForLiquidation(params) {
-        const liquidateeUserAccount = params.userAccount;
+    getRemainingAccountsWithCounterparty(params) {
+        const counterPartyUserAccount = params.counterPartyUserAccount;
         const oracleAccountMap = new Map();
         const bankAccountMap = new Map();
         const marketAccountMap = new Map();
-        for (const bankBalance of liquidateeUserAccount.bankBalances) {
+        for (const bankBalance of counterPartyUserAccount.bankBalances) {
             if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
                 const bankAccount = this.getBankAccount(bankBalance.bankIndex);
                 bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
@@ -1356,7 +1362,7 @@ class ClearingHouse {
                 }
             }
         }
-        for (const position of liquidateeUserAccount.positions) {
+        for (const position of counterPartyUserAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {

package/lib/clearingHouseUser.d.ts

@@ -37,6 +37,7 @@ export declare class ClearingHouseUser {
      */
     getUserPosition(marketIndex: BN): UserPosition | undefined;
     getEmptyPosition(marketIndex: BN): UserPosition;
+    getClonedPosition(position: UserPosition): UserPosition;
     /**
      * @param orderId
      * @returns Order
@@ -53,7 +54,7 @@ export declare class ClearingHouseUser {
      * calculates the market position if the lp position was settled
      * @returns : userPosition
      */
-    getSettledLPPosition(marketIndex: BN): [UserPosition, BN];
+    getSettledLPPosition(marketIndex: BN): [UserPosition, BN, BN];
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
      * @returns : Precision QUOTE_PRECISION
@@ -64,6 +65,13 @@ export declare class ClearingHouseUser {
      * @returns : Precision QUOTE_PRECISION
      */
     getFreeCollateral(): BN;
+    /**
+     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+     */
+    getMarginRequirement(type: MarginCategory): BN;
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
     getInitialMarginRequirement(): BN;
     /**
      * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION

package/lib/clearingHouseUser.js

@@ -78,6 +78,10 @@ class ClearingHouseUser {
             lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
     }
+    getClonedPosition(position) {
+        const clonedPosition = Object.assign({}, position);
+        return clonedPosition;
+    }
     /**
      * @param orderId
      * @returns Order
@@ -104,7 +108,8 @@ class ClearingHouseUser {
      * @returns : userPosition
      */
     getSettledLPPosition(marketIndex) {
-        const position = this.getUserPosition(marketIndex);
+        const _position = this.getUserPosition(marketIndex);
+        const position = this.getClonedPosition(_position);
         const market = this.clearingHouse.getMarketAccount(position.marketIndex);
         const nShares = position.lpShares;
         const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
@@ -180,7 +185,7 @@ class ClearingHouseUser {
         else {
             position.lastCumulativeFundingRate = numericConstants_1.ZERO;
         }
-        return [position, pnl];
+        return [position, remainderBaa, pnl];
     }
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
@@ -201,37 +206,69 @@ class ClearingHouseUser {
         const freeCollateral = totalCollateral.sub(initialMarginRequirement);
         return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
     }
-    getInitialMarginRequirement() {
-        const postionMarginRequirement = this.getUserAccount().positions.reduce((marginRequirement, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(marketPosition);
-            const worstCaseAssetValue = worstCaseBaseAssetAmount
-                .abs()
-                .mul(this.getOracleDataForMarket(market.marketIndex).price)
-                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-            const marketMarginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), 'Initial'));
-            return marginRequirement.add(worstCaseAssetValue.mul(marketMarginRatio).div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO);
-        const bankMarginRequirement = this.getBankLiabilityValue(undefined, 'Initial');
-        return bankMarginRequirement.add(postionMarginRequirement);
-    }
     /**
-     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
      */
-    getMaintenanceMarginRequirement() {
+    getMarginRequirement(type) {
         return this.getUserAccount()
             .positions.reduce((marginRequirement, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
+            if (marketPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                // is an lp
+                // clone so we dont mutate the position
+                marketPosition = this.getClonedPosition(marketPosition);
+                // settle position
+                const [settledPosition, dustBaa, _] = this.getSettledLPPosition(market.marketIndex);
+                marketPosition.baseAssetAmount =
+                    settledPosition.baseAssetAmount.add(dustBaa);
+                marketPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+                // open orders
+                let openAsks;
+                if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
+                    openAsks = market.amm.maxBaseAssetReserve
+                        .sub(market.amm.baseAssetReserve)
+                        .mul(marketPosition.lpShares)
+                        .div(market.amm.sqrtK)
+                        .mul(new _1.BN(-1));
+                }
+                else {
+                    openAsks = numericConstants_1.ZERO;
+                }
+                let openBids;
+                if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
+                    openBids = market.amm.baseAssetReserve
+                        .sub(market.amm.minBaseAssetReserve)
+                        .mul(marketPosition.lpShares)
+                        .div(market.amm.sqrtK);
+                }
+                else {
+                    openBids = numericConstants_1.ZERO;
+                }
+                marketPosition.openAsks = marketPosition.openAsks.add(openAsks);
+                marketPosition.openBids = marketPosition.openBids.add(openBids);
+            }
             const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(marketPosition);
             const worstCaseAssetValue = worstCaseBaseAssetAmount
                 .abs()
                 .mul(this.getOracleDataForMarket(market.marketIndex).price)
                 .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
             return marginRequirement.add(worstCaseAssetValue
-                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), 'Maintenance')))
+                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), type)))
                 .div(numericConstants_1.MARGIN_PRECISION));
         }, numericConstants_1.ZERO)
-            .add(this.getBankLiabilityValue(undefined, 'Maintenance'));
+            .add(this.getBankLiabilityValue(undefined, type));
+    }
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getInitialMarginRequirement() {
+        return this.getMarginRequirement('Initial');
+    }
+    /**
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getMaintenanceMarginRequirement() {
+        return this.getMarginRequirement('Maintenance');
     }
     /**
      * calculates unrealized position price pnl

package/lib/math/orders.d.ts

@@ -8,6 +8,7 @@ export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouse
 export declare function isOrderReduceOnly(user: ClearingHouseUser, order: Order): boolean;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
 export declare function getLimitPrice(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
-export declare function isFillableByVAMM(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): boolean;
+export declare function isFillableByVAMM(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number, maxAuctionDuration: number): boolean;
 export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
 export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, market: MarketAccount, limitPrice: BN, oraclePriceData: OraclePriceData): BN;
+export declare function isOrderExpired(order: Order, slot: number, maxAuctionDuration: number): boolean;

package/lib/math/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
@@ -86,7 +86,7 @@ function getLimitPrice(order, market, oraclePriceData, slot) {
         limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
     else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
-        if ((0, auction_1.isAuctionComplete)(order, slot)) {
+        if (!(0, auction_1.isAuctionComplete)(order, slot)) {
             limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
         }
         else if (!order.price.eq(numericConstants_1.ZERO)) {
@@ -109,9 +109,10 @@ function getLimitPrice(order, market, oraclePriceData, slot) {
     return limitPrice;
 }
 exports.getLimitPrice = getLimitPrice;
-function isFillableByVAMM(order, market, oraclePriceData, slot) {
-    return ((0, auction_1.isAuctionComplete)(order, slot) &&
-        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO));
+function isFillableByVAMM(order, market, oraclePriceData, slot, maxAuctionDuration) {
+    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
+        isOrderExpired(order, slot, maxAuctionDuration));
 }
 exports.isFillableByVAMM = isFillableByVAMM;
 function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
@@ -142,3 +143,11 @@ function isSameDirection(firstDirection, secondDirection) {
     return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
+function isOrderExpired(order, slot, maxAuctionDuration) {
+    if (!(0, types_1.isVariant)(order.orderType, 'market') ||
+        !(0, types_1.isVariant)(order.status, 'open')) {
+        return false;
+    }
+    return new anchor_1.BN(slot).sub(order.slot).gt(new anchor_1.BN(maxAuctionDuration));
+}
+exports.isOrderExpired = isOrderExpired;

package/lib/types.d.ts

@@ -345,6 +345,8 @@ export declare type StateAccount = {
     numberOfMarkets: BN;
     numberOfBanks: BN;
     minOrderQuoteAssetAmount: BN;
+    maxAuctionDuration: number;
+    minAuctionDuration: number;
 };
 export declare type MarketAccount = {
     initialized: boolean;
@@ -597,6 +599,7 @@ export declare type MakerInfo = {
 export declare type TakerInfo = {
     taker: PublicKey;
     takerStats: PublicKey;
+    takerUserAccount: UserAccount;
     order: Order;
 };
 export declare type ReferrerInfo = {

package/my-script/.env

@@ -0,0 +1,7 @@
+#ANCHOR_WALLET=/Users/ww/.config/solana/id.json
+
+#ANCHOR_WALLET=/Users/ww/.config/solana/bot2RzYy9oY5s3z71Yubo4MmRxyDBQP3qNNCqyqLcPp.json
+
+ANCHOR_WALLET=./ww18NdhuLSQPCrHSx7V68eZJpe2y311heWeXJfSmP3Q.json
+#ANCHOR_WALLET=./ww2z7N9TG1PLLUQGQF2VKzCFaPtQ5FBhRfeEAuy6c5C.json
+#ANCHOR_WALLET=./ww3StJtTubhwssqAhvSSAc5ifCgKjzmF8hz7Gt2DmSa.json

package/my-script/getUserStats.ts

@@ -0,0 +1,124 @@
+import * as anchor from '@project-serum/anchor';
+// import { AnchorProvider } from '@project-serum/anchor';
+import { PublicKey, clusterApiUrl } from '@solana/web3.js';
+
+import {
+    DriftEnv,
+    initialize,
+    BN,
+    BulkAccountLoader,
+    convertToNumber,
+    calculateAdjustKCost,
+    calculateBidAskPrice,
+    EventSubscriber,
+    UserAccount,
+    DevnetBanks,
+    DevnetMarkets,
+    MARK_PRICE_PRECISION,
+    BASE_PRECISION,
+    QUOTE_PRECISION,
+    ClearingHouse,
+    getMarketOrderParams,
+    PositionDirection,
+    ZERO,
+} from '..';
+import { printUserStats } from './utils';
+
+require('dotenv').config();
+const driftEnv = process.env.ENV as DriftEnv;
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main(provider: anchor.AnchorProvider) {
+    const connection = provider.connection;
+    const config = initialize({ env: 'devnet' });
+    const clearingHousePublicKey = new PublicKey(
+        config.CLEARING_HOUSE_PROGRAM_ID
+    );
+
+    const bulkAccountLoader = new BulkAccountLoader(connection, 'confirmed', 1000);
+    const clearingHouse = new ClearingHouse({
+        connection,
+        wallet: provider.wallet,
+        programID: clearingHousePublicKey,
+        env: 'devnet',
+        // accountSubscription: {
+		// 	type: 'websocket',
+        // }
+        accountSubscription: {
+            type: 'polling',
+            accountLoader: bulkAccountLoader,
+        }
+    });
+
+    console.log(`clearingHouseProgramID: ${clearingHousePublicKey}`)
+    console.log(`provider.wallet:        ${provider.wallet.publicKey.toBase58()}`)
+
+    const eventSubscriber = new EventSubscriber(connection, clearingHouse.program, {
+        maxTx: 8192,
+        maxEventsPerType: 4096,
+        orderBy: 'blockchain',
+        orderDir: 'desc',
+        commitment: 'confirmed',
+        logProviderConfig: {
+            type: 'websocket',
+        },
+    });
+
+	if (!(await clearingHouse.getUser().exists())) {
+		console.error(`ClearingHouseUser for ${provider.wallet.publicKey} does not exist`);
+        console.info(`Creating ClearingHouseUser for ${provider.wallet.publicKey}`);
+        const [txSig] = await clearingHouse.initializeUserAccount();
+        console.log(`Initialized user account in transaction: ${txSig}`);
+	}
+
+    if (!await clearingHouse.subscribe()) {
+        throw new Error("fail clearingHouse.subscribe");
+    }
+    if (!await clearingHouse.accountSubscriber.subscribe()) {
+        throw new Error("fail clearingHouse.accountSubscriber.subscribe");
+    }
+	if (!eventSubscriber.subscribe()) {
+        throw new Error("fail eventSubscriber.subscribe");
+    }
+
+    const chUser = clearingHouse.getUser();
+    const chUserAccount = clearingHouse.getUserAccount();
+    console.log(`chUserAcc.authority:    ${chUserAccount!.authority.toBase58()}`);
+    console.log(`  chUserAccount pubkey: ${chUser.userAccountPublicKey.toBase58()}`)
+
+    const keyToSymbol = new Map<string, string>();
+    const marketIndexToSymbol = new Map<number, string>();
+    for (const market of DevnetMarkets) {
+        keyToSymbol.set(market.oracle.toBase58(), market.baseAssetSymbol);
+        marketIndexToSymbol.set(market.marketIndex.toNumber(), market.symbol);
+    }
+
+    const run = async () => {
+        await clearingHouse.fetchAccounts();
+        await chUser.fetchAccounts();
+        printUserStats(chUserAccount!, marketIndexToSymbol);
+    }
+    await run();
+    setInterval(run, 1000);
+}
+
+
+try {
+    if (!process.env.ANCHOR_WALLET) {
+        throw new Error('ANCHOR_WALLET must be set.');
+    }
+    main(
+        anchor.AnchorProvider.local(clusterApiUrl("devnet"), {
+            // anchor.AnchorProvider.local('https://devnet.genesysgo.net', {
+            preflightCommitment: 'confirmed',
+            skipPreflight: false,
+            commitment: 'confirmed',
+        })
+    );
+    // anchor.AnchorProvider.local('https://psytrbhymqlkfrhudd.dev.genesysgo.net:8899/');
+} catch (e) {
+   console.error(e);
+}

package/my-script/multiConnections.ts

@@ -0,0 +1,137 @@
+import * as anchor from '@project-serum/anchor';
+// import { AnchorProvider } from '@project-serum/anchor';
+import { PublicKey, clusterApiUrl } from '@solana/web3.js';
+
+import {
+	DriftEnv,
+	initialize,
+	BN,
+	BulkAccountLoader,
+	convertToNumber,
+	calculateAdjustKCost,
+	calculateBidAskPrice,
+	EventSubscriber,
+	UserAccount,
+	DevnetBanks,
+	DevnetMarkets,
+	MARK_PRICE_PRECISION,
+	BASE_PRECISION,
+	QUOTE_PRECISION,
+	ClearingHouse,
+	getMarketOrderParams,
+	PositionDirection,
+	ZERO,
+} from '..';
+import { printUserStats } from './utils';
+
+require('dotenv').config();
+const driftEnv = process.env.ENV as DriftEnv;
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main(provider: anchor.AnchorProvider) {
+	const connection = provider.connection;
+	const config = initialize({ env: 'devnet' });
+	const clearingHousePublicKey = new PublicKey(
+		config.CLEARING_HOUSE_PROGRAM_ID
+	);
+
+	const bulkAccountLoader = new BulkAccountLoader(
+		connection,
+		'confirmed',
+		1000
+	);
+	const clearingHouse = new ClearingHouse({
+		connection,
+		wallet: provider.wallet,
+		programID: clearingHousePublicKey,
+		env: 'devnet',
+		// accountSubscription: {
+		// 	type: 'websocket',
+		// }
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
+
+	console.log(`clearingHouseProgramID: ${clearingHousePublicKey}`);
+	console.log(
+		`provider.wallet:        ${provider.wallet.publicKey.toBase58()}`
+	);
+
+	const eventSubscriber = new EventSubscriber(
+		connection,
+		clearingHouse.program,
+		{
+			maxTx: 8192,
+			maxEventsPerType: 4096,
+			orderBy: 'blockchain',
+			orderDir: 'desc',
+			commitment: 'confirmed',
+			logProviderConfig: {
+				type: 'websocket',
+			},
+		}
+	);
+
+	if (!(await clearingHouse.getUser().exists())) {
+		console.error(
+			`ClearingHouseUser for ${provider.wallet.publicKey} does not exist`
+		);
+		console.info(`Creating ClearingHouseUser for ${provider.wallet.publicKey}`);
+		const [txSig] = await clearingHouse.initializeUserAccount();
+		console.log(`Initialized user account in transaction: ${txSig}`);
+	}
+
+	if (!(await clearingHouse.subscribe())) {
+		throw new Error('fail clearingHouse.subscribe');
+	}
+	if (!(await clearingHouse.accountSubscriber.subscribe())) {
+		throw new Error('fail clearingHouse.accountSubscriber.subscribe');
+	}
+	if (!eventSubscriber.subscribe()) {
+		throw new Error('fail eventSubscriber.subscribe');
+	}
+
+	const chUser = clearingHouse.getUser();
+	const chUserAccount = clearingHouse.getUserAccount();
+	console.log(`chUserAcc.authority:    ${chUserAccount!.authority.toBase58()}`);
+	console.log(
+		`  chUserAccount pubkey: ${chUser.userAccountPublicKey.toBase58()}`
+	);
+
+	const keyToSymbol = new Map<string, string>();
+	const marketIndexToSymbol = new Map<number, string>();
+	for (const market of DevnetMarkets) {
+		keyToSymbol.set(market.oracle.toBase58(), market.baseAssetSymbol);
+		marketIndexToSymbol.set(market.marketIndex.toNumber(), market.symbol);
+	}
+
+	const run = async () => {
+		await clearingHouse.fetchAccounts();
+		await chUser.fetchAccounts();
+		printUserStats(chUserAccount!, marketIndexToSymbol);
+	};
+	await run();
+	setInterval(run, 1000);
+}
+
+try {
+	if (!process.env.ANCHOR_WALLET) {
+		throw new Error('ANCHOR_WALLET must be set.');
+	}
+	main(
+		anchor.AnchorProvider.local(clusterApiUrl('devnet'), {
+			// anchor.AnchorProvider.local('https://devnet.genesysgo.net', {
+			preflightCommitment: 'confirmed',
+			skipPreflight: false,
+			commitment: 'confirmed',
+		})
+	);
+	// anchor.AnchorProvider.local('https://psytrbhymqlkfrhudd.dev.genesysgo.net:8899/');
+} catch (e) {
+	console.error(e);
+}

package/my-script/test-regex.ts

@@ -0,0 +1,11 @@
+try {
+    // const msg = 'Program 65sz7dRiWDRPZjiRxcTxPM7AE6VK4Nag9HEK6oBJXhJn failed: custom program error: 0x179e'
+    const msg = 'Program log: AnchorError occurred. Error Code: OrderDoesNotExist. Error Number: 6046. Error Message: Order does not exist.'
+    const code = msg.match(
+        /Program log: AnchorError occurred. Error Code: ([0-9,a-z,A-Z]+). Error Number/
+    );
+    console.log(code[1]);
+} catch (e) {
+    console.log("nothing");
+    // no problem if couldn't match error code
+}