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

package/src/tokenFaucet.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenFaucet = void 0;
+const anchor = __importStar(require("@project-serum/anchor"));
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts) {
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
+        const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
+    }
+    getFaucetConfigPublicKeyAndNonce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+                this.mint.toBuffer(),
+            ], this.program.programId);
+        });
+    }
+    getMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+                this.mint.toBuffer(),
+            ], this.program.programId))[0];
+        });
+    }
+    getFaucetConfigPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getFaucetConfigPublicKeyAndNonce())[0];
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [faucetConfigPublicKey] = yield this.getFaucetConfigPublicKeyAndNonce();
+            return yield this.program.rpc.initialize({
+                accounts: {
+                    faucetConfig: faucetConfigPublicKey,
+                    admin: this.wallet.publicKey,
+                    mintAccount: this.mint,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    fetchState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.account.faucetConfig.fetch(yield this.getFaucetConfigPublicKey());
+        });
+    }
+    mintToUserIx(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.instruction.mintToUser(amount, {
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    userTokenAccount,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    mintToUser(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mintIx = yield this.mintToUserIx(userTokenAccount, amount);
+            const tx = new web3_js_1.Transaction().add(mintIx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return txSig;
+        });
+    }
+    transferMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.transferMintAuthority({
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+        });
+    }
+    createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new web3_js_1.Transaction();
+            const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = yield this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+            let associatedTokenAccountExists = false;
+            try {
+                const assosciatedTokenAccount = yield this.connection.getAccountInfo(associatedTokenPublicKey);
+                associatedTokenAccountExists = !!assosciatedTokenAccount;
+            }
+            catch (e) {
+                // token account doesn't exist
+                associatedTokenAccountExists = false;
+            }
+            const skipAccountCreation = associatedTokenAccountExists;
+            if (!skipAccountCreation)
+                tx.add(createAssociatedAccountIx);
+            tx.add(mintToTx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return [associatedTokenPublicKey, txSig];
+        });
+    }
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            const associateTokenPublicKey = yield this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+            const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, associateTokenPublicKey, userPublicKey, this.wallet.publicKey);
+            const mintToIx = yield this.mintToUserIx(associateTokenPublicKey, amount);
+            return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+        });
+    }
+    getAssosciatedMockUSDMintAddress(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, props.userPubKey);
+        });
+    }
+    getTokenAccountInfo(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assosciatedKey = yield this.getAssosciatedMockUSDMintAddress(props);
+            const state = yield this.fetchState();
+            const token = new spl_token_1.Token(this.connection, state.mint, spl_token_1.TOKEN_PROGRAM_ID, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this.provider.payer);
+            return yield token.getAccountInfo(assosciatedKey);
+        });
+    }
+    subscribeToTokenAccount(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenAccountKey = yield this.getAssosciatedMockUSDMintAddress(props);
+                props.callback(yield this.getTokenAccountInfo(props));
+                // Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
+                this.connection.onAccountChange(tokenAccountKey, (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => __awaiter(this, void 0, void 0, function* () {
+                    props.callback(yield this.getTokenAccountInfo(props));
+                }));
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+}
+exports.TokenFaucet = TokenFaucet;

package/src/tx/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInTx = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const COMPUTE_UNITS_DEFAULT = 200000;
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
+) {
+    const tx = new web3_js_1.Transaction();
+    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: computeUnits,
+            additionalFee: 0,
+        }));
+    }
+    return tx.add(instruction);
+}
+exports.wrapInTx = wrapInTx;

package/src/types.ts

