@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.30

package/lib/dlob/NodeList.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="bn.js" />
+import { BN, MarketTypeStr, Order, PerpMarketAccount, SpotMarketAccount } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { DLOBNode, DLOBNodeMap } from './DLOBNode';
+export declare type SortDirection = 'asc' | 'desc';
+export declare function getOrderSignature(orderId: BN, userAccount: PublicKey): string;
+export interface DLOBNodeGenerator {
+    getGenerator(): Generator<DLOBNode>;
+}
+export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLOBNodeGenerator {
+    private nodeType;
+    private sortDirection;
+    head?: DLOBNodeMap[NodeType];
+    length: number;
+    nodeMap: Map<string, DLOBNodeMap[NodeType]>;
+    constructor(nodeType: NodeType, sortDirection: SortDirection);
+    insert(order: Order, marketType: MarketTypeStr, market: PerpMarketAccount | SpotMarketAccount, userAccount: PublicKey): void;
+    prependNode(currentNode: DLOBNodeMap[NodeType], newNode: DLOBNodeMap[NodeType]): boolean;
+    update(order: Order, userAccount: PublicKey): void;
+    remove(order: Order, userAccount: PublicKey): void;
+    getGenerator(): Generator<DLOBNode>;
+    has(order: Order, userAccount: PublicKey): boolean;
+    print(): void;
+    printTop(): void;
+}
+export declare function getVammNodeGenerator(price: BN | undefined): Generator<DLOBNode>;

package/lib/dlob/NodeList.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVammNodeGenerator = exports.NodeList = exports.getOrderSignature = void 0;
+const __1 = require("..");
+const DLOBNode_1 = require("./DLOBNode");
+function getOrderSignature(orderId, userAccount) {
+    return `${userAccount.toString()}-${orderId.toString()}`;
+}
+exports.getOrderSignature = getOrderSignature;
+class NodeList {
+    constructor(nodeType, sortDirection) {
+        this.nodeType = nodeType;
+        this.sortDirection = sortDirection;
+        this.length = 0;
+        this.nodeMap = new Map();
+    }
+    insert(order, marketType, market, userAccount) {
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        if (marketType === 'spot') {
+            market = market;
+        }
+        else if (marketType === 'perp') {
+            market = market;
+        }
+        const newNode = (0, DLOBNode_1.createNode)(this.nodeType, order, market, userAccount);
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            return;
+        }
+        this.nodeMap.set(orderId, newNode);
+        this.length += 1;
+        if (this.head === undefined) {
+            this.head = newNode;
+            return;
+        }
+        if (this.prependNode(this.head, newNode)) {
+            this.head.previous = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+            return;
+        }
+        let currentNode = this.head;
+        while (currentNode.next !== undefined &&
+            !this.prependNode(currentNode.next, newNode)) {
+            currentNode = currentNode.next;
+        }
+        newNode.next = currentNode.next;
+        if (currentNode.next !== undefined) {
+            newNode.next.previous = newNode;
+        }
+        currentNode.next = newNode;
+        newNode.previous = currentNode;
+    }
+    prependNode(currentNode, newNode) {
+        const currentOrder = currentNode.order;
+        const newOrder = newNode.order;
+        const currentOrderSortPrice = currentNode.sortValue;
+        const newOrderSortPrice = newNode.sortValue;
+        if (newOrderSortPrice.eq(currentOrderSortPrice)) {
+            return newOrder.ts.lt(currentOrder.ts);
+        }
+        if (this.sortDirection === 'asc') {
+            return newOrderSortPrice.lt(currentOrderSortPrice);
+        }
+        else {
+            return newOrderSortPrice.gt(currentOrderSortPrice);
+        }
+    }
+    update(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            Object.assign(node.order, order);
+            node.haveFilled = false;
+        }
+    }
+    remove(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            if (node.next) {
+                node.next.previous = node.previous;
+            }
+            if (node.previous) {
+                node.previous.next = node.next;
+            }
+            if (this.head && node.order.orderId.eq(this.head.order.orderId)) {
+                this.head = node.next;
+            }
+            node.previous = undefined;
+            node.next = undefined;
+            this.nodeMap.delete(orderId);
+            this.length--;
+        }
+    }
+    *getGenerator() {
+        let node = this.head;
+        while (node !== undefined) {
+            yield node;
+            node = node.next;
+        }
+    }
+    has(order, userAccount) {
+        return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+    }
+    print() {
+        let currentNode = this.head;
+        while (currentNode !== undefined) {
+            console.log(currentNode.getLabel());
+            currentNode = currentNode.next;
+        }
+    }
+    printTop() {
+        if (this.head) {
+            console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+        }
+        else {
+            console.log('---');
+        }
+    }
+}
+exports.NodeList = NodeList;
+function* getVammNodeGenerator(price) {
+    if (!price) {
+        return;
+    }
+    yield {
+        getPrice: () => price,
+        isVammNode: () => true,
+        order: undefined,
+        market: undefined,
+        userAccount: undefined,
+        haveFilled: false,
+    };
+}
+exports.getVammNodeGenerator = getVammNodeGenerator;

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;
         }

