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

package/lib/accounts/types.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
+/// <reference types="node" />
 import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';

package/lib/idl/clearing_house.json

@@ -5164,6 +5164,11 @@
             "code": 6118,
             "name": "TryingToRemoveLiquidityTooFast",
             "msg": "Trying to remove liqudity too fast after adding it"
+        },
+        {
+            "code": 6119,
+            "name": "InvalidBankState",
+            "msg": "Invalid Bank State"
         }
     ]
 }

package/lib/math/amm.js

@@ -371,10 +371,10 @@ function calculateMaxBaseAssetAmountFillable(amm, orderDirection) {
     const maxFillSize = amm.baseAssetReserve.div(new anchor_1.BN(amm.maxBaseAssetAmountRatio));
     let maxBaseAssetAmountOnSide;
     if ((0, types_1.isVariant)(orderDirection, 'long')) {
-        maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.maxBaseAssetReserve.sub(amm.baseAssetReserve));
+        maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.baseAssetReserve.sub(amm.minBaseAssetReserve));
     }
     else {
-        maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.baseAssetReserve.sub(amm.minBaseAssetReserve));
+        maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.maxBaseAssetReserve.sub(amm.baseAssetReserve));
     }
     return (0, __1.standardizeBaseAssetAmount)(anchor_1.BN.min(maxFillSize, maxBaseAssetAmountOnSide), amm.baseAssetAmountStepSize);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.21",
+	"version": "0.2.0-master.22",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/addresses/marketAddresses.js

@@ -0,0 +1,26 @@
+"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.getMarketAddress = void 0;
+const pda_1 = require("./pda");
+const CACHE = new Map();
+function getMarketAddress(programId, marketIndex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cacheKey = `${programId.toString()}-${marketIndex.toString()}`;
+        if (CACHE.has(cacheKey)) {
+            return CACHE.get(cacheKey);
+        }
+        const publicKey = yield pda_1.getMarketPublicKey(programId, marketIndex);
+        CACHE.set(cacheKey, publicKey);
+        return publicKey;
+    });
+}
+exports.getMarketAddress = getMarketAddress;

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;

package/src/constants/banks.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Banks = exports.MainnetBanks = exports.DevnetBanks = exports.WRAPPED_SOL_MINT = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const __1 = require("../");
+exports.WRAPPED_SOL_MINT = new web3_js_1.PublicKey('So11111111111111111111111111111111111111112');
+exports.DevnetBanks = [
+    {
+        symbol: 'USDC',
+        bankIndex: new __1.BN(0),
+        oracle: web3_js_1.PublicKey.default,
+        oracleSource: __1.OracleSource.QUOTE_ASSET,
+        mint: new web3_js_1.PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
+    },
+    {
+        symbol: 'SOL',
+        bankIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey(exports.WRAPPED_SOL_MINT),
+    },
+    {
+        symbol: 'BTC',
+        bankIndex: new __1.BN(2),
+        oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
+    },
+];
+exports.MainnetBanks = [
+    {
+        symbol: 'USDC',
+        bankIndex: new __1.BN(0),
+        oracle: web3_js_1.PublicKey.default,
+        oracleSource: __1.OracleSource.QUOTE_ASSET,
+        mint: new web3_js_1.PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+    },
+];
+exports.Banks = {
+    devnet: exports.DevnetBanks,
+    'mainnet-beta': exports.MainnetBanks,
+};