@@ -58,9 +58,6 @@ export class OrderAction {
 
 export class OrderActionExplanation {
 	static readonly NONE = { none: {} };
-	static readonly BREACHED_MARGIN_REQUIREMENT = {
-		breachedMarginRequirement: {},
-	};
 	static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
 		oraclePriceBreachedLimitPrice: {},
 	};
@@ -156,10 +153,15 @@ export type FundingRateRecord = {
 	recordId: BN;
 	marketIndex: BN;
 	fundingRate: BN;
+	fundingRateLong: BN;
+	fundingRateShort: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
 	oraclePriceTwap: BN;
 	markPriceTwap: BN;
+	periodRevenue: BN;
+	netBaseAssetAmount: BN;
+	netUnsettledLpBaseAssetAmount: BN;
 };
 
 export type FundingPaymentRecord = {
@@ -274,27 +276,41 @@ export type SettlePnlRecord = {
 
 export type OrderRecord = {
 	ts: BN;
-	taker: PublicKey;
-	maker: PublicKey;
-	takerOrder: Order;
-	makerOrder: Order;
-	takerPnl: BN;
-	makerPnl: BN;
+	user: PublicKey;
+	order: Order;
+};
+
+export type OrderActionRecord = {
+	ts: BN;
 	action: OrderAction;
 	actionExplanation: OrderActionExplanation;
-	filler: PublicKey;
-	fillRecordId: BN;
 	marketIndex: BN;
-	baseAssetAmountFilled: BN;
-	quoteAssetAmountFilled: BN;
-	makerRebate: BN;
-	takerFee: BN;
-	fillerReward: BN;
-	quoteAssetAmountSurplus: BN;
+	filler: PublicKey | null;
+	fillerReward: BN | null;
+	fillRecordId: BN | null;
+	referrer: PublicKey | null;
+	baseAssetAmountFilled: BN | null;
+	quoteAssetAmountFilled: BN | null;
+	takerPnl: BN | null;
+	makerPnl: BN | null;
+	takerFee: BN | null;
+	makerRebate: BN | null;
+	referrerReward: BN | null;
+	refereeDiscount: BN | null;
+	quoteAssetAmountSurplus: BN | null;
+	taker: PublicKey | null;
+	takerOrderId: BN | null;
+	takerOrderBaseAssetAmount: BN | null;
+	takerOrderBaseAssetAmountFilled: BN | null;
+	takerOrderQuoteAssetAmountFilled: BN | null;
+	takerOrderFee: BN | null;
+	maker: PublicKey | null;
+	makerOrderId: BN | null;
+	makerOrderBaseAssetAmount: BN | null;
+	makerOrderBaseAssetAmountFilled: BN | null;
+	makerOrderQuoteAssetAmountFilled: BN | null;
+	makerOrderFee: BN | null;
 	oraclePrice: BN;
-	referrer: PublicKey;
-	referrerReward: BN;
-	refereeDiscount: BN;
 };
 
 export type StateAccount = {
@@ -357,6 +373,20 @@ export type BankAccount = {
 	vault: PublicKey;
 	vaultAuthority: PublicKey;
 	vaultAuthorityNonce: number;
+
+	insuranceFundVault: PublicKey;
+	insuranceFundVaultAuthority: PublicKey;
+	insuranceFundVaultAuthorityNonce: number;
+	insuranceWithdrawEscrowPeriod: BN;
+	revenuePool: PoolBalance;
+
+	totalIfShares: BN;
+	userIfShares: BN;
+
+	userIfFactor: BN;
+	totalIfFactor: BN;
+	liquidationIfFactor: BN;
+
 	decimals: number;
 	optimalUtilization: BN;
 	optimalBorrowRate: BN;
@@ -439,6 +469,7 @@ export type AMM = {
 	maxSpread: number;
 	marketPosition: UserPosition;
 	marketPositionPerLp: UserPosition;
+	ammJitIntensity: number;
 	maxBaseAssetReserve: BN;
 	minBaseAssetReserve: BN;
 };
@@ -478,6 +509,7 @@ export type UserStatsAccount = {
 	isReferrer: boolean;
 	totalReferrerReward: BN;
 	authority: PublicKey;
+	quoteAssetInsuranceFundStake: BN;
 };
 
 export type UserAccount = {
@@ -664,3 +696,15 @@ export type OrderFillerRewardStructure = {
 };
 
 export type MarginCategory = 'Initial' | 'Maintenance';
+
+export type InsuranceFundStake = {
+	bankIndex: BN;
+	authority: PublicKey;
+
+	ifShares: BN;
+	ifBase: BN;
+
+	lastWithdrawRequestShares: BN;
+	lastWithdrawRequestValue: BN;
+	lastWithdrawRequestTs: BN;
+};

package/src/userName.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeName = exports.encodeName = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.MAX_NAME_LENGTH = 32;
+exports.DEFAULT_USER_NAME = 'Main Account';
+function encodeName(name) {
+    if (name.length > exports.MAX_NAME_LENGTH) {
+        throw Error(`User name (${name}) longer than 32 characters`);
+    }
+    const buffer = Buffer.alloc(32);
+    buffer.fill(name);
+    buffer.fill(' ', name.length);
+    return Array(...buffer);
+}
+exports.encodeName = encodeName;
+function decodeName(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.toString('utf8').trim();
+}
+exports.decodeName = decodeName;

package/src/util/computeUnits.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield connection.getTransaction(txSignature, { commitment });
+        const computeUnits = [];
+        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
+        tx.meta.logMessages.forEach((logMessage) => {
+            const match = logMessage.match(regex);
+            if (match && match[1]) {
+                computeUnits.push(match[1]);
+            }
+        });
+        return computeUnits;
+    });
+}
+exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/src/util/tps.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
+        if (failed) {
+            signatures = signatures.filter((signature) => signature.err);
+        }
+        const numberOfSignatures = signatures.length;
+        if (numberOfSignatures === 0) {
+            return 0;
+        }
+        return (numberOfSignatures /
+            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+    });
+}
+exports.estimateTps = estimateTps;

package/src/wallet.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+class Wallet {
+    constructor(payer) {
+        this.payer = payer;
+    }
+    signTransaction(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            tx.partialSign(this.payer);
+            return tx;
+        });
+    }
+    signAllTransactions(txs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return txs.map((t) => {
+                t.partialSign(this.payer);
+                return t;
+            });
+        });
+    }
+    get publicKey() {
+        return this.payer.publicKey;
+    }
+}
+exports.Wallet = Wallet;

package/my-script/.env

@@ -1,7 +0,0 @@
-#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

@@ -1,124 +0,0 @@
-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);
-}