@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.34

package/lib/dlob/DLOB.js

@@ -3,19 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLOB = void 0;
 const NodeList_1 = require("./NodeList");
 const __1 = require("..");
+const exchangeStatus_1 = require("../math/exchangeStatus");
 class DLOB {
     /**
      *
      * @param perpMarkets The perp markets to maintain a DLOB for
      * @param spotMarkets The spot markets to maintain a DLOB for
+     * @param userMap map of all users
      * @param silent set to true to prevent logging on inserts and removals
      */
-    constructor(perpMarkets, spotMarkets, silent) {
+    constructor(perpMarkets, spotMarkets, stateAccount, userMap, silent) {
         this.openOrders = new Map();
         this.orderLists = new Map();
         this.marketIndexToAccount = new Map();
         this.silent = false;
         this.initialized = false;
+        this.stateAccount = stateAccount;
+        this.userMap = userMap;
         this.silent = silent;
         this.openOrders.set('perp', new Set());
         this.openOrders.set('spot', new Set());
@@ -94,32 +98,18 @@ class DLOB {
     /**
      * initializes a new DLOB instance
      *
-     * @param clearingHouse The ClearingHouse instance to use for price data
      * @returns a promise that resolves when the DLOB is initialized
      */
-    async init(clearingHouse, userMap) {
+    async init() {
         if (this.initialized) {
             return false;
         }
-        if (userMap) {
-            // initialize the dlob with the user map (prevents hitting getProgramAccounts)
-            for (const user of userMap.values()) {
-                const userAccount = user.getUserAccount();
-                const userAccountPubkey = user.getUserAccountPublicKey();
-                for (const order of userAccount.orders) {
-                    this.insertOrder(order, userAccountPubkey);
-                }
-            }
-        }
-        else {
-            const programAccounts = await clearingHouse.program.account.user.all();
-            for (const programAccount of programAccounts) {
-                // @ts-ignore
-                const userAccount = programAccount.account;
-                const userAccountPublicKey = programAccount.publicKey;
-                for (const order of userAccount.orders) {
-                    this.insertOrder(order, userAccountPublicKey);
-                }
+        // initialize the dlob with the user map (prevents hitting getProgramAccounts)
+        for (const user of this.userMap.values()) {
+            const userAccount = user.getUserAccount();
+            const userAccountPubkey = user.getUserAccountPublicKey();
+            for (const order of userAccount.orders) {
+                this.insertOrder(order, userAccountPubkey);
             }
         }
         this.initialized = true;
@@ -165,7 +155,7 @@ class DLOB {
         else if ((0, __1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
             type = 'market';
         }
-        else if (!order.oraclePriceOffset.eq(__1.ZERO)) {
+        else if (order.oraclePriceOffset !== 0) {
             type = 'floatingLimit';
         }
         else {
@@ -184,13 +174,22 @@ class DLOB {
         }
         return this.orderLists.get(marketType).get(order.marketIndex)[type][subType];
     }
-    findNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData) {
+    findNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, ts, marketType, oraclePriceData) {
+        const marketAccount = this.marketIndexToAccount
+            .get((0, __1.getVariant)(marketType))
+            .get(marketIndex);
+        if ((0, exchangeStatus_1.fillPaused)(this.stateAccount, marketAccount)) {
+            return [];
+        }
         // Find all the crossing nodes
         const crossingNodesToFill = this.findCrossingNodesToFill(marketIndex, slot, marketType, oraclePriceData);
-        const vAMMCrossingNodesToFill = this.findvAMMCrossingNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData);
+        let fallbackCrossingNodesToFill = new Array();
+        if (!(0, exchangeStatus_1.ammPaused)(this.stateAccount, marketAccount)) {
+            fallbackCrossingNodesToFill = this.findFallbackCrossingNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, marketType, oraclePriceData);
+        }
         // get expired market nodes
-        const marketNodesToFill = this.findExpiredMarketNodesToFill(marketIndex, slot, marketType);
-        return crossingNodesToFill.concat(vAMMCrossingNodesToFill, marketNodesToFill);
+        const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
+        return crossingNodesToFill.concat(fallbackCrossingNodesToFill, expiredNodesToFill);
     }
     findCrossingNodesToFill(marketIndex, slot, marketType, oraclePriceData) {
         const nodesToFill = new Array();
@@ -226,7 +225,8 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findvAMMCrossingNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData) {
+    findFallbackCrossingNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, marketType, oraclePriceData) {
+        var _a, _b;
         const nodesToFill = new Array();
         const askGenerator = this.getAsks(marketIndex, undefined, // dont include vask
         slot, marketType, oraclePriceData);
@@ -234,53 +234,79 @@ class DLOB {
         slot, marketType, oraclePriceData);
         let nextAsk = askGenerator.next();
         let nextBid = bidGenerator.next();
-        // check for asks that cross vBid
-        while (!nextAsk.done) {
+        // check for asks that cross fallbackBid
+        while (!nextAsk.done && fallbackBid !== undefined) {
             const askNode = nextAsk.value;
-            const askPrice = askNode.getPrice(oraclePriceData, slot);
-            if (askPrice.lte(vBid) && (0, __1.isAuctionComplete)(askNode.order, slot)) {
+            if ((0, __1.isVariant)(marketType, 'spot') && ((_a = askNode.order) === null || _a === void 0 ? void 0 : _a.postOnly)) {
+                nextAsk = askGenerator.next();
+                continue;
+            }
+            const askLimitPrice = (0, __1.getOptionalLimitPrice)(askNode.order, oraclePriceData, slot);
+            // order crosses if there is no limit price or it crosses fallback price
+            const crosses = askLimitPrice === undefined || askLimitPrice.lte(fallbackBid);
+            // fallback is available if auction is complete or it's a spot order
+            const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') || (0, __1.isAuctionComplete)(askNode.order, slot);
+            if (crosses && fallbackAvailable) {
                 nodesToFill.push({
                     node: askNode,
-                    makerNode: undefined, // filled by vAMM
+                    makerNode: undefined, // filled by fallback
                 });
             }
-            else {
-                break;
-            }
             nextAsk = askGenerator.next();
         }
-        // check for bids that cross vAsk
-        while (!nextBid.done) {
+        // check for bids that cross fallbackAsk
+        while (!nextBid.done && fallbackAsk !== undefined) {
             const bidNode = nextBid.value;
-            const bidPrice = bidNode.getPrice(oraclePriceData, slot);
-            if (bidPrice.gte(vAsk) && (0, __1.isAuctionComplete)(bidNode.order, slot)) {
+            if ((0, __1.isVariant)(marketType, 'spot') && ((_b = bidNode.order) === null || _b === void 0 ? void 0 : _b.postOnly)) {
+                nextBid = bidGenerator.next();
+                continue;
+            }
+            const bidLimitPrice = (0, __1.getOptionalLimitPrice)(bidNode.order, oraclePriceData, slot);
+            // order crosses if there is no limit price or it crosses fallback price
+            const crosses = bidLimitPrice === undefined || bidLimitPrice.gte(fallbackAsk);
+            // fallback is available if auction is complete or it's a spot order
+            const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') || (0, __1.isAuctionComplete)(bidNode.order, slot);
+            if (crosses && fallbackAvailable) {
                 nodesToFill.push({
                     node: bidNode,
-                    makerNode: undefined, // filled by vAMM
+                    makerNode: undefined, // filled by fallback
                 });
             }
-            else {
-                break;
-            }
             nextBid = bidGenerator.next();
         }
         return nodesToFill;
     }
-    findExpiredMarketNodesToFill(marketIndex, slot, marketType) {
+    findExpiredNodesToFill(marketIndex, ts, marketType) {
         const nodesToFill = new Array();
-        // Then see if there are orders to fill against vamm
-        for (const marketBid of this.getMarketBids(marketIndex, marketType)) {
-            if ((0, __1.isOrderExpired)(marketBid.order, slot)) {
-                nodesToFill.push({
-                    node: marketBid,
-                });
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        // All bids/asks that can expire
+        const bidGenerators = [
+            nodeLists.limit.bid.getGenerator(),
+            nodeLists.floatingLimit.bid.getGenerator(),
+            nodeLists.market.bid.getGenerator(),
+        ];
+        const askGenerators = [
+            nodeLists.limit.ask.getGenerator(),
+            nodeLists.floatingLimit.ask.getGenerator(),
+            nodeLists.market.ask.getGenerator(),
+        ];
+        for (const bidGenerator of bidGenerators) {
+            for (const bid of bidGenerator) {
+                if ((0, __1.isOrderExpired)(bid.order, ts)) {
+                    nodesToFill.push({
+                        node: bid,
+                    });
+                }
             }
         }
-        for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
-            if ((0, __1.isOrderExpired)(marketAsk.order, slot)) {
-                nodesToFill.push({
-                    node: marketAsk,
-                });
+        for (const askGenerator of askGenerators) {
+            for (const ask of askGenerator) {
+                if ((0, __1.isOrderExpired)(ask.order, ts)) {
+                    nodesToFill.push({
+                        node: ask,
+                    });
+                }
             }
         }
         return nodesToFill;
@@ -318,7 +344,7 @@ class DLOB {
             .get(marketIndex)
             .market.ask.getGenerator();
     }
-    *getAsks(marketIndex, vAsk, slot, marketType, oraclePriceData) {
+    *getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
         if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot asks');
         }
@@ -329,8 +355,8 @@ class DLOB {
             nodeLists.floatingLimit.ask.getGenerator(),
             nodeLists.market.ask.getGenerator(),
         ];
-        if (marketTypeStr === 'perp' && vAsk) {
-            generatorList.push((0, NodeList_1.getVammNodeGenerator)(vAsk));
+        if (marketTypeStr === 'perp' && fallbackAsk) {
+            generatorList.push((0, NodeList_1.getVammNodeGenerator)(fallbackAsk));
         }
         if (generatorList.length === 0) {
             throw new Error('No ask generators found');
@@ -362,6 +388,15 @@ class DLOB {
                     bestGenerator.next = bestGenerator.generator.next();
                     continue;
                 }
+                // skip order if user is being liquidated/bankrupt
+                if (bestGenerator.next.value.userAccount !== undefined) {
+                    const user = this.userMap.get(bestGenerator.next.value.userAccount.toString());
+                    if ((user === null || user === void 0 ? void 0 : user.getUserAccount().isBeingLiquidated) ||
+                        (user === null || user === void 0 ? void 0 : user.getUserAccount().isBankrupt)) {
+                        bestGenerator.next = bestGenerator.generator.next();
+                        continue;
+                    }
+                }
                 yield bestGenerator.next.value;
                 bestGenerator.next = bestGenerator.generator.next();
             }
@@ -370,7 +405,7 @@ class DLOB {
             }
         }
     }
-    *getBids(marketIndex, vBid, slot, marketType, oraclePriceData) {
+    *getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
         if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot bids');
         }
@@ -381,8 +416,8 @@ class DLOB {
             nodeLists.floatingLimit.bid.getGenerator(),
             nodeLists.market.bid.getGenerator(),
         ];
-        if (marketTypeStr === 'perp' && vBid) {
-            generatorList.push((0, NodeList_1.getVammNodeGenerator)(vBid));
+        if (marketTypeStr === 'perp' && fallbackBid) {
+            generatorList.push((0, NodeList_1.getVammNodeGenerator)(fallbackBid));
         }
         if (generatorList.length === 0) {
             throw new Error('No bid generators found');
@@ -393,7 +428,7 @@ class DLOB {
                 generator,
             };
         });
-        let bidsExhausted = false; // there will always be the vBid
+        let bidsExhausted = false; // there will always be the fallbackBid
         while (!bidsExhausted) {
             const bestGenerator = bidGenerators.reduce((bestGenerator, currentGenerator) => {
                 if (currentGenerator.next.done) {
@@ -414,6 +449,15 @@ class DLOB {
                     bestGenerator.next = bestGenerator.generator.next();
                     continue;
                 }
+                // skip order if user is being liquidated/bankrupt
+                if (bestGenerator.next.value.userAccount !== undefined) {
+                    const user = this.userMap.get(bestGenerator.next.value.userAccount.toString());
+                    if ((user === null || user === void 0 ? void 0 : user.getUserAccount().isBeingLiquidated) ||
+                        (user === null || user === void 0 ? void 0 : user.getUserAccount().isBankrupt)) {
+                        bestGenerator.next = bestGenerator.generator.next();
+                        continue;
+                    }
+                }
                 yield bestGenerator.next.value;
                 bestGenerator.next = bestGenerator.generator.next();
             }
@@ -434,9 +478,11 @@ class DLOB {
         }
         const bidOrder = bidNode.order;
         const askOrder = askNode.order;
-        // Can't match two maker orders or if maker and taker are the same
-        const makerIsTaker = bidNode.userAccount.equals(askNode.userAccount);
-        if (makerIsTaker || (bidOrder.postOnly && askOrder.postOnly)) {
+        const bidUserAuthority = this.userMap.getUserAuthority(bidNode.userAccount.toString());
+        const askUserAuthority = this.userMap.getUserAuthority(askNode.userAccount.toString());
+        // Can't match orders from the same authority
+        const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+        if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
             // don't have a principle way to pick which one to exhaust,
             // exhaust each one 50% of the time so we can try each one against other orders
             const exhaustedSide = Math.random() < 0.5 ? 'bid' : 'ask';
@@ -445,6 +491,14 @@ class DLOB {
                 exhaustedSide,
             };
         }
+        const { takerNode, makerNode, makerSide } = this.determineMakerAndTaker(askNode, bidNode);
+        // If order doesn't have limit price, cant be maker
+        if (!(0, __1.hasLimitPrice)(makerNode.order, slot)) {
+            return {
+                crossingNodes: [],
+                exhaustedSide: makerSide,
+            };
+        }
         const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
         const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
         let exhaustedSide;
@@ -493,56 +547,74 @@ class DLOB {
             newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
             this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
         }
-        // Bid is maker
-        if (bidOrder.postOnly) {
-            return {
-                crossingNodes: [
-                    {
-                        node: askNode,
-                        makerNode: bidNode,
-                    },
-                ],
-                exhaustedSide,
-            };
-        }
-        // Ask is maker
-        if (askOrder.postOnly) {
-            return {
-                crossingNodes: [
-                    {
-                        node: bidNode,
-                        makerNode: askNode,
-                    },
-                ],
-                exhaustedSide,
-            };
-        }
-        // Both are takers
-        // older order is maker
-        const [olderNode, newerNode] = askOrder.ts.lt(bidOrder.ts)
-            ? [askNode, bidNode]
-            : [bidNode, askNode];
         return {
             crossingNodes: [
                 {
-                    node: newerNode,
-                    makerNode: olderNode,
+                    node: takerNode,
+                    makerNode: makerNode,
                 },
             ],
             exhaustedSide,
         };
     }
-    getBestAsk(marketIndex, vAsk, slot, marketType, oraclePriceData) {
-        return this.getAsks(marketIndex, vAsk, slot, marketType, oraclePriceData)
+    determineMakerAndTaker(askNode, bidNode) {
+        if (bidNode.order.postOnly) {
+            return {
+                takerNode: askNode,
+                makerNode: bidNode,
+                makerSide: 'bid',
+            };
+        }
+        else if (askNode.order.postOnly) {
+            return {
+                takerNode: bidNode,
+                makerNode: askNode,
+                makerSide: 'ask',
+            };
+        }
+        else if ((0, __1.isMarketOrder)(bidNode.order) && (0, __1.isLimitOrder)(askNode.order)) {
+            return {
+                takerNode: bidNode,
+                makerNode: askNode,
+                makerSide: 'ask',
+            };
+        }
+        else if ((0, __1.isMarketOrder)(askNode.order) && (0, __1.isLimitOrder)(bidNode.order)) {
+            return {
+                takerNode: askNode,
+                makerNode: bidNode,
+                makerSide: 'bid',
+            };
+        }
+        else if (askNode.order.slot.lt(bidNode.order.slot)) {
+            return {
+                takerNode: bidNode,
+                makerNode: askNode,
+                makerSide: 'ask',
+            };
+        }
+        else {
+            return {
+                takerNode: askNode,
+                makerNode: bidNode,
+                makerSide: 'bid',
+            };
+        }
+    }
+    getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
+        return this.getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData)
             .next()
             .value.getPrice(oraclePriceData, slot);
     }
-    getBestBid(marketIndex, vBid, slot, marketType, oraclePriceData) {
-        return this.getBids(marketIndex, vBid, slot, marketType, oraclePriceData)
+    getBestBid(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
+        return this.getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData)
             .next()
             .value.getPrice(oraclePriceData, slot);
     }
     findNodesToTrigger(marketIndex, slot, oraclePrice, marketType) {
+        if ((0, exchangeStatus_1.exchangePaused)(this.stateAccount)) {
+            return [];
+        }
         const nodesToTrigger = [];
         const marketTypeStr = (0, __1.getVariant)(marketType);
         for (const node of this.orderLists
@@ -581,11 +653,11 @@ class DLOB {
         if ((0, __1.isVariant)(marketType, 'perp')) {
             const market = clearingHouse.getPerpMarketAccount(marketIndex);
             const slot = slotSubscriber.getSlot();
-            const oraclePriceData = clearingHouse.getOracleDataForMarket(marketIndex);
-            const vAsk = (0, __1.calculateAskPrice)(market, oraclePriceData);
-            const vBid = (0, __1.calculateBidPrice)(market, oraclePriceData);
-            const bestAsk = this.getBestAsk(marketIndex, vAsk, slot, marketType, oraclePriceData);
-            const bestBid = this.getBestBid(marketIndex, vBid, slot, marketType, oraclePriceData);
+            const oraclePriceData = clearingHouse.getOracleDataForPerpMarket(marketIndex);
+            const fallbackAsk = (0, __1.calculateAskPrice)(market, oraclePriceData);
+            const fallbackBid = (0, __1.calculateBidPrice)(market, oraclePriceData);
+            const bestAsk = this.getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData);
+            const bestBid = this.getBestBid(marketIndex, fallbackBid, slot, marketType, oraclePriceData);
             const mid = bestAsk.add(bestBid).div(new __1.BN(2));
             const bidSpread = ((0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION) /
                 (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
@@ -602,7 +674,7 @@ class DLOB {
         }
         else if ((0, __1.isVariant)(marketType, 'spot')) {
             const slot = slotSubscriber.getSlot();
-            const oraclePriceData = clearingHouse.getOracleDataForMarket(marketIndex);
+            const oraclePriceData = clearingHouse.getOracleDataForPerpMarket(marketIndex);
             const bestAsk = this.getBestAsk(marketIndex, undefined, slot, marketType, oraclePriceData);
             const bestBid = this.getBestBid(marketIndex, undefined, slot, marketType, oraclePriceData);
             const mid = bestAsk.add(bestBid).div(new __1.BN(2));

package/lib/dlob/DLOBNode.js

@@ -26,15 +26,7 @@ class OrderNode {
         return msg;
     }
     getPrice(oraclePriceData, slot) {
-        if ((0, __1.isOneOfVariant)(this.order.marketType, ['spot'])) {
-            return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot);
-        }
-        else if ((0, __1.isOneOfVariant)(this.order.marketType, ['perp'])) {
-            return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot, this.market);
-        }
-        else {
-            console.error(`Unknown market type: ${this.order.marketType}`);
-        }
+        return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot);
     }
     isBaseFilled() {
         return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
@@ -52,7 +44,7 @@ class LimitOrderNode extends OrderNode {
 exports.LimitOrderNode = LimitOrderNode;
 class FloatingLimitOrderNode extends OrderNode {
     getSortValue(order) {
-        return order.oraclePriceOffset;
+        return new __1.BN(order.oraclePriceOffset);
     }
 }
 exports.FloatingLimitOrderNode = FloatingLimitOrderNode;

package/lib/dlob/NodeList.js

@@ -64,7 +64,7 @@ class NodeList {
         const currentOrderSortPrice = currentNode.sortValue;
         const newOrderSortPrice = newNode.sortValue;
         if (newOrderSortPrice.eq(currentOrderSortPrice)) {
-            return newOrder.ts.lt(currentOrder.ts);
+            return newOrder.slot.lt(currentOrder.slot);
         }
         if (this.sortDirection === 'asc') {
             return newOrderSortPrice.lt(currentOrderSortPrice);

package/lib/events/eventSubscriber.d.ts

@@ -16,6 +16,7 @@ export declare class EventSubscriber {
     private logProvider;
     eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
     private lastSeenSlot;
+    private lastSeenBlockTime;
     lastSeenTxSig: string;
     constructor(connection: Connection, program: Program, options?: EventSubscriptionOptions);
     subscribe(): Promise<boolean>;

package/lib/events/eventSubscriber.js

@@ -35,8 +35,8 @@ class EventSubscriber {
             if (this.logProvider.isSubscribed()) {
                 return true;
             }
-            this.logProvider.subscribe((txSig, slot, logs) => {
-                this.handleTxLogs(txSig, slot, logs);
+            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
             }, true);
             return true;
         }
@@ -46,13 +46,16 @@ class EventSubscriber {
             return false;
         }
     }
-    handleTxLogs(txSig, slot, logs) {
+    handleTxLogs(txSig, slot, logs, mostRecentBlockTime) {
         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);
+        }
+        // dont emit event till we've added all the events to the eventListMap
+        for (const wrappedEvent of wrappedEvents) {
             this.eventEmitter.emit('newEvent', wrappedEvent);
         }
         if (this.awaitTxPromises.has(txSig)) {
@@ -63,6 +66,10 @@ class EventSubscriber {
         if (slot > this.lastSeenSlot) {
             this.lastSeenTxSig = txSig;
         }
+        if (this.lastSeenBlockTime === undefined ||
+            mostRecentBlockTime > this.lastSeenBlockTime) {
+            this.lastSeenBlockTime = mostRecentBlockTime;
+        }
         this.txEventCache.add(txSig, wrappedEvents);
     }
     async fetchPreviousTx(fetchMax) {
@@ -80,7 +87,7 @@ class EventSubscriber {
             txFetched += response.transactionLogs.length;
             beforeTx = response.earliestTx;
             for (const { txSig, slot, logs } of response.transactionLogs) {
-                this.handleTxLogs(txSig, slot, logs);
+                this.handleTxLogs(txSig, slot, logs, response.mostRecentBlockTime);
             }
         }
     }

package/lib/events/fetchLogs.d.ts

@@ -1,5 +1,5 @@
 import { Program } from '@project-serum/anchor';
-import { Connection, Finality, PublicKey, TransactionSignature } from '@solana/web3.js';
+import { Connection, Finality, PublicKey, TransactionResponse, TransactionSignature } from '@solana/web3.js';
 import { WrappedEvents } from './types';
 declare type Log = {
     txSig: TransactionSignature;
@@ -12,11 +12,13 @@ declare type FetchLogsResponse = {
     earliestSlot: number;
     mostRecentSlot: number;
     transactionLogs: Log[];
+    mostRecentBlockTime: number | 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);
+    parseEventsFromTransaction(transaction: TransactionResponse): WrappedEvents;
     parseEventsFromLogs(event: Log): WrappedEvents;
 }
 export {};

package/lib/events/fetchLogs.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogParser = exports.fetchLogs = void 0;
+function mapTransactionResponseToLog(transaction) {
+    return {
+        txSig: transaction.transaction.signatures[0],
+        slot: transaction.slot,
+        logs: transaction.meta.logMessages,
+    };
+}
 async function fetchLogs(connection, programId, finality, beforeTx, untilTx, limit) {
     const signatures = await connection.getSignaturesForAddress(programId, {
         before: beforeTx,
@@ -16,11 +23,7 @@ async function fetchLogs(connection, programId, finality, beforeTx, untilTx, lim
     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,
-            };
+            return mapTransactionResponseToLog(transaction);
         });
     }))).flat();
     const earliest = filteredSignatures[0];
@@ -31,6 +34,7 @@ async function fetchLogs(connection, programId, finality, beforeTx, untilTx, lim
         mostRecentTx: mostRecent.signature,
         earliestSlot: earliest.slot,
         mostRecentSlot: mostRecent.slot,
+        mostRecentBlockTime: mostRecent.blockTime,
     };
 }
 exports.fetchLogs = fetchLogs;
@@ -44,6 +48,10 @@ class LogParser {
     constructor(program) {
         this.program = program;
     }
+    parseEventsFromTransaction(transaction) {
+        const transactionLogObject = mapTransactionResponseToLog(transaction);
+        return this.parseEventsFromLogs(transactionLogObject);
+    }
     parseEventsFromLogs(event) {
         const records = [];
         // @ts-ignore

package/lib/events/pollingLogProvider.js

@@ -29,7 +29,7 @@ class PollingLogProvider {
                 }
                 const { mostRecentTx, transactionLogs } = response;
                 for (const { txSig, slot, logs } of transactionLogs) {
-                    callback(txSig, slot, logs);
+                    callback(txSig, slot, logs, response.mostRecentBlockTime);
                 }
                 this.mostRecentSeenTx = mostRecentTx;
             }

package/lib/events/types.d.ts

@@ -39,7 +39,7 @@ 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 declare type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined) => void;
 export interface LogProvider {
     isSubscribed(): boolean;
     subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;

package/lib/events/webSocketLogProvider.js

@@ -12,7 +12,7 @@ class WebSocketLogProvider {
             return true;
         }
         this.subscriptionId = this.connection.onLogs(this.programId, (logs, ctx) => {
-            callback(logs.signature, ctx.slot, logs.logs);
+            callback(logs.signature, ctx.slot, logs.logs, undefined);
         }, this.commitment);
         return true;
     }