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

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;
+function orderActionRecordSortFn(currentEvent, newEvent) {
+    var _a, _b;
+    const currentEventMarketIndex = currentEvent.marketIndex;
+    const newEventMarketIndex = newEvent.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)) {
+    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, NewUserRecord, OrderRecord, SettlePnlRecord } from '../index';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord } from '../index';
 export declare type EventSubscriptionOptions = {
     eventTypes?: EventType[];
     maxEventsPerType?: number;
@@ -27,8 +27,10 @@ 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>;
 };
 export declare type EventType = keyof EventMap;
 export interface EventSubscriberEvents {
@@ -38,7 +40,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,9 +7,11 @@ exports.DefaultEventSubscriptionOptions = {
         'FundingPaymentRecord',
         'LiquidationRecord',
         'OrderRecord',
+        'OrderActionRecord',
         'FundingRateRecord',
         'NewUserRecord',
         'SettlePnlRecord',
+        'LPRecord',
     ],
     maxEventsPerType: 4096,
     orderBy: 'blockchain',

package/lib/examples/makeTradeExample.js

@@ -11,9 +11,10 @@ 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,16 +31,27 @@ 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,
+        marketIndexes: __2.Markets[cluster].map((market) => market.marketIndex),
+        bankIndexes: banks_1.Banks[cluster].map((bank) => bank.bankIndex),
+        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();