package/src/constants/markets.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Markets = exports.MainnetMarkets = exports.DevnetMarkets = void 0;
+const __1 = require("../");
+const web3_js_1 = require("@solana/web3.js");
+exports.DevnetMarkets = [
+    {
+        fullName: 'Solana',
+        category: ['L1', 'Infra'],
+        symbol: 'SOL-PERP',
+        baseAssetSymbol: 'SOL',
+        marketIndex: new __1.BN(0),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        launchTs: 1655751353000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+    {
+        fullName: 'Bitcoin',
+        category: ['L1', 'Payment'],
+        symbol: 'BTC-PERP',
+        baseAssetSymbol: 'BTC',
+        marketIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
+        launchTs: 1655751353000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+    {
+        fullName: 'Ethereum',
+        category: ['L1', 'Infra'],
+        symbol: 'ETH-PERP',
+        baseAssetSymbol: 'ETH',
+        marketIndex: new __1.BN(2),
+        oracle: new web3_js_1.PublicKey('EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw'),
+        launchTs: 1637691133472,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+];
+exports.MainnetMarkets = [];
+exports.Markets = {
+    devnet: exports.DevnetMarkets,
+    'mainnet-beta': [],
+};

package/src/constants/numericConstants.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUOTE_ASSET_BANK_INDEX = exports.ONE_YEAR = exports.BID_ASK_SPREAD_PRECISION = exports.MARGIN_PRECISION = exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.PRICE_TO_QUOTE_PRECISION = exports.PRICE_DIV_PEG = exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.BASE_PRECISION_EXP = exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION = exports.PEG_PRECISION = exports.FUNDING_PAYMENT_PRECISION = exports.MARK_PRICE_PRECISION = exports.QUOTE_PRECISION = exports.LIQUIDATION_FEE_PRECISION = exports.BANK_BALANCE_PRECISION = exports.BANK_BALANCE_PRECISION_EXP = exports.BANK_WEIGHT_PRECISION = exports.BANK_RATE_PRECISION = exports.BANK_UTILIZATION_PRECISION = exports.BANK_CUMULATIVE_INTEREST_PRECISION = exports.BANK_INTEREST_PRECISION = exports.AMM_RESERVE_PRECISION_EXP = exports.PEG_PRECISION_EXP = exports.FUNDING_RATE_PRECISION_EXP = exports.MARK_PRICE_PRECISION_EXP = exports.FUNDING_PAYMENT_PRECISION_EXP = exports.QUOTE_PRECISION_EXP = exports.MAX_LEVERAGE = exports.TEN_MILLION = exports.BN_MAX = exports.TEN_THOUSAND = exports.TEN = exports.TWO = exports.ONE = exports.ZERO = void 0;
+const __1 = require("../");
+exports.ZERO = new __1.BN(0);
+exports.ONE = new __1.BN(1);
+exports.TWO = new __1.BN(2);
+exports.TEN = new __1.BN(10);
+exports.TEN_THOUSAND = new __1.BN(10000);
+exports.BN_MAX = new __1.BN(Number.MAX_SAFE_INTEGER);
+exports.TEN_MILLION = exports.TEN_THOUSAND.mul(exports.TEN_THOUSAND);
+exports.MAX_LEVERAGE = new __1.BN(5);
+exports.QUOTE_PRECISION_EXP = new __1.BN(6);
+exports.FUNDING_PAYMENT_PRECISION_EXP = new __1.BN(4);
+exports.MARK_PRICE_PRECISION_EXP = new __1.BN(10);
+exports.FUNDING_RATE_PRECISION_EXP = exports.MARK_PRICE_PRECISION_EXP.mul(exports.FUNDING_PAYMENT_PRECISION_EXP);
+exports.PEG_PRECISION_EXP = new __1.BN(3);
+exports.AMM_RESERVE_PRECISION_EXP = new __1.BN(13);
+exports.BANK_INTEREST_PRECISION = new __1.BN(1000000);
+exports.BANK_CUMULATIVE_INTEREST_PRECISION = new __1.BN(10000000000);
+exports.BANK_UTILIZATION_PRECISION = new __1.BN(1000000);
+exports.BANK_RATE_PRECISION = new __1.BN(1000000);
+exports.BANK_WEIGHT_PRECISION = new __1.BN(100);
+exports.BANK_BALANCE_PRECISION_EXP = new __1.BN(6);
+exports.BANK_BALANCE_PRECISION = new __1.BN(10).pow(exports.BANK_BALANCE_PRECISION_EXP);
+exports.LIQUIDATION_FEE_PRECISION = new __1.BN(1000000);
+exports.QUOTE_PRECISION = new __1.BN(10).pow(exports.QUOTE_PRECISION_EXP);
+exports.MARK_PRICE_PRECISION = new __1.BN(10).pow(exports.MARK_PRICE_PRECISION_EXP);
+exports.FUNDING_PAYMENT_PRECISION = new __1.BN(10).pow(exports.FUNDING_PAYMENT_PRECISION_EXP);
+exports.PEG_PRECISION = new __1.BN(10).pow(exports.PEG_PRECISION_EXP);
+exports.AMM_RESERVE_PRECISION = new __1.BN(10).pow(exports.AMM_RESERVE_PRECISION_EXP);
+exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION;
+exports.BASE_PRECISION_EXP = exports.AMM_RESERVE_PRECISION_EXP;
+exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.AMM_RESERVE_PRECISION.div(exports.QUOTE_PRECISION); // 10^7
+exports.PRICE_DIV_PEG = exports.MARK_PRICE_PRECISION.div(exports.PEG_PRECISION); //10^7
+exports.PRICE_TO_QUOTE_PRECISION = exports.MARK_PRICE_PRECISION.div(exports.QUOTE_PRECISION);
+exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.AMM_RESERVE_PRECISION.mul(exports.PEG_PRECISION).div(exports.QUOTE_PRECISION); // 10^10
+exports.MARGIN_PRECISION = exports.TEN_THOUSAND;
+exports.BID_ASK_SPREAD_PRECISION = new __1.BN(1000000);
+exports.ONE_YEAR = new __1.BN(31536000);
+exports.QUOTE_ASSET_BANK_INDEX = new __1.BN(0);

package/src/events/eventList.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventList = void 0;
+class Node {
+    constructor(event, next, prev) {
+        this.event = event;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+class EventList {
+    constructor(eventType, maxSize, sortFn, orderDirection) {
+        this.eventType = eventType;
+        this.maxSize = maxSize;
+        this.sortFn = sortFn;
+        this.orderDirection = orderDirection;
+        this.size = 0;
+    }
+    insert(event) {
+        this.size++;
+        const newNode = new Node(event);
+        if (this.head === undefined) {
+            this.head = this.tail = newNode;
+            return;
+        }
+        if (this.sortFn(this.head.event, newNode.event) ===
+            (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+            this.head.prev = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+        }
+        else {
+            let currentNode = this.head;
+            while (currentNode.next !== undefined &&
+                this.sortFn(currentNode.next.event, newNode.event) !==
+                    (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+                currentNode = currentNode.next;
+            }
+            newNode.next = currentNode.next;
+            if (currentNode.next !== undefined) {
+                newNode.next.prev = newNode;
+            }
+            currentNode.next = newNode;
+            newNode.prev = currentNode;
+        }
+        if (this.size > this.maxSize) {
+            this.detach();
+        }
+    }
+    detach() {
+        const node = this.tail;
+        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;
+        }
+        this.size--;
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.event;
+            node = node.next;
+        }
+    }
+}
+exports.EventList = EventList;

package/src/events/eventSubscriber.js

@@ -0,0 +1,139 @@
+"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.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, 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);
+    }
+    fetchPreviousTx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.untilTx) {
+                return;
+            }
+            let txFetched = 0;
+            let beforeTx = undefined;
+            const untilTx = this.options.untilTx;
+            while (txFetched < this.options.maxTx) {
+                const response = yield 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);
+                }
+            }
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield 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/src/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/src/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/src/examples/makeTradeExample.js

@@ -0,0 +1,80 @@
+"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");
+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* () {
+    // Initialize Drift SDK
+    const sdkConfig = __2.initialize({ env: 'devnet' });
+    // 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)));
+    const wallet = new __1.Wallet(keypair);
+    // Set up the Connection
+    const rpcAddress = process.env.RPC_ADDRESS; // can use: https://api.devnet.solana.com for devnet; https://api.mainnet-beta.solana.com for mainnet;
+    const connection = new web3_js_1.Connection(rpcAddress);
+    // 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));
+    // Misc. other things to set up
+    const usdcTokenAddress = yield 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({
+        connection,
+        wallet: provider.wallet,
+        programID: clearingHousePublicKey,
+    });
+    yield clearingHouse.subscribe();
+    // Set up Clearing House user client
+    const user = new __2.ClearingHouseUser({
+        clearingHouse,
+        userAccountPublicKey: yield clearingHouse.getUserAccountPublicKey(),
+    });
+    //// Check if clearing house account exists for the current wallet
+    const userAccountExists = yield 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 exports.getTokenAddress(usdcTokenAddress.toString(), wallet.publicKey.toString()), banks_1.Banks['devnet'][0].bankIndex);
+    }
+    yield user.subscribe();
+    // Get current price
+    const solMarketInfo = sdkConfig.MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
+    const currentMarketPrice = __2.calculateMarkPrice(clearingHouse.getMarketAccount(solMarketInfo.marketIndex), undefined);
+    const formattedPrice = __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.getMarketAccount(solMarketInfo.marketIndex);
+    const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
+    const slippage = __2.convertToNumber(__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);
+    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);
+    // Close the rest of the position
+    yield clearingHouse.closePosition(solMarketInfo.marketIndex);
+});
+main();