@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.2

package/lib/events/eventSubscriber.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriber = void 0;
+const types_1 = require("./types");
+const txEventCache_1 = require("./txEventCache");
+const eventList_1 = require("./eventList");
+const pollingLogProvider_1 = require("./pollingLogProvider");
+const fetchLogs_1 = require("./fetchLogs");
+const webSocketLogProvider_1 = require("./webSocketLogProvider");
+const events_1 = require("events");
+const sort_1 = require("./sort");
+class EventSubscriber {
+    constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
+        this.connection = connection;
+        this.program = program;
+        this.options = options;
+        this.awaitTxPromises = new Map();
+        this.awaitTxResolver = new Map();
+        this.options = Object.assign({}, types_1.DefaultEventSubscriptionOptions, options);
+        this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
+        this.eventListMap = new Map();
+        for (const eventType of this.options.eventTypes) {
+            this.eventListMap.set(eventType, new eventList_1.EventList(eventType, this.options.maxEventsPerType, (0, sort_1.getSortFn)(this.options.orderBy, this.options.orderDir, eventType), this.options.orderDir));
+        }
+        this.eventEmitter = new events_1.EventEmitter();
+        if (this.options.logProviderConfig.type === 'websocket') {
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.program.programId, this.options.commitment);
+        }
+        else {
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.program.programId, options.commitment, this.options.logProviderConfig.frequency);
+        }
+    }
+    subscribe() {
+        if (this.logProvider.isSubscribed()) {
+            return true;
+        }
+        this.fetchPreviousTx().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);
+        });
+    }
+    handleTxLogs(txSig, slot, logs) {
+        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);
+            this.eventEmitter.emit('newEvent', wrappedEvent);
+        }
+        if (this.awaitTxPromises.has(txSig)) {
+            this.awaitTxPromises.delete(txSig);
+            this.awaitTxResolver.get(txSig)();
+            this.awaitTxResolver.delete(txSig);
+        }
+        this.txEventCache.add(txSig, wrappedEvents);
+    }
+    async fetchPreviousTx() {
+        if (!this.options.untilTx) {
+            return;
+        }
+        let txFetched = 0;
+        let beforeTx = undefined;
+        const untilTx = this.options.untilTx;
+        while (txFetched < this.options.maxTx) {
+            const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.program.programId, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+            if (response === undefined) {
+                break;
+            }
+            txFetched += response.transactionLogs.length;
+            beforeTx = response.earliestTx;
+            for (const { txSig, slot, logs } of response.transactionLogs) {
+                this.handleTxLogs(txSig, slot, logs);
+            }
+        }
+    }
+    async unsubscribe() {
+        return await this.logProvider.unsubscribe();
+    }
+    parseEventsFromLogs(txSig, slot, logs) {
+        const records = [];
+        // @ts-ignore
+        this.program._events._eventParser.parseLogs(logs, (event) => {
+            const expectRecordType = this.eventListMap.has(event.name);
+            if (expectRecordType) {
+                event.data.txSig = txSig;
+                event.data.slot = slot;
+                event.data.eventType = event.name;
+                records.push(event.data);
+            }
+        });
+        return records;
+    }
+    awaitTx(txSig) {
+        if (this.awaitTxPromises.has(txSig)) {
+            return this.awaitTxPromises.get(txSig);
+        }
+        if (this.txEventCache.has(txSig)) {
+            return Promise.resolve();
+        }
+        const promise = new Promise((resolve) => {
+            this.awaitTxResolver.set(txSig, resolve);
+        });
+        this.awaitTxPromises.set(txSig, promise);
+        return promise;
+    }
+    getEventList(eventType) {
+        return this.eventListMap.get(eventType);
+    }
+    /**
+     * This requires the EventList be cast to an array, which requires reallocation of memory.
+     * Would bias to using getEventList over getEvents
+     *
+     * @param eventType
+     */
+    getEventsArray(eventType) {
+        return this.eventListMap.get(eventType).toArray();
+    }
+    getEventsByTx(txSig) {
+        return this.txEventCache.get(txSig);
+    }
+}
+exports.EventSubscriber = EventSubscriber;

package/lib/events/fetchLogs.d.ts

@@ -0,0 +1,13 @@
+import { Connection, Finality, PublicKey, TransactionSignature } from '@solana/web3.js';
+declare type Log = {
+    txSig: TransactionSignature;
+    slot: number;
+    logs: string[];
+};
+declare type FetchLogsResponse = {
+    earliestTx: string;
+    mostRecentTx: string;
+    transactionLogs: Log[];
+};
+export declare function fetchLogs(connection: Connection, programId: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature): Promise<FetchLogsResponse | undefined>;
+export {};