package/lib/events/eventSubscriber.d.ts

@@ -15,10 +15,12 @@ export declare class EventSubscriber {
     private awaitTxResolver;
     private logProvider;
     eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+    private lastSeenSlot;
+    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,17 +30,21 @@ 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) => {
+                this.handleTxLogs(txSig, slot, logs);
+            }, 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) {
         if (this.txEventCache.has(txSig)) {
@@ -56,10 +60,13 @@ class EventSubscriber {
             this.awaitTxResolver.get(txSig)();
             this.awaitTxResolver.delete(txSig);
         }
+        if (slot > this.lastSeenSlot) {
+            this.lastSeenTxSig = txSig;
+        }
         this.txEventCache.add(txSig, wrappedEvents);
     }
-    async fetchPreviousTx() {
-        if (!this.options.untilTx) {
+    async fetchPreviousTx(fetchMax) {
+        if (!this.options.untilTx && !fetchMax) {
             return;
         }
         let txFetched = 0;

package/lib/events/fetchLogs.d.ts

@@ -1,4 +1,6 @@
+import { Program } from '@project-serum/anchor';
 import { Connection, Finality, PublicKey, TransactionSignature } from '@solana/web3.js';
+import { WrappedEvents } from './types';
 declare type Log = {
     txSig: TransactionSignature;
     slot: number;
@@ -7,7 +9,14 @@ declare type Log = {
 declare type FetchLogsResponse = {
     earliestTx: string;
     mostRecentTx: string;
+    earliestSlot: number;
+    mostRecentSlot: number;
     transactionLogs: Log[];
 };
-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);
+    parseEventsFromLogs(event: Log): WrappedEvents;
+}
 export {};

package/lib/events/fetchLogs.js

@@ -1,12 +1,13 @@
 "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;
+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;
@@ -22,12 +23,14 @@ async function fetchLogs(connection, programId, finality, beforeTx, untilTx) {
             };
         });
     }))).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,
     };
 }
 exports.fetchLogs = fetchLogs;
@@ -37,3 +40,20 @@ function chunk(array, size) {
         .map((_, index) => index * size)
         .map((begin) => array.slice(begin, begin + size));
 }
