@drift-labs/sdk 2.49.0-beta.0 → 2.49.0-beta.10

package/VERSION

@@ -1 +1 @@
-2.49.0-beta.0
+2.49.0-beta.10

package/lib/accounts/{mockUserAccountSubscriber.d.ts → basicUserAccountSubscriber.d.ts}

@@ -4,14 +4,14 @@ import { PublicKey } from '@solana/web3.js';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
-export declare class MockUserAccountSubscriber implements UserAccountSubscriber {
+export declare class BasicUserAccountSubscriber implements UserAccountSubscriber {
     isSubscribed: boolean;
     eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
     userAccountPublicKey: PublicKey;
     callbackId?: string;
     errorCallbackId?: string;
     user: DataAndSlot<UserAccount>;
-    constructor(userAccountPublicKey: PublicKey, data: UserAccount, slot: number);
+    constructor(userAccountPublicKey: PublicKey, data?: UserAccount, slot?: number);
     subscribe(_userAccount?: UserAccount): Promise<boolean>;
     addToAccountLoader(): Promise<void>;
     fetch(): Promise<void>;

package/lib/accounts/{mockUserAccountSubscriber.js → basicUserAccountSubscriber.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockUserAccountSubscriber = void 0;
+exports.BasicUserAccountSubscriber = void 0;
 const events_1 = require("events");
-class MockUserAccountSubscriber {
+class BasicUserAccountSubscriber {
     constructor(userAccountPublicKey, data, slot) {
         this.isSubscribed = true;
         this.eventEmitter = new events_1.EventEmitter();
@@ -23,9 +23,12 @@ class MockUserAccountSubscriber {
         return this.user;
     }
     updateData(userAccount, slot) {
-        this.user = { data: userAccount, slot };
-        this.eventEmitter.emit('userAccountUpdate', userAccount);
-        this.eventEmitter.emit('update');
+        var _a;
+        if (!this.user || slot >= ((_a = this.user.slot) !== null && _a !== void 0 ? _a : 0)) {
+            this.user = { data: userAccount, slot };
+            this.eventEmitter.emit('userAccountUpdate', userAccount);
+            this.eventEmitter.emit('update');
+        }
     }
 }
-exports.MockUserAccountSubscriber = MockUserAccountSubscriber;
+exports.BasicUserAccountSubscriber = BasicUserAccountSubscriber;

package/lib/accounts/pollingInsuranceFundStakeAccountSubscriber.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { DataAndSlot, InsuranceFundStakeAccountEvents, InsuranceFundStakeAccountSubscriber } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { InsuranceFundStake } from '../types';
+export declare class PollingInsuranceFundStakeAccountSubscriber implements InsuranceFundStakeAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, InsuranceFundStakeAccountEvents>;
+    insuranceFundStakeAccountPublicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    callbackId?: string;
+    errorCallbackId?: string;
+    insuranceFundStakeAccountAndSlot?: DataAndSlot<InsuranceFundStake>;
+    constructor(program: Program, publicKey: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(insuranceFundStake?: InsuranceFundStake): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+    didSubscriptionSucceed(): boolean;
+    updateData(insuranceFundStake: InsuranceFundStake, slot: number): void;
+}

package/lib/accounts/pollingInsuranceFundStakeAccountSubscriber.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingInsuranceFundStakeAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingInsuranceFundStakeAccountSubscriber {
+    constructor(program, publicKey, accountLoader) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.insuranceFundStakeAccountPublicKey = publicKey;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe(insuranceFundStake) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (insuranceFundStake) {
+            this.insuranceFundStakeAccountAndSlot = {
+                data: insuranceFundStake,
+                slot: undefined,
+            };
+        }
+        await this.addToAccountLoader();
+        if (this.doesAccountExist()) {
+            this.eventEmitter.emit('update');
+        }
+        this.isSubscribed = true;
+        return true;
+    }
+    async addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = await this.accountLoader.addAccount(this.insuranceFundStakeAccountPublicKey, (buffer, slot) => {
+            if (!buffer) {
+                return;
+            }
+            if (this.insuranceFundStakeAccountAndSlot &&
+                this.insuranceFundStakeAccountAndSlot.slot > slot) {
+                return;
+            }
+            const account = this.program.account.user.coder.accounts.decode('InsuranceFundStake', buffer);
+            this.insuranceFundStakeAccountAndSlot = { data: account, slot };
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', account);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async fetchIfUnloaded() {
+        if (this.insuranceFundStakeAccountAndSlot === undefined) {
+            await this.fetch();
+        }
+    }
+    async fetch() {
+        var _a, _b;
+        try {
+            const dataAndContext = await this.program.account.insuranceFundStake.fetchAndContext(this.insuranceFundStakeAccountPublicKey, this.accountLoader.commitment);
+            if (dataAndContext.context.slot >
+                ((_b = (_a = this.insuranceFundStakeAccountAndSlot) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0)) {
+                this.insuranceFundStakeAccountAndSlot = {
+                    data: dataAndContext.data,
+                    slot: dataAndContext.context.slot,
+                };
+            }
+        }
+        catch (e) {
+            console.log(`PollingInsuranceFundStakeAccountSubscriber.fetch() InsuranceFundStake does not exist: ${e.message}`);
+        }
+    }
+    doesAccountExist() {
+        return this.insuranceFundStakeAccountAndSlot !== undefined;
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.insuranceFundStakeAccountPublicKey, this.callbackId);
+        this.callbackId = undefined;
+        this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+        this.errorCallbackId = undefined;
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getInsuranceFundStakeAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.insuranceFundStakeAccountAndSlot;
+    }
+    didSubscriptionSucceed() {
+        return !!this.insuranceFundStakeAccountAndSlot;
+    }
+    updateData(insuranceFundStake, slot) {
+        if (!this.insuranceFundStakeAccountAndSlot ||
+            this.insuranceFundStakeAccountAndSlot.slot < slot) {
+            this.insuranceFundStakeAccountAndSlot = {
+                data: insuranceFundStake,
+                slot,
+            };
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', insuranceFundStake);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.PollingInsuranceFundStakeAccountSubscriber = PollingInsuranceFundStakeAccountSubscriber;

package/lib/accounts/types.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount, InsuranceFundStake } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { Context, PublicKey } from '@solana/web3.js';
@@ -73,6 +73,19 @@ export interface TokenAccountSubscriber {
     unsubscribe(): Promise<void>;
     getTokenAccountAndSlot(): DataAndSlot<Account>;
 }
+export interface InsuranceFundStakeAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, InsuranceFundStakeAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+}
+export interface InsuranceFundStakeAccountEvents {
+    insuranceFundStakeAccountUpdate: (payload: InsuranceFundStake) => void;
+    update: void;
+    error: (e: Error) => void;
+}
 export interface OracleEvents {
     oracleUpdate: (payload: OraclePriceData) => void;
     update: void;

package/lib/accounts/webSocketInsuranceFundStakeAccountSubscriber.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, InsuranceFundStakeAccountEvents, InsuranceFundStakeAccountSubscriber } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { InsuranceFundStake } from '../types';
+export declare class WebSocketInsuranceFundStakeAccountSubscriber implements InsuranceFundStakeAccountSubscriber {
+    isSubscribed: boolean;
+    reconnectTimeoutMs?: number;
+    commitment?: Commitment;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, InsuranceFundStakeAccountEvents>;
+    insuranceFundStakeAccountPublicKey: PublicKey;
+    insuranceFundStakeDataAccountSubscriber: AccountSubscriber<InsuranceFundStake>;
+    constructor(program: Program, insuranceFundStakeAccountPublicKey: PublicKey, reconnectTimeoutMs?: number, commitment?: Commitment);
+    subscribe(insuranceFundStakeAccount?: InsuranceFundStake): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+    updateData(insuranceFundStake: InsuranceFundStake, slot: number): void;
+}

package/lib/accounts/webSocketInsuranceFundStakeAccountSubscriber.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketInsuranceFundStakeAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketInsuranceFundStakeAccountSubscriber {
+    constructor(program, insuranceFundStakeAccountPublicKey, reconnectTimeoutMs, commitment) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.insuranceFundStakeAccountPublicKey =
+            insuranceFundStakeAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.reconnectTimeoutMs = reconnectTimeoutMs;
+        this.commitment = commitment;
+    }
+    async subscribe(insuranceFundStakeAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.insuranceFundStakeDataAccountSubscriber =
+            new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('insuranceFundStake', this.program, this.insuranceFundStakeAccountPublicKey, undefined, this.reconnectTimeoutMs, this.commitment);
+        if (insuranceFundStakeAccount) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStakeAccount);
+        }
+        await this.insuranceFundStakeDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.insuranceFundStakeDataAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([
+            this.insuranceFundStakeDataAccountSubscriber.unsubscribe(),
+        ]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getInsuranceFundStakeAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.insuranceFundStakeDataAccountSubscriber.dataAndSlot;
+    }
+    updateData(insuranceFundStake, slot) {
+        var _a;
+        const currentDataSlot = ((_a = this.insuranceFundStakeDataAccountSubscriber.dataAndSlot) === null || _a === void 0 ? void 0 : _a.slot) || 0;
+        if (currentDataSlot <= slot) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStake, slot);
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', insuranceFundStake);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.WebSocketInsuranceFundStakeAccountSubscriber = WebSocketInsuranceFundStakeAccountSubscriber;

package/lib/dlob/DLOB.d.ts

@@ -68,11 +68,15 @@ export declare class DLOB {
     updateRestingLimitOrdersForMarketType(slot: number, marketTypeStr: MarketTypeStr): void;
     getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
+    getMakerRebate(marketType: MarketType, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): {
+        makerRebateNumerator: number;
+        makerRebateDenominator: number;
+    };
     mergeNodesToFill(restingLimitOrderNodesToFill: NodeToFill[], takingOrderNodesToFill: NodeToFill[]): NodeToFill[];
-    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
+    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, makerRebateNumerator: number, makerRebateDenominator: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     findTakingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
     findTakingNodesCrossingMakerNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
-    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, fallbackPrice: BN, doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean, minAuctionDuration: number): NodeToFill[];
+    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, doesCross: (nodePrice: BN | undefined) => boolean, minAuctionDuration: number): NodeToFill[];
     findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
     findJitAuctionNodesToFill(marketIndex: number, slot: number, oraclePriceData: OraclePriceData, marketType: MarketType): NodeToFill[];
     getTakingBids(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData): Generator<DLOBNode>;

package/lib/dlob/DLOB.js

@@ -304,7 +304,8 @@ class DLOB {
         const minAuctionDuration = (0, __1.isVariant)(marketType, 'perp')
             ? stateAccount.minPerpAuctionDuration
             : 0;
-        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
+        const { makerRebateNumerator, makerRebateDenominator } = this.getMakerRebate(marketType, stateAccount, marketAccount);
+        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, makerRebateNumerator, makerRebateDenominator, fallbackAsk, fallbackBid);
         const takingOrderNodesToFill = this.findTakingNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
         // get expired market nodes
         const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
@@ -314,6 +315,28 @@ class DLOB {
         }
         return this.mergeNodesToFill(restingLimitOrderNodesToFill, takingOrderNodesToFill).concat(expiredNodesToFill);
     }
+    getMakerRebate(marketType, stateAccount, marketAccount) {
+        let makerRebateNumerator;
+        let makerRebateDenominator;
+        if ((0, __1.isVariant)(marketType, 'perp')) {
+            makerRebateNumerator =
+                stateAccount.perpFeeStructure.feeTiers[0].makerRebateNumerator;
+            makerRebateDenominator =
+                stateAccount.perpFeeStructure.feeTiers[0].makerRebateDenominator;
+        }
+        else {
+            makerRebateNumerator =
+                stateAccount.spotFeeStructure.feeTiers[0].makerRebateNumerator;
+            makerRebateDenominator =
+                stateAccount.spotFeeStructure.feeTiers[0].makerRebateDenominator;
+        }
+        // @ts-ignore
+        const feeAdjustment = marketAccount.feeAdjustment || 0;
+        if (feeAdjustment !== 0) {
+            makerRebateNumerator += (makerRebateNumerator * feeAdjustment) / 100;
+        }
+        return { makerRebateNumerator, makerRebateDenominator };
+    }
     mergeNodesToFill(restingLimitOrderNodesToFill, takingOrderNodesToFill) {
         const mergedNodesToFill = new Map();
         const mergeNodesToFillHelper = (nodesToFillArray) => {
@@ -336,7 +359,7 @@ class DLOB {
         mergeNodesToFillHelper(takingOrderNodesToFill);
         return Array.from(mergedNodesToFill.values());
     }
-    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid) {
+    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, makerRebateNumerator, makerRebateDenominator, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         const crossingNodes = this.findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
         for (const crossingNode of crossingNodes) {
@@ -344,8 +367,9 @@ class DLOB {
         }
         if (fallbackBid && !isAmmPaused) {
             const askGenerator = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
-            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, fallbackBid, (askPrice, fallbackPrice) => {
-                return askPrice.lte(fallbackPrice);
+            const fallbackBidWithBuffer = fallbackBid.sub(fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator));
+            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, (askPrice) => {
+                return askPrice.lte(fallbackBidWithBuffer);
             }, minAuctionDuration);
             for (const askCrossingFallback of asksCrossingFallback) {
                 nodesToFill.push(askCrossingFallback);
@@ -353,8 +377,9 @@ class DLOB {
         }
         if (fallbackAsk && !isAmmPaused) {
             const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
-            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, fallbackAsk, (bidPrice, fallbackPrice) => {
-                return bidPrice.gte(fallbackPrice);
+            const fallbackAskWithBuffer = fallbackAsk.add(fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator));
+            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, (bidPrice) => {
+                return bidPrice.gte(fallbackAskWithBuffer);
             }, minAuctionDuration);
             for (const bidCrossingFallback of bidsCrossingFallback) {
                 nodesToFill.push(bidCrossingFallback);
@@ -381,8 +406,8 @@ class DLOB {
         }
         if (fallbackBid && !isAmmPaused) {
             takingOrderGenerator = this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData);
-            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackBid, (takerPrice, fallbackPrice) => {
-                return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, (takerPrice) => {
+                return takerPrice === undefined || takerPrice.lte(fallbackBid);
             }, minAuctionDuration);
             for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
                 nodesToFill.push(takingAskCrossingFallback);
@@ -405,8 +430,8 @@ class DLOB {
         }
         if (fallbackAsk && !isAmmPaused) {
             takingOrderGenerator = this.getTakingBids(marketIndex, marketType, slot, oraclePriceData);
-            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackAsk, (takerPrice, fallbackPrice) => {
-                return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, (takerPrice) => {
+                return takerPrice === undefined || takerPrice.gte(fallbackAsk);
             }, minAuctionDuration);
             for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
                 nodesToFill.push(marketBidCrossingFallback);
@@ -456,7 +481,7 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, fallbackPrice, doesCross, minAuctionDuration) {
+    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, doesCross, minAuctionDuration) {
         var _a;
         const nodesToFill = new Array();
         let nextNode = nodeGenerator.next();
@@ -468,7 +493,7 @@ class DLOB {
             }
             const nodePrice = (0, __1.getLimitPrice)(node.order, oraclePriceData, slot);
             // order crosses if there is no limit price or it crosses fallback price
-            const crosses = doesCross(nodePrice, fallbackPrice);
+            const crosses = doesCross(nodePrice);
             // fallback is available if auction is complete or it's a spot order
             const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') ||
                 (0, __1.isFallbackAvailableLiquiditySource)(node.order, minAuctionDuration, slot);