@drift-labs/sdk 2.52.0-beta.1 → 2.52.0-beta.3

package/VERSION

@@ -1 +1 @@
-2.52.0-beta.1
+2.52.0-beta.3

package/lib/accounts/webSocketAccountSubscriber.d.ts

@@ -24,5 +24,5 @@ export declare class WebSocketAccountSubscriber<T> implements AccountSubscriber<
     fetch(): Promise<void>;
     handleRpcResponse(context: Context, accountInfo?: AccountInfo<Buffer>): void;
     decodeBuffer(buffer: Buffer): T;
-    unsubscribe(): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
 }

package/lib/accounts/webSocketAccountSubscriber.js

@@ -15,7 +15,7 @@ class WebSocketAccountSubscriber {
             commitment !== null && commitment !== void 0 ? commitment : this.program.provider.opts.commitment;
     }
     async subscribe(onChange) {
-        if (this.listenerId || this.isUnsubscribing) {
+        if (this.listenerId != null || this.isUnsubscribing) {
             return;
         }
         this.onChange = onChange;
@@ -58,7 +58,7 @@ class WebSocketAccountSubscriber {
             }
             if (this.receivingData) {
                 console.log(`No ws data from ${this.accountName} in ${this.resubTimeoutMs}ms, resubscribing`);
-                await this.unsubscribe();
+                await this.unsubscribe(true);
                 this.receivingData = false;
                 await this.subscribe(this.onChange);
             }
@@ -114,11 +114,14 @@ class WebSocketAccountSubscriber {
             return this.program.account[this.accountName].coder.accounts.decode((0, utils_1.capitalize)(this.accountName), buffer);
         }
     }
-    unsubscribe() {
+    unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
         this.isUnsubscribing = true;
         clearTimeout(this.timeoutId);
         this.timeoutId = undefined;
-        if (this.listenerId) {
+        if (this.listenerId != null) {
             const promise = this.program.provider.connection
                 .removeAccountChangeListener(this.listenerId)
                 .then(() => {

package/lib/accounts/webSocketProgramAccountSubscriber.d.ts

@@ -29,5 +29,5 @@ export declare class WebSocketProgramAccountSubscriber<T> implements ProgramAcco
     subscribe(onChange: (accountId: PublicKey, data: T, context: Context) => void): Promise<void>;
     private setTimeout;
     handleRpcResponse(context: Context, keyedAccountInfo: KeyedAccountInfo): void;
-    unsubscribe(): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
 }

package/lib/accounts/webSocketProgramAccountSubscriber.js

@@ -17,7 +17,7 @@ class WebSocketProgramAccountSubscriber {
     }
     async subscribe(onChange) {
         var _a;
-        if (this.listenerId || this.isUnsubscribing) {
+        if (this.listenerId != null || this.isUnsubscribing) {
             return;
         }
         this.onChange = onChange;
@@ -47,7 +47,7 @@ class WebSocketProgramAccountSubscriber {
             }
             if (this.receivingData) {
                 console.log(`No ws data from ${this.subscriptionName} in ${this.resubTimeoutMs}ms, resubscribing`);
-                await this.unsubscribe();
+                await this.unsubscribe(true);
                 this.receivingData = false;
                 await this.subscribe(this.onChange);
             }
@@ -93,11 +93,14 @@ class WebSocketProgramAccountSubscriber {
             this.onChange(keyedAccountInfo.accountId, account, context);
         }
     }
-    unsubscribe() {
+    unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
         this.isUnsubscribing = true;
         clearTimeout(this.timeoutId);
         this.timeoutId = undefined;
-        if (this.listenerId) {
+        if (this.listenerId != null) {
             const promise = this.program.provider.connection
                 .removeAccountChangeListener(this.listenerId)
                 .then(() => {

package/lib/dlob/orderBookLevels.d.ts

@@ -47,4 +47,26 @@ export declare function getVammL2Generator({ marketAccount, oraclePriceData, num
     topOfBookQuoteAmounts?: BN[];
 }): L2OrderBookGenerator;
 export declare function groupL2(l2: L2OrderBook, grouping: BN, depth: number): L2OrderBook;
+/**
+ * The purpose of this function is uncross the L2 orderbook by modifying the bid/ask price at the top of the book
+ * This will make the liquidity look worse but more intuitive (users familiar with clob get confused w temporarily
+ * crossing book)
+ *
+ * Things to note about how it works:
+ * - it will not uncross the user's liquidity
+ * - it does the uncrossing by "shifting" the crossing liquidity to the nearest uncrossed levels. Thus the output liquidity maintains the same total size.
+ *
+ * @param bids
+ * @param asks
+ * @param oraclePrice
+ * @param oracleTwap5Min
+ * @param markTwap5Min
+ * @param grouping
+ * @param userBids
+ * @param userAsks
+ */
+export declare function uncrossL2(bids: L2Level[], asks: L2Level[], oraclePrice: BN, oracleTwap5Min: BN, markTwap5Min: BN, grouping: BN, userBids: Set<string>, userAsks: Set<string>): {
+    bids: L2Level[];
+    asks: L2Level[];
+};
 export {};

package/lib/dlob/orderBookLevels.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupL2 = exports.getVammL2Generator = exports.createL2Levels = exports.mergeL2LevelGenerators = exports.getL2GeneratorFromDLOBNodes = exports.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = void 0;
+exports.uncrossL2 = exports.groupL2 = exports.getVammL2Generator = exports.createL2Levels = exports.mergeL2LevelGenerators = exports.getL2GeneratorFromDLOBNodes = exports.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = void 0;
 const __1 = require("..");
 const assert_1 = require("../assert/assert");
 exports.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = [
@@ -245,3 +245,117 @@ function groupL2Levels(levels, grouping, direction, depth) {
     }
     return groupedLevels;
 }
+/**
+ * The purpose of this function is uncross the L2 orderbook by modifying the bid/ask price at the top of the book
+ * This will make the liquidity look worse but more intuitive (users familiar with clob get confused w temporarily
+ * crossing book)
+ *
+ * Things to note about how it works:
+ * - it will not uncross the user's liquidity
+ * - it does the uncrossing by "shifting" the crossing liquidity to the nearest uncrossed levels. Thus the output liquidity maintains the same total size.
+ *
+ * @param bids
+ * @param asks
+ * @param oraclePrice
+ * @param oracleTwap5Min
+ * @param markTwap5Min
+ * @param grouping
+ * @param userBids
+ * @param userAsks
+ */
+function uncrossL2(bids, asks, oraclePrice, oracleTwap5Min, markTwap5Min, grouping, userBids, userAsks) {
+    // If there are no bids or asks, there is nothing to center
+    if (bids.length === 0 || asks.length === 0) {
+        return { bids, asks };
+    }
+    // If the top of the book is already centered, there is nothing to do
+    if (bids[0].price.lt(asks[0].price)) {
+        return { bids, asks };
+    }
+    const newBids = [];
+    const newAsks = [];
+    const updateLevels = (newPrice, oldLevel, levels) => {
+        if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
+            levels[levels.length - 1].size = levels[levels.length - 1].size.add(oldLevel.size);
+            for (const [source, size] of Object.entries(oldLevel.sources)) {
+                if (levels[levels.length - 1].sources[source]) {
+                    levels[levels.length - 1].sources = {
+                        ...levels[levels.length - 1].sources,
+                        [source]: levels[levels.length - 1].sources[source].add(size),
+                    };
+                }
+                else {
+                    levels[levels.length - 1].sources[source] = size;
+                }
+            }
+        }
+        else {
+            levels.push({
+                price: newPrice,
+                size: oldLevel.size,
+                sources: oldLevel.sources,
+            });
+        }
+    };
+    // This is the best estimate of the premium in the market vs oracle to filter crossing around
+    const referencePrice = oraclePrice.add(markTwap5Min.sub(oracleTwap5Min));
+    let bidIndex = 0;
+    let askIndex = 0;
+    while (bidIndex < bids.length || askIndex < asks.length) {
+        const nextBid = bids[bidIndex];
+        const nextAsk = asks[askIndex];
+        if (!nextBid) {
+            newAsks.push(nextAsk);
+            askIndex++;
+            continue;
+        }
+        if (!nextAsk) {
+            newBids.push(nextBid);
+            bidIndex++;
+            continue;
+        }
+        if (nextBid.price.gt(nextAsk.price)) {
+            if (userBids.has(nextBid.price.toString())) {
+                newBids.push(nextBid);
+                bidIndex++;
+                continue;
+            }
+            if (userAsks.has(nextAsk.price.toString())) {
+                newAsks.push(nextAsk);
+                askIndex++;
+                continue;
+            }
+            if (nextBid.price.gt(referencePrice) &&
+                nextAsk.price.gt(referencePrice)) {
+                const newBidPrice = nextAsk.price.sub(grouping);
+                updateLevels(newBidPrice, nextBid, newBids);
+                bidIndex++;
+            }
+            else if (nextAsk.price.lt(referencePrice) &&
+                nextBid.price.lt(referencePrice)) {
+                const newAskPrice = nextBid.price.add(grouping);
+                updateLevels(newAskPrice, nextAsk, newAsks);
+                askIndex++;
+            }
+            else {
+                const newBidPrice = referencePrice.sub(grouping);
+                const newAskPrice = referencePrice.add(grouping);
+                updateLevels(newBidPrice, nextBid, newBids);
+                updateLevels(newAskPrice, nextAsk, newAsks);
+                bidIndex++;
+                askIndex++;
+            }
+        }
+        else {
+            newAsks.push(nextAsk);
+            askIndex++;
+            newBids.push(nextBid);
+            bidIndex++;
+        }
+    }
+    return {
+        bids: newBids,
+        asks: newAsks,
+    };
+}
+exports.uncrossL2 = uncrossL2;

package/lib/driftClient.js

@@ -2216,8 +2216,13 @@ class DriftClient {
     async getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }) {
         const userAccountPublicKeyToUse = userAccountPublicKey || (await this.getUserAccountPublicKey());
         const userAccounts = [];
-        if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
-            userAccounts.push(this.getUser().getUserAccountAndSlot().data);
+        try {
+            if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
+                userAccounts.push(this.getUser().getUserAccountAndSlot().data);
+            }
+        }
+        catch (err) {
+            // ignore
         }
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts,

package/lib/events/webSocketLogProvider.js

@@ -17,7 +17,7 @@ class WebSocketLogProvider {
         }
     }
     async subscribe(callback) {
-        if (this.subscriptionId) {
+        if (this.subscriptionId != null) {
             return true;
         }
         this.callback = callback;
@@ -48,14 +48,14 @@ class WebSocketLogProvider {
         }, this.commitment);
     }
     isSubscribed() {
-        return this.subscriptionId !== undefined;
+        return this.subscriptionId != null;
     }
     async unsubscribe(external = false) {
         this.isUnsubscribing = true;
         this.externalUnsubscribe = external;
         clearTimeout(this.timeoutId);
         this.timeoutId = undefined;
-        if (this.subscriptionId !== undefined) {
+        if (this.subscriptionId != null) {
             try {
                 await this.connection.removeOnLogsListener(this.subscriptionId);
                 this.subscriptionId = undefined;

package/lib/factory/bigNum.d.ts

@@ -86,7 +86,7 @@ export declare class BigNum {
      * @returns
      */
     toNotional(useTradePrecision?: boolean, precisionOverride?: number): string;
-    toMillified(precision?: number, rounded?: boolean): string;
+    toMillified(precision?: number, rounded?: boolean, type?: 'financial' | 'scientific'): string;
     toJSON(): {
         val: string;
         precision: string;

package/lib/factory/bigNum.js

@@ -330,7 +330,7 @@ class BigNum {
         }
         return `${prefix}${val.replace('-', '')}`;
     }
-    toMillified(precision = 3, rounded = false) {
+    toMillified(precision = 3, rounded = false, type = 'financial') {
         if (rounded) {
             return this.toRounded(precision).toMillified(precision);
         }
@@ -346,7 +346,10 @@ class BigNum {
         if (leftSide.length <= 3) {
             return this.shift(new anchor_1.BN(precision)).toPrecision(precision, true);
         }
-        const unitTicks = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+        const unitTicks = type === 'financial'
+            ? ['', 'K', 'M', 'B', 'T', 'Q']
+            : ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+        // TODO -- handle nubers which are larger than the max unit tick
         const unitNumber = Math.floor((leftSide.length - 1) / 3);
         const unit = unitTicks[unitNumber];
         let leadDigits = leftSide.slice(0, precision);

package/lib/idl/drift.json

@@ -7343,12 +7343,24 @@
                         "name": "totalFeeEarnedPerLp",
                         "type": "u64"
                     },
+                    {
+                        "name": "netUnsettledFundingPnl",
+                        "type": "i64"
+                    },
+                    {
+                        "name": "quoteAssetAmountWithUnsettledLp",
+                        "type": "i64"
+                    },
+                    {
+                        "name": "referencePriceOffset",
+                        "type": "i32"
+                    },
                     {
                         "name": "padding",
                         "type": {
                             "array": [
                                 "u8",
-                                32
+                                12
                             ]
                         }
                     }

package/lib/math/amm.d.ts

@@ -34,7 +34,9 @@ export type AssetType = 'quote' | 'base';
  */
 export declare function calculateAmmReservesAfterSwap(amm: Pick<AMM, 'pegMultiplier' | 'quoteAssetReserve' | 'sqrtK' | 'baseAssetReserve'>, inputAssetType: AssetType, swapAmount: BN, swapDirection: SwapDirection): [BN, BN];
 export declare function calculateMarketOpenBidAsk(baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN, stepSize?: BN): [BN, BN];
+export declare function calculateInventoryLiquidityRatio(baseAssetAmountWithAmm: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): BN;
 export declare function calculateInventoryScale(baseAssetAmountWithAmm: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN, directionalSpread: number, maxSpread: number): number;
+export declare function calculateReferencePriceOffset(reservePrice: BN, last24hAvgFundingRate: BN, liquidityFraction: BN, oracleTwapFast: BN, markTwapFast: BN, oracleTwapSlow: BN, markTwapSlow: BN, maxOffsetPct: number): BN;
 export declare function calculateEffectiveLeverage(baseSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, reservePrice: BN, totalFeeMinusDistributions: BN): number;
 export declare function calculateMaxSpread(marginRatioInitial: number): number;
 export declare function calculateVolSpreadBN(lastOracleConfPct: BN, reservePrice: BN, markStd: BN, oracleStd: BN, longIntensity: BN, shortIntensity: BN, volume24H: BN): [BN, BN];
@@ -55,11 +57,13 @@ export declare function calculateSpreadBN(baseSpread: number, lastOracleReserveP
     halfRevenueRetreatAmount: number;
     longSpreadwRevRetreat: number;
     shortSpreadwRevRetreat: number;
+    longSpreadwOffsetShrink: number;
+    shortSpreadwOffsetShrink: number;
     totalSpread: number;
     longSpread: number;
     shortSpread: number;
 };
-export declare function calculateSpread(amm: AMM, oraclePriceData: OraclePriceData, now?: BN): [number, number];
+export declare function calculateSpread(amm: AMM, oraclePriceData: OraclePriceData, now?: BN, reservePrice?: BN): [number, number];
 export declare function calculateSpreadReserves(amm: AMM, oraclePriceData: OraclePriceData, now?: BN): {
     baseAssetReserve: any;
     quoteAssetReserve: any;

package/lib/math/amm.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateVolSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateInventoryScale = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
+exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateVolSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateReferencePriceOffset = exports.calculateInventoryScale = exports.calculateInventoryLiquidityRatio = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -201,11 +201,7 @@ function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBas
     return [openBids, openAsks];
 }
 exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
-function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, directionalSpread, maxSpread) {
-    if (baseAssetAmountWithAmm.eq(numericConstants_1.ZERO)) {
-        return 1;
-    }
-    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
+function calculateInventoryLiquidityRatio(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
     // inventory skew
     const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
     const minSideLiquidity = anchor_1.BN.min(openBids.abs(), openAsks.abs());
@@ -213,6 +209,15 @@ function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBa
         .mul(numericConstants_1.PERCENTAGE_PRECISION)
         .div(anchor_1.BN.max(minSideLiquidity, numericConstants_1.ONE))
         .abs(), numericConstants_1.PERCENTAGE_PRECISION);
+    return inventoryScaleBN;
+}
+exports.calculateInventoryLiquidityRatio = calculateInventoryLiquidityRatio;
+function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, directionalSpread, maxSpread) {
+    if (baseAssetAmountWithAmm.eq(numericConstants_1.ZERO)) {
+        return 1;
+    }
+    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
+    const inventoryScaleBN = calculateInventoryLiquidityRatio(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
     const inventoryScaleMaxBN = anchor_1.BN.max(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, new anchor_1.BN(maxSpread)
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(new anchor_1.BN(Math.max(directionalSpread, 1))));
@@ -220,6 +225,36 @@ function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBa
     return inventoryScaleCapped;
 }
 exports.calculateInventoryScale = calculateInventoryScale;
+function calculateReferencePriceOffset(reservePrice, last24hAvgFundingRate, liquidityFraction, oracleTwapFast, markTwapFast, oracleTwapSlow, markTwapSlow, maxOffsetPct) {
+    if (last24hAvgFundingRate.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const maxOffsetInPrice = new anchor_1.BN(maxOffsetPct)
+        .mul(reservePrice)
+        .div(numericConstants_1.PERCENTAGE_PRECISION);
+    // Calculate quote denominated market premium
+    const markPremiumMinute = (0, __1.clampBN)(markTwapFast.sub(oracleTwapFast), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    const markPremiumHour = (0, __1.clampBN)(markTwapSlow.sub(oracleTwapSlow), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    // Convert last24hAvgFundingRate to quote denominated premium
+    const markPremiumDay = (0, __1.clampBN)(last24hAvgFundingRate.div(numericConstants_1.FUNDING_RATE_BUFFER_PRECISION).mul(new anchor_1.BN(24)), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    // Take average clamped premium as the price-based offset
+    const markPremiumAvg = markPremiumMinute
+        .add(markPremiumHour)
+        .add(markPremiumDay)
+        .div(new anchor_1.BN(3));
+    const markPremiumAvgPct = markPremiumAvg
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(reservePrice);
+    const inventoryPct = (0, __1.clampBN)(liquidityFraction.mul(new anchor_1.BN(maxOffsetPct)).div(numericConstants_1.PERCENTAGE_PRECISION), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    // Only apply when inventory is consistent with recent and 24h market premium
+    let offsetPct = markPremiumAvgPct.add(inventoryPct);
+    if (!(0, __1.sigNum)(inventoryPct).eq((0, __1.sigNum)(markPremiumAvgPct))) {
+        offsetPct = numericConstants_1.ZERO;
+    }
+    const clampedOffsetPct = (0, __1.clampBN)(offsetPct, new anchor_1.BN(-maxOffsetPct), new anchor_1.BN(maxOffsetPct));
+    return clampedOffsetPct;
+}
+exports.calculateReferencePriceOffset = calculateReferencePriceOffset;
 function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions) {
     // vAMM skew
     const netBaseAssetValue = quoteAssetReserve
@@ -283,6 +318,8 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
         halfRevenueRetreatAmount: 0,
         longSpreadwRevRetreat: 0,
         shortSpreadwRevRetreat: 0,
+        longSpreadwOffsetShrink: 0,
+        shortSpreadwOffsetShrink: 0,
         totalSpread: 0,
         longSpread: 0,
         shortSpread: 0,
@@ -380,11 +417,13 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
     return [longSpread, shortSpread];
 }
 exports.calculateSpreadBN = calculateSpreadBN;
-function calculateSpread(amm, oraclePriceData, now) {
+function calculateSpread(amm, oraclePriceData, now, reservePrice) {
     if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
         return [amm.baseSpread / 2, amm.baseSpread / 2];
     }
-    const reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    if (!reservePrice) {
+        reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    }
     const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || reservePrice;
     const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
     const targetMarkSpreadPct = reservePrice
@@ -410,10 +449,15 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
                 quoteAssetReserve: amm.quoteAssetReserve,
             };
         }
-        const spreadFraction = anchor_1.BN.max(new anchor_1.BN(spread / 2), numericConstants_1.ONE);
+        let spreadFraction = new anchor_1.BN(spread / 2);
+        // make non-zero
+        if (spreadFraction.eq(numericConstants_1.ZERO)) {
+            spreadFraction = spread >= 0 ? new anchor_1.BN(1) : new anchor_1.BN(-1);
+        }
         const quoteAssetReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(spreadFraction));
         let quoteAssetReserve;
-        if ((0, types_1.isVariant)(direction, 'long')) {
+        if ((spread >= 0 && (0, types_1.isVariant)(direction, 'long')) ||
+            (spread <= 0 && (0, types_1.isVariant)(direction, 'short'))) {
             quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
         }
         else {
@@ -425,9 +469,14 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
             quoteAssetReserve,
         };
     }
-    const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData, now);
-    const askReserves = calculateSpreadReserve(longSpread, types_1.PositionDirection.LONG, amm);
-    const bidReserves = calculateSpreadReserve(shortSpread, types_1.PositionDirection.SHORT, amm);
+    const reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    // always allow 10 bps of price offset, up to a fifth of the market's max_spread
+    const maxOffset = Math.max(amm.maxSpread / 5, numericConstants_1.PERCENTAGE_PRECISION.toNumber() / 1000);
+    const liquidityFraction = calculateInventoryLiquidityRatio(amm.baseAssetAmountWithAmm, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
+    const referencePriceOffset = calculateReferencePriceOffset(reservePrice, amm.last24HAvgFundingRate, liquidityFraction, amm.historicalOracleData.lastOraclePriceTwap5Min, amm.lastMarkPriceTwap5Min, amm.historicalOracleData.lastOraclePriceTwap, amm.lastMarkPriceTwap, maxOffset);
+    const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData, now, reservePrice);
+    const askReserves = calculateSpreadReserve(longSpread + referencePriceOffset.toNumber(), types_1.PositionDirection.LONG, amm);
+    const bidReserves = calculateSpreadReserve(shortSpread + referencePriceOffset.toNumber(), types_1.PositionDirection.SHORT, amm);
     return [bidReserves, askReserves];
 }
 exports.calculateSpreadReserves = calculateSpreadReserves;

package/lib/phoenix/phoenixSubscriber.js

@@ -104,9 +104,9 @@ class PhoenixSubscriber {
         const ladder = (0, phoenix_sdk_1.getMarketUiLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 20);
         for (let i = 0; i < ladder[side].length; i++) {
             const { price, quantity } = ladder[side][i];
-            const size = new anchor_1.BN(Math.floor(quantity * basePrecision));
+            const size = new anchor_1.BN(quantity).mul(new anchor_1.BN(basePrecision));
             yield {
-                price: new anchor_1.BN(Math.floor(price * pricePrecision)),
+                price: new anchor_1.BN(price).mul(new anchor_1.BN(pricePrecision)),
                 size,
                 sources: {
                     phoenix: size,

package/lib/slot/SlotSubscriber.d.ts

@@ -1,8 +1,11 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Connection } from '@solana/web3.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types/types/src';
-type SlotSubscriberConfig = {};
+type SlotSubscriberConfig = {
+    resubTimeoutMs?: number;
+};
 export interface SlotSubscriberEvents {
     newSlot: (newSlot: number) => void;
 }
@@ -11,9 +14,14 @@ export declare class SlotSubscriber {
     currentSlot: number;
     subscriptionId: number;
     eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
-    constructor(connection: Connection, _config?: SlotSubscriberConfig);
+    timeoutId?: NodeJS.Timeout;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlotSubscriberConfig);
     subscribe(): Promise<void>;
+    private setTimeout;
     getSlot(): number;
-    unsubscribe(): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
 }
 export {};

package/lib/slot/SlotSubscriber.js

@@ -3,28 +3,64 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlotSubscriber = void 0;
 const events_1 = require("events");
 class SlotSubscriber {
-    constructor(connection, _config) {
+    constructor(connection, config) {
         this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
         this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
     }
     async subscribe() {
-        if (this.subscriptionId) {
+        if (this.subscriptionId != null) {
             return;
         }
         this.currentSlot = await this.connection.getSlot('confirmed');
         this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
             if (!this.currentSlot || this.currentSlot < slotInfo.slot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
                 this.currentSlot = slotInfo.slot;
                 this.eventEmitter.emit('newSlot', slotInfo.slot);
             }
         });
+        if (this.resubTimeoutMs) {
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
     }
     getSlot() {
         return this.currentSlot;
     }
-    async unsubscribe() {
-        if (this.subscriptionId) {
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
             await this.connection.removeSlotChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
         }
     }
 }

package/lib/types.d.ts

@@ -767,7 +767,7 @@ export type AMM = {
     pegMultiplier: BN;
     cumulativeFundingRateLong: BN;
     cumulativeFundingRateShort: BN;
-    last24hAvgFundingRate: BN;
+    last24HAvgFundingRate: BN;
     lastFundingRateShort: BN;
     lastFundingRateLong: BN;
     totalLiquidationFee: BN;

package/lib/user.d.ts

@@ -353,7 +353,7 @@ export declare class User {
      * @param quoteAmount
      * @returns feeForQuote : Precision QUOTE_PRECISION
      */
-    calculateFeeForQuoteAmount(quoteAmount: BN): BN;
+    calculateFeeForQuoteAmount(quoteAmount: BN, marketIndex?: number): BN;
     /**
      * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,
      * it will return the max withdrawal amount without opening a liability for the user