+class LogParser {
+    constructor(program) {
+        this.program = program;
+    }
+    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,7 +20,10 @@ 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;
                 }

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/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 } from '../index';
 export declare type EventSubscriptionOptions = {
     eventTypes?: EventType[];
     maxEventsPerType?: number;
@@ -27,6 +27,11 @@ 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>;
 };
 export declare type EventType = keyof EventMap;
 export interface EventSubscriberEvents {
@@ -36,7 +41,7 @@ export declare type SortFn = (currentRecord: EventMap[EventType], newRecord: Eve
 export declare type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[]) => 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,12 @@ exports.DefaultEventSubscriptionOptions = {
         'FundingPaymentRecord',
         'LiquidationRecord',
         'OrderRecord',
+        'OrderActionRecord',
         'FundingRateRecord',
+        'NewUserRecord',
+        'SettlePnlRecord',
+        'LPRecord',
+        'InsuranceFundRecord',
     ],
     maxEventsPerType: 4096,
     orderBy: 'blockchain',

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)));
@@ -30,34 +31,45 @@ const main = async () => {
     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 bulkAccountLoader = new __2.BulkAccountLoader(connection, 'confirmed', 1000);
     const clearingHouse = new __2.ClearingHouse({
         connection,
         wallet: provider.wallet,
         programID: clearingHousePublicKey,
+        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();
     // Set up Clearing House user client
     const user = new __2.ClearingHouseUser({
         clearingHouse,
         userAccountPublicKey: await clearingHouse.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 clearingHouse.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)(clearingHouse.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 = clearingHouse.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);

package/lib/factory/bigNum.d.ts

@@ -6,6 +6,7 @@ export declare class BigNum {
     static delim: string;
     static spacer: string;
     constructor(val: BN | number | string, precisionVal?: BN | number | string);
+    private bigNumFromParam;
     add(bn: BigNum): BigNum;
     sub(bn: BigNum): BigNum;
     mul(bn: BigNum | BN): BigNum;

package/lib/factory/bigNum.js

@@ -10,6 +10,9 @@ class BigNum {
         this.val = new anchor_1.BN(val);
         this.precision = new anchor_1.BN(precisionVal);
     }
+    bigNumFromParam(bn) {
+        return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
+    }
     add(bn) {
         (0, assert_1.assert)(bn.precision.eq(this.precision), 'Adding unequal precisions');
         return BigNum.from(this.val.add(bn.val), this.precision);
@@ -19,7 +22,7 @@ class BigNum {
         return BigNum.from(this.val.sub(bn.val), this.precision);
     }
     mul(bn) {
-        const mulVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const mulVal = this.bigNumFromParam(bn);
         return BigNum.from(this.val.mul(mulVal.val), this.precision.add(mulVal.precision));
     }
     /**
@@ -28,12 +31,12 @@ class BigNum {
      * @returns
      */
     scalarMul(bn) {
-        if (bn instanceof anchor_1.BN)
+        if (anchor_1.BN.isBN(bn))
             return BigNum.from(this.val.mul(bn), this.precision);
         return BigNum.from(this.val.mul(bn.val), this.precision.add(bn.precision)).shift(bn.precision.neg());
     }
     div(bn) {
-        if (bn instanceof anchor_1.BN)
+        if (anchor_1.BN.isBN(bn))
             return BigNum.from(this.val.div(bn), this.precision);
         return BigNum.from(this.val.div(bn.val), this.precision.sub(bn.precision));
     }
@@ -73,35 +76,35 @@ class BigNum {
             .toPrecision(precision);
     }
     gt(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.gt(comparisonVal.val);
     }
     lt(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.lt(comparisonVal.val);
     }
     gte(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.gte(comparisonVal.val);
     }
     lte(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.lte(comparisonVal.val);
     }
     eq(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
@@ -134,7 +137,8 @@ class BigNum {
      */
     print() {
         (0, assert_1.assert)(this.precision.gte(numericConstants_1.ZERO), 'Tried to print a BN with precision lower than zero');
-        const plainString = this.toString();
+        const isNeg = this.isNeg();
+        const plainString = this.abs().toString();
         const precisionNum = this.precision.toNumber();
         // make a string with at least the precisionNum number of zeroes
         let printString = [
@@ -151,6 +155,9 @@ class BigNum {
         // add zero if leading delim
         if (printString[0] === BigNum.delim)
             printString = `0${printString}`;
+        // Add minus if negative
+        if (isNeg)
+            printString = `-${printString}`;
         // remove trailing delim
         if (printString[printString.length - 1] === BigNum.delim)
             printString = printString.slice(0, printString.length - 1);
@@ -261,10 +268,27 @@ class BigNum {
      * @returns
      */
     toNotional(useTradePrecision, precisionOverride) {
+        var _a;
         const prefix = `${this.lt(BigNum.zero()) ? `-` : ``}$`;
-        const val = useTradePrecision || precisionOverride
+        const usingCustomPrecision = true && (useTradePrecision || precisionOverride);
+        let val = usingCustomPrecision
             ? this.prettyPrint(useTradePrecision, precisionOverride)
             : BigNum.fromPrint(this.toFixed(2), new anchor_1.BN(2)).prettyPrint();
+        // Append two trailing zeroes if not using custom precision
+        if (!usingCustomPrecision) {
+            const [_, rightSide] = val.split(BigNum.delim);
+            const trailingLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
+            if (trailingLength < 2) {
+                const numHasDecimals = this.print().includes(BigNum.delim);
+                // Handle case where pretty print won't include the decimal point
+                if (trailingLength === 0 && numHasDecimals) {
+                    val = `${val}.00`;
+                }
+                else {
+                    val = `${val}${new Array(2 - trailingLength).fill('0').join('')}`;
+                }
+            }
+        }
         return `${prefix}${val.replace('-', '')}`;
     }
     toMillified(precision = 3) {