package/lib/events/fetchLogs.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchLogs = void 0;
+async function fetchLogs(connection, programId, finality, beforeTx, untilTx) {
+    const signatures = await connection.getSignaturesForAddress(programId, {
+        before: beforeTx,
+        until: untilTx,
+    }, finality);
+    const sortedSignatures = signatures.sort((a, b) => a.slot < b.slot ? -1 : 1);
+    const filteredSignatures = sortedSignatures.filter((signature) => !signature.err);
+    if (filteredSignatures.length === 0) {
+        return undefined;
+    }
+    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,
+            };
+        });
+    }))).flat();
+    const earliestTx = filteredSignatures[0].signature;
+    const mostRecentTx = filteredSignatures[filteredSignatures.length - 1].signature;
+    return {
+        transactionLogs: transactionLogs,
+        earliestTx: earliestTx,
+        mostRecentTx: mostRecentTx,
+    };
+}
+exports.fetchLogs = fetchLogs;
+function chunk(array, size) {
+    return new Array(Math.ceil(array.length / size))
+        .fill(null)
+        .map((_, index) => index * size)
+        .map((begin) => array.slice(begin, begin + size));
+}

package/lib/events/pollingLogProvider.d.ts

@@ -0,0 +1,15 @@
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+export declare class PollingLogProvider implements LogProvider {
+    private connection;
+    private programId;
+    private frequency;
+    private finality;
+    private intervalId;
+    private mostRecentSeenTx?;
+    private mutex;
+    constructor(connection: Connection, programId: PublicKey, commitment: Commitment, frequency?: number);
+    subscribe(callback: logProviderCallback): boolean;
+    isSubscribed(): boolean;
+    unsubscribe(): Promise<boolean>;
+}

package/lib/events/pollingLogProvider.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingLogProvider = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+class PollingLogProvider {
+    constructor(connection, programId, commitment, frequency = 15 * 1000) {
+        this.connection = connection;
+        this.programId = programId;
+        this.frequency = frequency;
+        this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+    }
+    subscribe(callback) {
+        if (this.intervalId) {
+            return true;
+        }
+        this.intervalId = setInterval(async () => {
+            if (this.mutex === 1) {
+                return;
+            }
+            this.mutex = 1;
+            try {
+                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.programId, this.finality, undefined, this.mostRecentSeenTx);
+                if (response === undefined) {
+                    return;
+                }
+                const { mostRecentTx, transactionLogs } = response;
+                for (const { txSig, slot, logs } of transactionLogs) {
+                    callback(txSig, slot, logs);
+                }
+                this.mostRecentSeenTx = mostRecentTx;
+            }
+            catch (e) {
+                console.error('PollingLogProvider threw an Error');
+                console.error(e);
+            }
+            finally {
+                this.mutex = 0;
+            }
+        }, this.frequency);
+        return true;
+    }
+    isSubscribed() {
+        return this.intervalId !== undefined;
+    }
+    async unsubscribe() {
+        if (this.intervalId !== undefined) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+        return true;
+    }
+}
+exports.PollingLogProvider = PollingLogProvider;

package/lib/events/sort.d.ts

@@ -0,0 +1,2 @@
+import { EventSubscriptionOrderBy, EventSubscriptionOrderDirection, EventType, SortFn } from './types';
+export declare function getSortFn(orderBy: EventSubscriptionOrderBy, orderDir: EventSubscriptionOrderDirection, eventType: EventType): SortFn;

package/lib/events/sort.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFn = void 0;
+const index_1 = require("../index");
+function clientSortAscFn() {
+    return 'less than';
+}
+function clientSortDescFn() {
+    return 'greater than';
+}
+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)) {
+        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+    }
+    if (currentEvent.fillRecordId.gt(index_1.ZERO) && newEvent.fillRecordId.gt(index_1.ZERO)) {
+        return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+            ? 'less than'
+            : 'greater than';
+    }
+    else {
+        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+    }
+}
+function getSortFn(orderBy, orderDir, eventType) {
+    if (orderBy === 'client') {
+        return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+    }
+    switch (eventType) {
+        case 'OrderRecord':
+            return orderRecordSortFn;
+        default:
+            return defaultBlockchainSortFn;
+    }
+}
+exports.getSortFn = getSortFn;

package/lib/events/txEventCache.d.ts

