@drift-labs/sdk 0.2.0-temp.2 → 2.0.0

package/lib/{clearingHouseConfig.d.ts → driftClientConfig.d.ts}

@@ -1,25 +1,25 @@
-/// <reference types="bn.js" />
 import { ConfirmOptions, Connection, PublicKey } from '@solana/web3.js';
 import { IWallet } from './types';
-import { BN } from '@project-serum/anchor';
 import { OracleInfo } from './oracles/types';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
 import { DriftEnv } from './config';
-export declare type ClearingHouseConfig = {
+export declare type DriftClientConfig = {
     connection: Connection;
     wallet: IWallet;
     programID: PublicKey;
-    accountSubscription?: ClearingHouseSubscriptionConfig;
+    accountSubscription?: DriftClientSubscriptionConfig;
     opts?: ConfirmOptions;
     txSenderConfig?: TxSenderConfig;
-    userIds?: number[];
-    activeUserId?: number;
-    marketIndexes?: BN[];
-    bankIndexes?: BN[];
+    subAccountIds?: number[];
+    activeSubAccountId?: number;
+    perpMarketIndexes?: number[];
+    spotMarketIndexes?: number[];
     oracleInfos?: OracleInfo[];
     env?: DriftEnv;
+    userStats?: boolean;
+    authority?: PublicKey;
 };
-declare type ClearingHouseSubscriptionConfig = {
+declare type DriftClientSubscriptionConfig = {
     type: 'websocket';
 } | {
     type: 'polling';

package/lib/events/eventList.d.ts

@@ -17,7 +17,6 @@ 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

@@ -69,13 +69,6 @@ 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/eventSubscriber.d.ts

@@ -15,10 +15,13 @@ export declare class EventSubscriber {
     private awaitTxResolver;
     private logProvider;
     eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+    private lastSeenSlot;
+    private lastSeenBlockTime;
+    lastSeenTxSig: string;
     constructor(connection: Connection, program: Program, options?: EventSubscriptionOptions);
-    subscribe(): boolean;
+    subscribe(): Promise<boolean>;
     private handleTxLogs;
-    private fetchPreviousTx;
+    fetchPreviousTx(fetchMax?: boolean): Promise<void>;
     unsubscribe(): Promise<boolean>;
     private parseEventsFromLogs;
     awaitTx(txSig: TransactionSignature): Promise<void>;

package/lib/events/eventSubscriber.js

@@ -30,25 +30,32 @@ class EventSubscriber {
             this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.program.programId, options.commitment, this.options.logProviderConfig.frequency);
         }
     }
-    subscribe() {
-        if (this.logProvider.isSubscribed()) {
+    async subscribe() {
+        try {
+            if (this.logProvider.isSubscribed()) {
+                return true;
+            }
+            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
+            }, true);
             return true;
         }
-        this.fetchPreviousTx().catch((e) => {
+        catch (e) {
             console.error('Error fetching previous txs in event subscriber');
             console.error(e);
-        });
-        return this.logProvider.subscribe((txSig, slot, logs) => {
-            this.handleTxLogs(txSig, slot, logs);
-        });
+            return false;
+        }
     }
-    handleTxLogs(txSig, slot, logs) {
+    handleTxLogs(txSig, slot, logs, mostRecentBlockTime) {
         if (this.txEventCache.has(txSig)) {
             return;
         }
         const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
         for (const wrappedEvent of wrappedEvents) {
             this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+        }
+        // dont emit event till we've added all the events to the eventListMap
+        for (const wrappedEvent of wrappedEvents) {
             this.eventEmitter.emit('newEvent', wrappedEvent);
         }
         if (this.awaitTxPromises.has(txSig)) {
@@ -56,10 +63,17 @@ class EventSubscriber {
             this.awaitTxResolver.get(txSig)();
             this.awaitTxResolver.delete(txSig);
         }
+        if (slot > this.lastSeenSlot) {
+            this.lastSeenTxSig = txSig;
+        }
+        if (this.lastSeenBlockTime === undefined ||
+            mostRecentBlockTime > this.lastSeenBlockTime) {
+            this.lastSeenBlockTime = mostRecentBlockTime;
+        }
         this.txEventCache.add(txSig, wrappedEvents);
     }
-    async fetchPreviousTx() {
-        if (!this.options.untilTx) {
+    async fetchPreviousTx(fetchMax) {
+        if (!this.options.untilTx && !fetchMax) {
             return;
         }
         let txFetched = 0;
@@ -73,7 +87,7 @@ class EventSubscriber {
             txFetched += response.transactionLogs.length;
             beforeTx = response.earliestTx;
             for (const { txSig, slot, logs } of response.transactionLogs) {
-                this.handleTxLogs(txSig, slot, logs);
+                this.handleTxLogs(txSig, slot, logs, response.mostRecentBlockTime);
             }
         }
     }

package/lib/events/fetchLogs.d.ts

@@ -1,4 +1,6 @@
-import { Connection, Finality, PublicKey, TransactionSignature } from '@solana/web3.js';
+import { Program } from '@project-serum/anchor';
+import { Connection, Finality, PublicKey, TransactionResponse, TransactionSignature } from '@solana/web3.js';
+import { WrappedEvents } from './types';
 declare type Log = {
     txSig: TransactionSignature;
     slot: number;
@@ -7,7 +9,16 @@ declare type Log = {
 declare type FetchLogsResponse = {
     earliestTx: string;
     mostRecentTx: string;
+    earliestSlot: number;
+    mostRecentSlot: number;
     transactionLogs: Log[];
+    mostRecentBlockTime: number | undefined;
 };
-export declare function fetchLogs(connection: Connection, programId: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature): Promise<FetchLogsResponse | undefined>;
+export declare function fetchLogs(connection: Connection, programId: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature, limit?: number): Promise<FetchLogsResponse>;
+export declare class LogParser {
+    private program;
+    constructor(program: Program);
+    parseEventsFromTransaction(transaction: TransactionResponse): WrappedEvents;
+    parseEventsFromLogs(event: Log): WrappedEvents;
+}
 export {};

package/lib/events/fetchLogs.js

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchLogs = void 0;
-async function fetchLogs(connection, programId, finality, beforeTx, untilTx) {
+exports.LogParser = exports.fetchLogs = void 0;
+function mapTransactionResponseToLog(transaction) {
+    return {
+        txSig: transaction.transaction.signatures[0],
+        slot: transaction.slot,
+        logs: transaction.meta.logMessages,
+    };
+}
+async function fetchLogs(connection, programId, finality, beforeTx, untilTx, limit) {
     const signatures = await connection.getSignaturesForAddress(programId, {
         before: beforeTx,
         until: untilTx,
+        limit,
     }, finality);
-    const sortedSignatures = signatures.sort((a, b) => a.slot < b.slot ? -1 : 1);
+    const sortedSignatures = signatures.sort((a, b) => a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1);
     const filteredSignatures = sortedSignatures.filter((signature) => !signature.err);
     if (filteredSignatures.length === 0) {
         return undefined;
@@ -14,20 +22,22 @@ async function fetchLogs(connection, programId, finality, beforeTx, untilTx) {
     const chunkedSignatures = chunk(filteredSignatures, 100);
     const transactionLogs = (await Promise.all(chunkedSignatures.map(async (chunk) => {
         const transactions = await connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), finality);
-        return transactions.map((transaction) => {
-            return {
-                txSig: transaction.transaction.signatures[0],
-                slot: transaction.slot,
-                logs: transaction.meta.logMessages,
-            };
-        });
+        return transactions.reduce((logs, transaction) => {
+            if (transaction) {
+                logs.push(mapTransactionResponseToLog(transaction));
+            }
+            return logs;
+        }, new Array());
     }))).flat();
-    const earliestTx = filteredSignatures[0].signature;
-    const mostRecentTx = filteredSignatures[filteredSignatures.length - 1].signature;
+    const earliest = filteredSignatures[0];
+    const mostRecent = filteredSignatures[filteredSignatures.length - 1];
     return {
         transactionLogs: transactionLogs,
-        earliestTx: earliestTx,
-        mostRecentTx: mostRecentTx,
+        earliestTx: earliest.signature,
+        mostRecentTx: mostRecent.signature,
+        earliestSlot: earliest.slot,
+        mostRecentSlot: mostRecent.slot,
+        mostRecentBlockTime: mostRecent.blockTime,
     };
 }
 exports.fetchLogs = fetchLogs;
@@ -37,3 +47,24 @@ function chunk(array, size) {
         .map((_, index) => index * size)
         .map((begin) => array.slice(begin, begin + size));
 }
+class LogParser {
+    constructor(program) {
+        this.program = program;
+    }
+    parseEventsFromTransaction(transaction) {
+        const transactionLogObject = mapTransactionResponseToLog(transaction);
+        return this.parseEventsFromLogs(transactionLogObject);
+    }
+    parseEventsFromLogs(event) {
+        const records = [];
+        // @ts-ignore
+        this.program._events._eventParser.parseLogs(event.logs, (eventLog) => {
+            eventLog.data.txSig = event.txSig;
+            eventLog.data.slot = event.slot;
+            eventLog.data.eventType = eventLog.name;
+            records.push(eventLog.data);
+        });
+        return records;
+    }
+}
+exports.LogParser = LogParser;

package/lib/events/pollingLogProvider.d.ts

@@ -8,8 +8,9 @@ export declare class PollingLogProvider implements LogProvider {
     private intervalId;
     private mostRecentSeenTx?;
     private mutex;
+    private firstFetch;
     constructor(connection: Connection, programId: PublicKey, commitment: Commitment, frequency?: number);
-    subscribe(callback: logProviderCallback): boolean;
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
     isSubscribed(): boolean;
     unsubscribe(): Promise<boolean>;
 }

package/lib/events/pollingLogProvider.js

@@ -7,9 +7,10 @@ class PollingLogProvider {
         this.connection = connection;
         this.programId = programId;
         this.frequency = frequency;
+        this.firstFetch = true;
         this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
     }
-    subscribe(callback) {
+    subscribe(callback, skipHistory) {
         if (this.intervalId) {
             return true;
         }
@@ -19,13 +20,16 @@ class PollingLogProvider {
             }
             this.mutex = 1;
             try {
-                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.programId, this.finality, undefined, this.mostRecentSeenTx);
+                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.programId, this.finality, undefined, this.mostRecentSeenTx, 
+                // If skipping history, only fetch one log back, not the maximum amount available
+                skipHistory && this.firstFetch ? 1 : undefined);
+                this.firstFetch = false;
                 if (response === undefined) {
                     return;
                 }
                 const { mostRecentTx, transactionLogs } = response;
                 for (const { txSig, slot, logs } of transactionLogs) {
-                    callback(txSig, slot, logs);
+                    callback(txSig, slot, logs, response.mostRecentBlockTime);
                 }
                 this.mostRecentSeenTx = mostRecentTx;
             }

package/lib/events/sort.js

@@ -11,17 +11,14 @@ function clientSortDescFn() {
 function defaultBlockchainSortFn(currentEvent, newEvent) {
     return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
 }
-function orderRecordSortFn(currentEvent, newEvent) {
-    const currentEventMarketIndex = !currentEvent.maker.equals(index_1.PublicKey.default)
-        ? currentEvent.makerOrder.marketIndex
-        : currentEvent.takerOrder.marketIndex;
-    const newEventMarketIndex = !newEvent.maker.equals(index_1.PublicKey.default)
-        ? newEvent.makerOrder.marketIndex
-        : newEvent.takerOrder.marketIndex;
-    if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+function orderActionRecordSortFn(currentEvent, newEvent) {
+    var _a, _b;
+    const currentEventMarketIndex = currentEvent.marketIndex;
+    const newEventMarketIndex = newEvent.marketIndex;
+    if (currentEventMarketIndex !== newEventMarketIndex) {
         return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
     }
-    if (currentEvent.fillRecordId.gt(index_1.ZERO) && newEvent.fillRecordId.gt(index_1.ZERO)) {
+    if (((_a = currentEvent.fillRecordId) === null || _a === void 0 ? void 0 : _a.gt(index_1.ZERO)) && ((_b = newEvent.fillRecordId) === null || _b === void 0 ? void 0 : _b.gt(index_1.ZERO))) {
         return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
             ? 'less than'
             : 'greater than';
@@ -35,8 +32,8 @@ function getSortFn(orderBy, orderDir, eventType) {
         return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
     }
     switch (eventType) {
-        case 'OrderRecord':
-            return orderRecordSortFn;
+        case 'OrderActionRecord':
+            return orderActionRecordSortFn;
         default:
             return defaultBlockchainSortFn;
     }

package/lib/events/txEventCache.d.ts

@@ -19,8 +19,6 @@ 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,20 +61,6 @@ 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;

package/lib/events/types.d.ts

@@ -1,5 +1,5 @@
 import { Commitment, TransactionSignature } from '@solana/web3.js';
-import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, OrderRecord } from '../index';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord } from '../index';
 export declare type EventSubscriptionOptions = {
     eventTypes?: EventType[];
     maxEventsPerType?: number;
@@ -27,16 +27,24 @@ export declare type EventMap = {
     LiquidationRecord: Event<LiquidationRecord>;
     FundingRateRecord: Event<FundingRateRecord>;
     OrderRecord: Event<OrderRecord>;
+    OrderActionRecord: Event<OrderActionRecord>;
+    SettlePnlRecord: Event<SettlePnlRecord>;
+    NewUserRecord: Event<NewUserRecord>;
+    LPRecord: Event<LPRecord>;
+    InsuranceFundRecord: Event<InsuranceFundRecord>;
+    SpotInterestRecord: Event<SpotInterestRecord>;
+    InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
+    CurveRecord: Event<CurveRecord>;
 };
 export declare type EventType = keyof EventMap;
 export interface EventSubscriberEvents {
     newEvent: (event: WrappedEvent<EventType>) => void;
 }
 export declare type SortFn = (currentRecord: EventMap[EventType], newRecord: EventMap[EventType]) => 'less than' | 'greater than';
-export declare type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[]) => void;
+export declare type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined) => void;
 export interface LogProvider {
     isSubscribed(): boolean;
-    subscribe(callback: logProviderCallback): boolean;
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
     unsubscribe(): Promise<boolean>;
 }
 export declare type WebSocketLogProviderConfig = {

package/lib/events/types.js

@@ -7,7 +7,15 @@ exports.DefaultEventSubscriptionOptions = {
         'FundingPaymentRecord',
         'LiquidationRecord',
         'OrderRecord',
+        'OrderActionRecord',
         'FundingRateRecord',
+        'NewUserRecord',
+        'SettlePnlRecord',
+        'LPRecord',
+        'InsuranceFundRecord',
+        'SpotInterestRecord',
+        'InsuranceFundStakeRecord',
+        'CurveRecord',
     ],
     maxEventsPerType: 4096,
     orderBy: 'blockchain',

package/lib/events/webSocketLogProvider.js

@@ -12,7 +12,7 @@ class WebSocketLogProvider {
             return true;
         }
         this.subscriptionId = this.connection.onLogs(this.programId, (logs, ctx) => {
-            callback(logs.signature, ctx.slot, logs.logs);
+            callback(logs.signature, ctx.slot, logs.logs, undefined);
         }, this.commitment);
         return true;
     }

package/lib/examples/makeTradeExample.js

@@ -6,14 +6,15 @@ const __1 = require("..");
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const __2 = require("..");
-const banks_1 = require("../constants/banks");
+const spotMarkets_1 = require("../constants/spotMarkets");
 const getTokenAddress = (mintAddress, userPubKey) => {
     return spl_token_1.Token.getAssociatedTokenAddress(new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`), spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
 };
 exports.getTokenAddress = getTokenAddress;
+const cluster = 'devnet';
 const main = async () => {
     // Initialize Drift SDK
-    const sdkConfig = (0, __2.initialize)({ env: 'devnet' });
+    const sdkConfig = (0, __2.initialize)({ env: cluster });
     // Set up the Wallet and Provider
     const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
     const keypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(JSON.parse(privateKey)));
@@ -29,43 +30,54 @@ const main = async () => {
     // Misc. other things to set up
     const usdcTokenAddress = await (0, exports.getTokenAddress)(sdkConfig.USDC_MINT_ADDRESS, wallet.publicKey.toString());
     // Set up the Drift Clearing House
-    const clearingHousePublicKey = new web3_js_1.PublicKey(sdkConfig.CLEARING_HOUSE_PROGRAM_ID);
-    const clearingHouse = new __2.ClearingHouse({
+    const driftPublicKey = new web3_js_1.PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
+    const bulkAccountLoader = new __2.BulkAccountLoader(connection, 'confirmed', 1000);
+    const driftClient = new __2.DriftClient({
         connection,
         wallet: provider.wallet,
-        programID: clearingHousePublicKey,
+        programID: driftPublicKey,
+        perpMarketIndexes: __2.PerpMarkets[cluster].map((market) => market.marketIndex),
+        spotMarketIndexes: spotMarkets_1.SpotMarkets[cluster].map((spotMarket) => spotMarket.marketIndex),
+        accountSubscription: {
+            type: 'polling',
+            accountLoader: bulkAccountLoader,
+        },
     });
-    await clearingHouse.subscribe();
+    await driftClient.subscribe();
     // Set up Clearing House user client
-    const user = new __2.ClearingHouseUser({
-        clearingHouse,
-        userAccountPublicKey: await clearingHouse.getUserAccountPublicKey(),
+    const user = new __2.User({
+        driftClient: driftClient,
+        userAccountPublicKey: await driftClient.getUserAccountPublicKey(),
+        accountSubscription: {
+            type: 'polling',
+            accountLoader: bulkAccountLoader,
+        },
     });
     //// Check if clearing house account exists for the current wallet
     const userAccountExists = await user.exists();
     if (!userAccountExists) {
         //// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
         const depositAmount = new anchor_1.BN(10000).mul(__2.QUOTE_PRECISION);
-        await clearingHouse.initializeUserAccountAndDepositCollateral(depositAmount, await (0, exports.getTokenAddress)(usdcTokenAddress.toString(), wallet.publicKey.toString()), banks_1.Banks['devnet'][0].bankIndex);
+        await driftClient.initializeUserAccountAndDepositCollateral(depositAmount, await (0, exports.getTokenAddress)(usdcTokenAddress.toString(), wallet.publicKey.toString()), spotMarkets_1.SpotMarkets['devnet'][0].marketIndex);
     }
     await user.subscribe();
     // Get current price
-    const solMarketInfo = sdkConfig.MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
-    const currentMarketPrice = (0, __2.calculateMarkPrice)(clearingHouse.getMarketAccount(solMarketInfo.marketIndex), undefined);
-    const formattedPrice = (0, __2.convertToNumber)(currentMarketPrice, __2.MARK_PRICE_PRECISION);
+    const solMarketInfo = sdkConfig.PERP_MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
+    const currentMarketPrice = (0, __2.calculateReservePrice)(driftClient.getPerpMarketAccount(solMarketInfo.marketIndex), undefined);
+    const formattedPrice = (0, __2.convertToNumber)(currentMarketPrice, __2.PRICE_PRECISION);
     console.log(`Current Market Price is $${formattedPrice}`);
     // Estimate the slippage for a $5000 LONG trade
-    const solMarketAccount = clearingHouse.getMarketAccount(solMarketInfo.marketIndex);
+    const solMarketAccount = driftClient.getPerpMarketAccount(solMarketInfo.marketIndex);
     const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
-    const slippage = (0, __2.convertToNumber)((0, __2.calculateTradeSlippage)(__2.PositionDirection.LONG, longAmount, solMarketAccount, 'quote', undefined)[0], __2.MARK_PRICE_PRECISION);
+    const slippage = (0, __2.convertToNumber)((0, __2.calculateTradeSlippage)(__2.PositionDirection.LONG, longAmount, solMarketAccount, 'quote', undefined)[0], __2.PRICE_PRECISION);
     console.log(`Slippage for a $5000 LONG on the SOL market would be $${slippage}`);
     // Make a $5000 LONG trade
-    await clearingHouse.openPosition(__2.PositionDirection.LONG, longAmount, solMarketInfo.marketIndex);
+    await driftClient.openPosition(__2.PositionDirection.LONG, longAmount, solMarketInfo.marketIndex);
     console.log(`LONGED $5000 SOL`);
     // Reduce the position by $2000
     const reduceAmount = new anchor_1.BN(2000).mul(__2.QUOTE_PRECISION);
-    await clearingHouse.openPosition(__2.PositionDirection.SHORT, reduceAmount, solMarketInfo.marketIndex);
+    await driftClient.openPosition(__2.PositionDirection.SHORT, reduceAmount, solMarketInfo.marketIndex);
     // Close the rest of the position
-    await clearingHouse.closePosition(solMarketInfo.marketIndex);
+    await driftClient.closePosition(solMarketInfo.marketIndex);
 };
 main();

package/lib/factory/bigNum.d.ts

@@ -5,7 +5,9 @@ export declare class BigNum {
     precision: BN;
     static delim: string;
     static spacer: string;
+    static setLocale(locale: string): void;
     constructor(val: BN | number | string, precisionVal?: BN | number | string);
+    private bigNumFromParam;
     add(bn: BigNum): BigNum;
     sub(bn: BigNum): BigNum;
     mul(bn: BigNum | BN): BigNum;
@@ -67,14 +69,16 @@ export declare class BigNum {
      * @param fixedPrecision
      * @returns
      */
-    toFixed(fixedPrecision: number): string;
+    toFixed(fixedPrecision: number, rounded?: boolean): string;
+    private getZeroes;
+    toRounded(roundingPrecision: number): BigNum;
     /**
      * Pretty print to the specified number of significant figures
      * @param fixedPrecision
      * @returns
      */
-    toPrecision(fixedPrecision: number, trailingZeroes?: boolean): string;
-    toTradePrecision(): string;
+    toPrecision(fixedPrecision: number, trailingZeroes?: boolean, rounded?: boolean): string;
+    toTradePrecision(rounded?: boolean): string;
     /**
      * Print dollar formatted value. Defaults to fixed decimals two unless a given precision is given.
      * @param useTradePrecision
@@ -82,7 +86,7 @@ export declare class BigNum {
      * @returns
      */
     toNotional(useTradePrecision?: boolean, precisionOverride?: number): string;
-    toMillified(precision?: number): string;
+    toMillified(precision?: number, rounded?: boolean): string;
     toJSON(): {
         val: string;
         precision: string;