@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

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/types.d.ts

@@ -1,5 +1,5 @@
 import { Commitment, TransactionSignature } from '@solana/web3.js';
-import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord } from '../index';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord } from '../index';
 export declare type EventSubscriptionOptions = {
     eventTypes?: EventType[];
     maxEventsPerType?: number;
@@ -31,6 +31,7 @@ export declare type EventMap = {
     SettlePnlRecord: Event<SettlePnlRecord>;
     NewUserRecord: Event<NewUserRecord>;
     LPRecord: Event<LPRecord>;
+    InsuranceFundRecord: Event<InsuranceFundRecord>;
 };
 export declare type EventType = keyof EventMap;
 export interface EventSubscriberEvents {

package/lib/events/types.js

@@ -12,6 +12,7 @@ exports.DefaultEventSubscriptionOptions = {
         'NewUserRecord',
         'SettlePnlRecord',
         'LPRecord',
+        'InsuranceFundRecord',
     ],
     maxEventsPerType: 4096,
     orderBy: 'blockchain',

package/lib/examples/makeTradeExample.js

@@ -6,7 +6,7 @@ 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));
 };
@@ -36,8 +36,8 @@ const main = async () => {
         connection,
         wallet: provider.wallet,
         programID: clearingHousePublicKey,
-        marketIndexes: __2.Markets[cluster].map((market) => market.marketIndex),
-        bankIndexes: banks_1.Banks[cluster].map((bank) => bank.bankIndex),
+        perpMarketIndexes: __2.PerpMarkets[cluster].map((market) => market.marketIndex),
+        spotMarketIndexes: spotMarkets_1.SpotMarkets[cluster].map((spotMarket) => spotMarket.marketIndex),
         accountSubscription: {
             type: 'polling',
             accountLoader: bulkAccountLoader,
@@ -58,16 +58,16 @@ const main = async () => {
     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 solMarketInfo = sdkConfig.PERP_MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
+    const currentMarketPrice = (0, __2.calculateMarkPrice)(clearingHouse.getPerpMarketAccount(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.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);
     console.log(`Slippage for a $5000 LONG on the SOL market would be $${slippage}`);