@@ -0,0 +1,24 @@
+import { WrappedEvent, EventType } from './types';
+declare class Node {
+    key: string;
+    value: WrappedEvent<EventType>[];
+    next?: Node;
+    prev?: Node;
+    constructor(key: string, value: WrappedEvent<EventType>[], next?: Node, prev?: Node);
+}
+export declare class TxEventCache {
+    maxTx: number;
+    size: number;
+    head?: Node;
+    tail?: Node;
+    cacheMap: {
+        [key: string]: Node;
+    };
+    constructor(maxTx?: number);
+    add(key: string, events: WrappedEvent<EventType>[]): void;
+    has(key: string): boolean;
+    get(key: string): WrappedEvent<EventType>[] | undefined;
+    detach(node: Node): void;
+    clear(): void;
+}
+export {};

package/lib/events/txEventCache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxEventCache = void 0;
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+// lru cache
+class TxEventCache {
+    constructor(maxTx = 1024) {
+        this.maxTx = maxTx;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
+        if (existingNode) {
+            this.detach(existingNode);
+            this.size--;
+        }
+        else if (this.size === this.maxTx) {
+            delete this.cacheMap[this.tail.key];
+            this.detach(this.tail);
+            this.size--;
+        }
+        // Write to head of LinkedList
+        if (!this.head) {
+            this.head = this.tail = new Node(key, events);
+        }
+        else {
+            const node = new Node(key, events, this.head);
+            this.head.prev = node;
+            this.head = node;
+        }
+        // update cacheMap with LinkedList key and Node reference
+        this.cacheMap[key] = this.head;
+        this.size++;
+    }
+    has(key) {
+        return this.cacheMap.hasOwnProperty(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    detach(node) {
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+}
+exports.TxEventCache = TxEventCache;

package/lib/events/types.d.ts

@@ -0,0 +1,49 @@
+import { Commitment, TransactionSignature } from '@solana/web3.js';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, OrderRecord } from '../index';
+export declare type EventSubscriptionOptions = {
+    eventTypes?: EventType[];
+    maxEventsPerType?: number;
+    orderBy?: EventSubscriptionOrderBy;
+    orderDir?: EventSubscriptionOrderDirection;
+    commitment?: Commitment;
+    maxTx?: number;
+    logProviderConfig?: LogProviderConfig;
+    untilTx?: TransactionSignature;
+};
+export declare const DefaultEventSubscriptionOptions: EventSubscriptionOptions;
+export declare type EventSubscriptionOrderBy = 'blockchain' | 'client';
+export declare type EventSubscriptionOrderDirection = 'asc' | 'desc';
+export declare type Event<T> = T & {
+    txSig: TransactionSignature;
+    slot: number;
+};
+export declare type WrappedEvent<Type extends EventType> = EventMap[Type] & {
+    eventType: Type;
+};
+export declare type WrappedEvents = WrappedEvent<EventType>[];
+export declare type EventMap = {
+    DepositRecord: Event<DepositRecord>;
+    FundingPaymentRecord: Event<FundingPaymentRecord>;
+    LiquidationRecord: Event<LiquidationRecord>;
+    FundingRateRecord: Event<FundingRateRecord>;
+    OrderRecord: Event<OrderRecord>;
+};
+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 interface LogProvider {
+    isSubscribed(): boolean;
+    subscribe(callback: logProviderCallback): boolean;
+    unsubscribe(): Promise<boolean>;
+}
+export declare type WebSocketLogProviderConfig = {
+    type: 'websocket';
+};
+export declare type PollingLogProviderConfig = {
+    type: 'polling';
+    frequency: number;
+};
+export declare type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig;

package/lib/events/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEventSubscriptionOptions = void 0;
+exports.DefaultEventSubscriptionOptions = {
+    eventTypes: [
+        'DepositRecord',
+        'FundingPaymentRecord',
+        'LiquidationRecord',
+        'OrderRecord',
+        'FundingRateRecord',
+    ],
+    maxEventsPerType: 4096,
+    orderBy: 'blockchain',
+    orderDir: 'asc',
+    commitment: 'confirmed',
+    maxTx: 4096,
+    logProviderConfig: {
+        type: 'websocket',
+    },
+};

package/lib/events/webSocketLogProvider.d.ts

@@ -0,0 +1,12 @@
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+export declare class WebSocketLogProvider implements LogProvider {
+    private connection;
+    private programId;
+    private commitment;
+    private subscriptionId;
+    constructor(connection: Connection, programId: PublicKey, commitment: Commitment);
+    subscribe(callback: logProviderCallback): boolean;
+    isSubscribed(): boolean;
+    unsubscribe(): Promise<boolean>;
+}

package/lib/events/webSocketLogProvider.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketLogProvider = void 0;
+class WebSocketLogProvider {
+    constructor(connection, programId, commitment) {
+        this.connection = connection;
+        this.programId = programId;
+        this.commitment = commitment;
+    }
+    subscribe(callback) {
+        if (this.subscriptionId) {
+            return true;
+        }
+        this.subscriptionId = this.connection.onLogs(this.programId, (logs, ctx) => {
+            callback(logs.signature, ctx.slot, logs.logs);
+        }, this.commitment);
+        return true;
+    }
+    isSubscribed() {
+        return this.subscriptionId !== undefined;
+    }
+    async unsubscribe() {
+        if (this.subscriptionId !== undefined) {
+            await this.connection.removeOnLogsListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+        }
+        return true;
+    }
+}
+exports.WebSocketLogProvider = WebSocketLogProvider;

package/lib/examples/makeTradeExample.js

@@ -1,13 +1,4 @@
 "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.getTokenAddress = void 0;
 const anchor_1 = require("@project-serum/anchor");
@@ -15,11 +6,12 @@ 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 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 main = () => __awaiter(void 0, void 0, void 0, function* () {
+const main = async () => {
     // Initialize Drift SDK
     const sdkConfig = (0, __2.initialize)({ env: 'devnet' });
     // Set up the Wallet and Provider
@@ -32,41 +24,48 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
     // Set up the Provider
     const provider = new anchor_1.AnchorProvider(connection, wallet, anchor_1.AnchorProvider.defaultOptions());
     // Check SOL Balance
-    const lamportsBalance = yield connection.getBalance(wallet.publicKey);
-    console.log('SOL balance:', lamportsBalance / Math.pow(10, 9));
+    const lamportsBalance = await connection.getBalance(wallet.publicKey);
+    console.log('SOL balance:', lamportsBalance / 10 ** 9);
     // Misc. other things to set up
-    const usdcTokenAddress = yield (0, exports.getTokenAddress)(sdkConfig.USDC_MINT_ADDRESS, wallet.publicKey.toString());
+    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 = __2.ClearingHouse.from(connection, provider.wallet, clearingHousePublicKey);
-    yield clearingHouse.subscribe();
+    const clearingHouse = new __2.ClearingHouse({
+        connection,
+        wallet: provider.wallet,
+        programID: clearingHousePublicKey,
+    });
+    await clearingHouse.subscribe();
     // Set up Clearing House user client
-    const user = __2.ClearingHouseUser.from(clearingHouse, wallet.publicKey);
+    const user = new __2.ClearingHouseUser({
+        clearingHouse,
+        userAccountPublicKey: await clearingHouse.getUserAccountPublicKey(),
+    });
     //// Check if clearing house account exists for the current wallet
-    const userAccountExists = yield user.exists();
+    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);
-        yield clearingHouse.initializeUserAccountAndDepositCollateral(depositAmount, yield (0, exports.getTokenAddress)(usdcTokenAddress.toString(), wallet.publicKey.toString()));
+        await clearingHouse.initializeUserAccountAndDepositCollateral(depositAmount, await (0, exports.getTokenAddress)(usdcTokenAddress.toString(), wallet.publicKey.toString()), banks_1.Banks['devnet'][0].bankIndex);
     }
-    yield user.subscribe();
+    await user.subscribe();
     // Get current price
-    const solMarketInfo = __2.Markets.find((market) => market.baseAssetSymbol === 'SOL');
-    const currentMarketPrice = (0, __2.calculateMarkPrice)(clearingHouse.getMarket(solMarketInfo.marketIndex));
+    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);
     console.log(`Current Market Price is $${formattedPrice}`);
     // Estimate the slippage for a $5000 LONG trade
-    const solMarketAccount = clearingHouse.getMarket(solMarketInfo.marketIndex);
+    const solMarketAccount = clearingHouse.getMarketAccount(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)[0], __2.MARK_PRICE_PRECISION);
+    const slippage = (0, __2.convertToNumber)((0, __2.calculateTradeSlippage)(__2.PositionDirection.LONG, longAmount, solMarketAccount, 'quote', undefined)[0], __2.MARK_PRICE_PRECISION);
     console.log(`Slippage for a $5000 LONG on the SOL market would be $${slippage}`);
     // Make a $5000 LONG trade
-    yield clearingHouse.openPosition(__2.PositionDirection.LONG, longAmount, solMarketInfo.marketIndex);
+    await clearingHouse.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);
-    yield clearingHouse.openPosition(__2.PositionDirection.SHORT, reduceAmount, solMarketInfo.marketIndex);
+    await clearingHouse.openPosition(__2.PositionDirection.SHORT, reduceAmount, solMarketInfo.marketIndex);
     // Close the rest of the position
-    yield clearingHouse.closePosition(solMarketInfo.marketIndex);
-});
+    await clearingHouse.closePosition(solMarketInfo.marketIndex);
+};
 main();