@drift-labs/sdk 2.52.0-beta.9 → 2.53.0-beta.0

package/VERSION

@@ -1 +1 @@
-2.52.0-beta.9
+2.53.0-beta.0

package/examples/phoenix.ts

@@ -1,38 +1,57 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { BASE_PRECISION, PRICE_PRECISION, PhoenixSubscriber } from '../src';
+import {
+	BASE_PRECISION,
+	L2Level,
+	PRICE_PRECISION,
+	PhoenixSubscriber,
+} from '../src';
 import { PROGRAM_ID } from '@ellipsis-labs/phoenix-sdk';
 
 export async function listenToBook(): Promise<void> {
 	const connection = new Connection('https://api.mainnet-beta.solana.com');
 
-	const phoenixSubscriber = new PhoenixSubscriber({
-		connection,
-		programId: PROGRAM_ID,
-		marketAddress: new PublicKey(
-			'4DoNfFBfF7UokCC2FQzriy7yHK6DY6NVdYpuekQ5pRgg'
-		),
-		accountSubscription: {
-			type: 'websocket',
-		},
-	});
-
-	await phoenixSubscriber.subscribe();
-
-	for (let i = 0; i < 10; i++) {
-		const bids = phoenixSubscriber.getL2Levels("bids");
-		const asks = phoenixSubscriber.getL2Levels("asks");
-		console.log("bids");
-		for (const bid of bids) {
-			console.log(bid.price.toNumber() / PRICE_PRECISION.toNumber(), bid.size.toNumber() / BASE_PRECISION.toNumber());
+	for (const market of [
+		'4DoNfFBfF7UokCC2FQzriy7yHK6DY6NVdYpuekQ5pRgg', // SOL/USDC
+		'Ew3vFDdtdGrknJAVVfraxCA37uNJtimXYPY4QjnfhFHH', // ETH/USDC
+		'2sTMN9A1D1qeZLF95XQgJCUPiKe5DiV52jLfZGqMP46m', // PYTH/USDC
+		'BRLLmdtPGuuFn3BU6orYw4KHaohAEptBToi3dwRUnHQZ', // JTO/USDC
+	]) {
+		const phoenixSubscriber = new PhoenixSubscriber({
+			connection,
+			programId: PROGRAM_ID,
+			marketAddress: new PublicKey(market),
+			accountSubscription: {
+				type: 'websocket',
+			},
+		});
+
+		await phoenixSubscriber.subscribe();
+
+		const bids = phoenixSubscriber.getL2Levels('bids');
+		const asks = phoenixSubscriber.getL2Levels('asks');
+		let bid: L2Level | null = null;
+		for (const b of bids) {
+			bid = b;
+			break;
 		}
-		console.log("asks");
-		for (const ask of asks) {
-			console.log(ask.price.toNumber() / PRICE_PRECISION.toNumber(), ask.size.toNumber() / BASE_PRECISION.toNumber());
+		let ask: L2Level | null = null;
+		for (const a of asks) {
+			ask = a;
+			break;
 		}
-		await new Promise((r) => setTimeout(r, 2000));
-	}
 
-	await phoenixSubscriber.unsubscribe();
+		console.log('market', market);
+		console.log(
+			(bid?.size.toNumber() || 0) / BASE_PRECISION.toNumber(),
+			(bid?.price.toNumber() || 0) / PRICE_PRECISION.toNumber(),
+			'@',
+			(ask?.price.toNumber() || (1 << 53) - 1) / PRICE_PRECISION.toNumber(),
+			(ask?.size.toNumber() || 0) / BASE_PRECISION.toNumber()
+		);
+		console.log();
+
+		await phoenixSubscriber.unsubscribe();
+	}
 }
 
 (async function () {

package/lib/constants/perpMarkets.js

@@ -214,6 +214,16 @@ exports.DevnetPerpMarkets = [
         launchTs: 1701967240000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'SEI',
+        category: ['L1'],
+        symbol: 'SEI-PERP',
+        baseAssetSymbol: 'SEI',
+        marketIndex: 21,
+        oracle: new web3_js_1.PublicKey('B6KVbgqTRY33yDgjAnc1mWw4ATS4W5544xghayQscdt7'),
+        launchTs: 1703173331000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.MainnetPerpMarkets = [
     {
@@ -426,6 +436,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1701967240000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'SEI',
+        category: ['L1'],
+        symbol: 'SEI-PERP',
+        baseAssetSymbol: 'SEI',
+        marketIndex: 21,
+        oracle: new web3_js_1.PublicKey('6cUuAyAX3eXoiWkjFF77RQBEUF15AAMQ7d1hm4EPd3tv'),
+        launchTs: 1703173331000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/driftClient.d.ts

@@ -133,8 +133,10 @@ export declare class DriftClient {
     getUserAccountsForAuthority(authority: PublicKey): Promise<UserAccount[]>;
     getReferredUserStatsAccountsByReferrer(referrer: PublicKey): Promise<UserStatsAccount[]>;
     getReferrerNameAccountsForAuthority(authority: PublicKey): Promise<ReferrerNameAccount[]>;
-    getUserDeletionIx(userAccountPublicKey: PublicKey): Promise<anchor.web3.TransactionInstruction>;
     deleteUser(subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getUserDeletionIx(userAccountPublicKey: PublicKey): Promise<anchor.web3.TransactionInstruction>;
+    reclaimRent(subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getReclaimRentIx(userAccountPublicKey: PublicKey): Promise<anchor.web3.TransactionInstruction>;
     getUser(subAccountId?: number, authority?: PublicKey): User;
     hasUser(subAccountId?: number, authority?: PublicKey): boolean;
     getUsers(): User[];

package/lib/driftClient.js

@@ -665,6 +665,16 @@ class DriftClient {
         ]);
         return programAccounts.map((programAccount) => programAccount.account);
     }
+    async deleteUser(subAccountId = 0, txParams) {
+        var _a;
+        const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId);
+        const ix = await this.getUserDeletionIx(userAccountPublicKey);
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(ix, txParams), [], this.opts);
+        const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
+        await ((_a = this.users.get(userMapKey)) === null || _a === void 0 ? void 0 : _a.unsubscribe());
+        this.users.delete(userMapKey);
+        return txSig;
+    }
     async getUserDeletionIx(userAccountPublicKey) {
         const ix = await this.program.instruction.deleteUser({
             accounts: {
@@ -676,16 +686,23 @@ class DriftClient {
         });
         return ix;
     }
-    async deleteUser(subAccountId = 0, txParams) {
-        var _a;
+    async reclaimRent(subAccountId = 0, txParams) {
         const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId);
-        const ix = await this.getUserDeletionIx(userAccountPublicKey);
+        const ix = await this.getReclaimRentIx(userAccountPublicKey);
         const { txSig } = await this.sendTransaction(await this.buildTransaction(ix, txParams), [], this.opts);
-        const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
-        await ((_a = this.users.get(userMapKey)) === null || _a === void 0 ? void 0 : _a.unsubscribe());
-        this.users.delete(userMapKey);
         return txSig;
     }
+    async getReclaimRentIx(userAccountPublicKey) {
+        return await this.program.instruction.reclaimRent({
+            accounts: {
+                user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+            },
+        });
+    }
     getUser(subAccountId, authority) {
         subAccountId = subAccountId !== null && subAccountId !== void 0 ? subAccountId : this.activeSubAccountId;
         authority = authority !== null && authority !== void 0 ? authority : this.authority;

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.51.0",
+    "version": "2.52.0",
     "name": "drift",
     "instructions": [
         {
@@ -1173,6 +1173,37 @@
             ],
             "args": []
         },
+        {
+            "name": "reclaimRent",
+            "accounts": [
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "userStats",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "rent",
+                    "isMut": false,
+                    "isSigner": false
+                }
+            ],
+            "args": []
+        },
         {
             "name": "fillPerpOrder",
             "accounts": [
@@ -11139,6 +11170,11 @@
             "code": 6256,
             "name": "CantPayUserInitFee",
             "msg": "CantPayUserInitFee"
+        },
+        {
+            "code": 6257,
+            "name": "CantReclaimRent",
+            "msg": "CantReclaimRent"
         }
     ]
 }

package/lib/math/amm.js

@@ -456,12 +456,11 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
         }
         const quoteAssetReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(spreadFraction));
         let quoteAssetReserve;
-        if ((spread >= 0 && (0, types_1.isVariant)(direction, 'long')) ||
-            (spread <= 0 && (0, types_1.isVariant)(direction, 'short'))) {
-            quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
+        if (quoteAssetReserveDelta.gte(numericConstants_1.ZERO)) {
+            quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta.abs());
         }
         else {
-            quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
+            quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta.abs());
         }
         const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
         return {
@@ -471,12 +470,18 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
     }
     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);
+    let maxOffset = 0;
+    let referencePriceOffset = numericConstants_1.ZERO;
+    if (amm.curveUpdateIntensity > 100) {
+        maxOffset = Math.max(amm.maxSpread / 5, (numericConstants_1.PERCENTAGE_PRECISION.toNumber() / 10000) *
+            (amm.curveUpdateIntensity - 100));
+        const liquidityFraction = calculateInventoryLiquidityRatio(amm.baseAssetAmountWithAmm, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
+        const liquidityFractionSigned = liquidityFraction.mul((0, __1.sigNum)(amm.baseAssetAmountWithAmm.add(amm.baseAssetAmountWithUnsettledLp)));
+        referencePriceOffset = calculateReferencePriceOffset(reservePrice, amm.last24HAvgFundingRate, liquidityFractionSigned, 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);
+    const bidReserves = calculateSpreadReserve(-shortSpread + referencePriceOffset.toNumber(), types_1.PositionDirection.SHORT, amm);
     return [bidReserves, askReserves];
 }
 exports.calculateSpreadReserves = calculateSpreadReserves;

package/lib/math/orders.d.ts

@@ -11,7 +11,7 @@ export declare function standardizePrice(price: BN, tickSize: BN, direction: Pos
 export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number, fallbackPrice?: BN): BN | undefined;
 export declare function hasLimitPrice(order: Order, slot: number): boolean;
 export declare function hasAuctionPrice(order: Order, slot: number): boolean;
-export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, ts: number): boolean;
+export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, ts: number, minAuctionDuration: number): boolean;
 export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
 export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, amm: AMM, limitPrice: BN, oraclePriceData: OraclePriceData): BN;
 export declare function isOrderExpired(order: Order, ts: number, enforceBuffer?: boolean): boolean;

package/lib/math/orders.js

@@ -124,8 +124,8 @@ function hasAuctionPrice(order, slot) {
         (!order.auctionStartPrice.eq(numericConstants_1.ZERO) || !order.auctionEndPrice.eq(numericConstants_1.ZERO)));
 }
 exports.hasAuctionPrice = hasAuctionPrice;
-function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
-    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+function isFillableByVAMM(order, market, oraclePriceData, slot, ts, minAuctionDuration) {
+    return (((0, auction_1.isFallbackAvailableLiquiditySource)(order, minAuctionDuration, slot) &&
         calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).gte(market.amm.minOrderSize)) ||
         isOrderExpired(order, ts));
 }

package/lib/math/state.js

@@ -22,6 +22,9 @@ function calculateInitUserFee(stateAccount) {
 }
 exports.calculateInitUserFee = calculateInitUserFee;
 function getMaxNumberOfSubAccounts(stateAccount) {
+    if (stateAccount.maxNumberOfSubAccounts <= 5) {
+        return new __1.BN(stateAccount.maxNumberOfSubAccounts);
+    }
     return new __1.BN(stateAccount.maxNumberOfSubAccounts).muln(100);
 }
 exports.getMaxNumberOfSubAccounts = getMaxNumberOfSubAccounts;

package/lib/phoenix/phoenixSubscriber.js

@@ -99,23 +99,25 @@ class PhoenixSubscriber {
         return this.getL2Levels('asks');
     }
     *getL2Levels(side) {
-        const tickSize = this.market.data.header
-            .tickSizeInQuoteAtomsPerBaseUnit;
-        const baseLotsToRawBaseUnits = this.market.baseLotsToRawBaseUnits(1);
-        const basePrecision = new anchor_1.BN(Math.pow(10, this.market.data.header.baseParams.decimals) *
-            baseLotsToRawBaseUnits);
-        const pricePrecision = numericConstants_1.PRICE_PRECISION.div(tickSize);
-        const ladder = (0, phoenix_sdk_1.getMarketLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 20);
+        const basePrecision = Math.pow(10, this.market.data.header.baseParams.decimals);
+        const pricePrecision = numericConstants_1.PRICE_PRECISION.toNumber();
+        const ladder = (0, phoenix_sdk_1.getMarketUiLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 20);
         for (let i = 0; i < ladder[side].length; i++) {
-            const { priceInTicks, sizeInBaseLots } = ladder[side][i];
-            const size = sizeInBaseLots.mul(basePrecision);
-            yield {
-                price: priceInTicks.mul(new anchor_1.BN(pricePrecision)),
-                size,
-                sources: {
-                    phoenix: size,
-                },
-            };
+            const { price, quantity } = ladder[side][i];
+            try {
+                const size = new anchor_1.BN(quantity * basePrecision);
+                const updatedPrice = new anchor_1.BN(price * pricePrecision);
+                yield {
+                    price: updatedPrice,
+                    size,
+                    sources: {
+                        phoenix: size,
+                    },
+                };
+            }
+            catch {
+                continue;
+            }
         }
     }
     async unsubscribe() {

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -25,16 +25,16 @@ class PriorityFeeSubscriber {
         }
     }
     get avgPriorityFee() {
-        return this.lastAvgStrategyResult;
+        return Math.floor(this.lastAvgStrategyResult);
     }
     get maxPriorityFee() {
-        return this.lastMaxStrategyResult;
+        return Math.floor(this.lastMaxStrategyResult);
     }
     get customPriorityFee() {
         if (!this.customStrategy) {
             console.error('Custom strategy not set');
         }
-        return this.lastCustomStrategyResult;
+        return Math.floor(this.lastCustomStrategyResult);
     }
     async subscribe() {
         if (this.intervalId) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.52.0-beta.9",
+	"version": "2.53.0-beta.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/constants/perpMarkets.ts

@@ -224,6 +224,16 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1701967240000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'SEI',
+		category: ['L1'],
+		symbol: 'SEI-PERP',
+		baseAssetSymbol: 'SEI',
+		marketIndex: 21,
+		oracle: new PublicKey('B6KVbgqTRY33yDgjAnc1mWw4ATS4W5544xghayQscdt7'),
+		launchTs: 1703173331000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const MainnetPerpMarkets: PerpMarketConfig[] = [
@@ -437,6 +447,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1701967240000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'SEI',
+		category: ['L1'],
+		symbol: 'SEI-PERP',
+		baseAssetSymbol: 'SEI',
+		marketIndex: 21,
+		oracle: new PublicKey('6cUuAyAX3eXoiWkjFF77RQBEUF15AAMQ7d1hm4EPd3tv'),
+		launchTs: 1703173331000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/driftClient.ts

@@ -1112,6 +1112,31 @@ export class DriftClient {
 		);
 	}
 
+	public async deleteUser(
+		subAccountId = 0,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const userAccountPublicKey = getUserAccountPublicKeySync(
+			this.program.programId,
+			this.wallet.publicKey,
+			subAccountId
+		);
+
+		const ix = await this.getUserDeletionIx(userAccountPublicKey);
+
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(ix, txParams),
+			[],
+			this.opts
+		);
+
+		const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
+		await this.users.get(userMapKey)?.unsubscribe();
+		this.users.delete(userMapKey);
+
+		return txSig;
+	}
+
 	public async getUserDeletionIx(userAccountPublicKey: PublicKey) {
 		const ix = await this.program.instruction.deleteUser({
 			accounts: {
@@ -1125,7 +1150,7 @@ export class DriftClient {
 		return ix;
 	}
 
-	public async deleteUser(
+	public async reclaimRent(
 		subAccountId = 0,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
@@ -1135,7 +1160,7 @@ export class DriftClient {
 			subAccountId
 		);
 
-		const ix = await this.getUserDeletionIx(userAccountPublicKey);
+		const ix = await this.getReclaimRentIx(userAccountPublicKey);
 
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(ix, txParams),
@@ -1143,13 +1168,21 @@ export class DriftClient {
 			this.opts
 		);
 
-		const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
-		await this.users.get(userMapKey)?.unsubscribe();
-		this.users.delete(userMapKey);
-
 		return txSig;
 	}
 
+	public async getReclaimRentIx(userAccountPublicKey: PublicKey) {
+		return await this.program.instruction.reclaimRent({
+			accounts: {
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+			},
+		});
+	}
+
 	public getUser(subAccountId?: number, authority?: PublicKey): User {
 		subAccountId = subAccountId ?? this.activeSubAccountId;
 		authority = authority ?? this.authority;

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.51.0",
+  "version": "2.52.0",
   "name": "drift",
   "instructions": [
     {
@@ -1173,6 +1173,37 @@
       ],
       "args": []
     },
+    {
+      "name": "reclaimRent",
+      "accounts": [
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userStats",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "rent",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
     {
       "name": "fillPerpOrder",
       "accounts": [
@@ -11139,6 +11170,11 @@
       "code": 6256,
       "name": "CantPayUserInitFee",
       "msg": "CantPayUserInitFee"
+    },
+    {
+      "code": 6257,
+      "name": "CantReclaimRent",
+      "msg": "CantReclaimRent"
     }
   ]
 }

package/src/math/amm.ts

@@ -863,13 +863,14 @@ export function calculateSpreadReserves(
 		);
 
 		let quoteAssetReserve;
-		if (
-			(spread >= 0 && isVariant(direction, 'long')) ||
-			(spread <= 0 && isVariant(direction, 'short'))
-		) {
-			quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
+		if (quoteAssetReserveDelta.gte(ZERO)) {
+			quoteAssetReserve = amm.quoteAssetReserve.add(
+				quoteAssetReserveDelta.abs()
+			);
 		} else {
-			quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
+			quoteAssetReserve = amm.quoteAssetReserve.sub(
+				quoteAssetReserveDelta.abs()
+			);
 		}
 
 		const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
@@ -886,26 +887,35 @@ export function calculateSpreadReserves(
 	);
 
 	// always allow 10 bps of price offset, up to a fifth of the market's max_spread
-	const maxOffset = Math.max(
-		amm.maxSpread / 5,
-		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
-	);
+	let maxOffset = 0;
+	let referencePriceOffset = ZERO;
+	if (amm.curveUpdateIntensity > 100) {
+		maxOffset = Math.max(
+			amm.maxSpread / 5,
+			(PERCENTAGE_PRECISION.toNumber() / 10000) *
+				(amm.curveUpdateIntensity - 100)
+		);
+
+		const liquidityFraction = calculateInventoryLiquidityRatio(
+			amm.baseAssetAmountWithAmm,
+			amm.baseAssetReserve,
+			amm.minBaseAssetReserve,
+			amm.maxBaseAssetReserve
+		);
+		const liquidityFractionSigned = liquidityFraction.mul(
+			sigNum(amm.baseAssetAmountWithAmm.add(amm.baseAssetAmountWithUnsettledLp))
+		);
+		referencePriceOffset = calculateReferencePriceOffset(
+			reservePrice,
+			amm.last24HAvgFundingRate,
+			liquidityFractionSigned,
+			amm.historicalOracleData.lastOraclePriceTwap5Min,
+			amm.lastMarkPriceTwap5Min,
+			amm.historicalOracleData.lastOraclePriceTwap,
+			amm.lastMarkPriceTwap,
+			maxOffset
+		);
+	}
 
 	const [longSpread, shortSpread] = calculateSpread(
 		amm,
@@ -920,7 +930,7 @@ export function calculateSpreadReserves(
 		amm
 	);
 	const bidReserves = calculateSpreadReserve(
-		shortSpread + referencePriceOffset.toNumber(),
+		-shortSpread + referencePriceOffset.toNumber(),
 		PositionDirection.SHORT,
 		amm
 	);

package/src/math/orders.ts

@@ -10,7 +10,11 @@ import {
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { getAuctionPrice, isAuctionComplete } from './auction';
+import {
+	getAuctionPrice,
+	isAuctionComplete,
+	isFallbackAvailableLiquiditySource,
+} from './auction';
 import {
 	calculateMaxBaseAssetAmountFillable,
 	calculateMaxBaseAssetAmountToTrade,
@@ -186,10 +190,11 @@ export function isFillableByVAMM(
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number,
-	ts: number
+	ts: number,
+	minAuctionDuration: number
 ): boolean {
 	return (
-		(isAuctionComplete(order, slot) &&
+		(isFallbackAvailableLiquiditySource(order, minAuctionDuration, slot) &&
 			calculateBaseAssetAmountForAmmToFulfill(
 				order,
 				market,

package/src/math/state.ts

@@ -22,5 +22,8 @@ export function calculateInitUserFee(stateAccount: StateAccount): BN {
 }
 
 export function getMaxNumberOfSubAccounts(stateAccount: StateAccount): BN {
+	if (stateAccount.maxNumberOfSubAccounts <= 5) {
+		return new BN(stateAccount.maxNumberOfSubAccounts);
+	}
 	return new BN(stateAccount.maxNumberOfSubAccounts).muln(100);
 }

package/src/phoenix/phoenixSubscriber.ts

@@ -6,7 +6,6 @@ import {
 	toNum,
 	getMarketUiLadder,
 	Market,
-	getMarketLadder,
 } from '@ellipsis-labs/phoenix-sdk';
 import { PRICE_PRECISION } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
@@ -164,18 +163,14 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 	}
 
 	*getL2Levels(side: 'bids' | 'asks'): Generator<L2Level> {
-		const tickSize = this.market.data.header
-			.tickSizeInQuoteAtomsPerBaseUnit as BN;
-		const baseLotsToRawBaseUnits = this.market.baseLotsToRawBaseUnits(1);
-
-		const basePrecision = new BN(
-			Math.pow(10, this.market.data.header.baseParams.decimals) *
-				baseLotsToRawBaseUnits
+		const basePrecision = Math.pow(
+			10,
+			this.market.data.header.baseParams.decimals
 		);
 
-		const pricePrecision = PRICE_PRECISION.div(tickSize as BN);
+		const pricePrecision = PRICE_PRECISION.toNumber();
 
-		const ladder = getMarketLadder(
+		const ladder = getMarketUiLadder(
 			this.market,
 			this.lastSlot,
 			this.lastUnixTimestamp,
@@ -183,18 +178,22 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 		);
 
 		for (let i = 0; i < ladder[side].length; i++) {
-			const { priceInTicks, sizeInBaseLots } = ladder[side][i];
-			const size = sizeInBaseLots.mul(basePrecision);
-			yield {
-				price: priceInTicks.mul(new BN(pricePrecision)),
-				size,
-				sources: {
-					phoenix: size,
-				},
-			};
+			const { price, quantity } = ladder[side][i];
+			try {
+				const size = new BN(quantity * basePrecision);
+				const updatedPrice = new BN(price * pricePrecision);
+				yield {
+					price: updatedPrice,
+					size,
+					sources: {
+						phoenix: size,
+					},
+				};
+			} catch {
+				continue;
+			}
 		}
 	}
-
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscribed) {
 			return;

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -46,18 +46,18 @@ export class PriorityFeeSubscriber {
 	}
 
 	public get avgPriorityFee(): number {
-		return this.lastAvgStrategyResult;
+		return Math.floor(this.lastAvgStrategyResult);
 	}
 
 	public get maxPriorityFee(): number {
-		return this.lastMaxStrategyResult;
+		return Math.floor(this.lastMaxStrategyResult);
 	}
 
 	public get customPriorityFee(): number {
 		if (!this.customStrategy) {
 			console.error('Custom strategy not set');
 		}
-		return this.lastCustomStrategyResult;
+		return Math.floor(this.lastCustomStrategyResult);
 	}
 
 	public async subscribe(): Promise<void> {

package/tests/amm/test.ts

@@ -8,6 +8,7 @@ import {
 	calculateSpread,
 	calculateSpreadBN,
 	ZERO,
+	sigNum,
 	ONE,
 	calculateLiveOracleStd,
 	calculateLiveOracleTwap,
@@ -465,7 +466,7 @@ describe('AMM Tests', () => {
 
 		mockAmm.baseAssetAmountWithAmm = new BN(0);
 		mockAmm.pegMultiplier = new BN(13.553 * PEG_PRECISION.toNumber());
-		mockAmm.ammJitIntensity = 100;
+		mockAmm.ammJitIntensity = 200;
 		mockAmm.curveUpdateIntensity = 200;
 		mockAmm.baseSpread = 2500;
 		mockAmm.maxSpread = 25000;
@@ -521,13 +522,13 @@ describe('AMM Tests', () => {
 		console.log('amm.baseAssetReserve:', mockAmm.baseAssetReserve.toString());
 		assert(mockAmm.baseAssetReserve.eq(new BN('1000000000')));
 		const reserves2 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
-		console.log(reserves2[1].baseAssetReserve.toString());
-		console.log(reserves2[1].quoteAssetReserve.toString());
+		console.log(reserves2[0].baseAssetReserve.toString());
+		console.log(reserves2[0].quoteAssetReserve.toString());
 
-		assert(reserves2[0].baseAssetReserve.eq(new BN('1006711408')));
-		assert(reserves2[0].quoteAssetReserve.eq(new BN('993333334')));
-		assert(reserves2[1].baseAssetReserve.eq(new BN('993377484')));
-		assert(reserves2[1].quoteAssetReserve.eq(new BN('1006666666')));
+		assert(reserves2[0].baseAssetReserve.eq(new BN('1005050504')));
+		assert(reserves2[0].quoteAssetReserve.eq(new BN('994974875')));
+		assert(reserves2[1].baseAssetReserve.eq(new BN('992537314')));
+		assert(reserves2[1].quoteAssetReserve.eq(new BN('1007518796')));
 
 		// create imbalance for reference price offset
 		mockAmm.baseAssetReserve = new BN(1000000000 * 1.1);
@@ -536,11 +537,12 @@ describe('AMM Tests', () => {
 			mockAmm.baseAssetReserve.mul(mockAmm.quoteAssetReserve)
 		);
 
-		mockAmm.baseAssetAmountWithAmm = new BN(-1000000000 * 0.1);
+		mockAmm.baseAssetAmountWithAmm = new BN(1000000000 * 0.1);
 
 		const maxOffset = Math.max(
 			mockAmm.maxSpread / 5,
-			PERCENTAGE_PRECISION.toNumber() / 1000
+			(PERCENTAGE_PRECISION.toNumber() / 10000) *
+				(mockAmm.curveUpdateIntensity - 100)
 		);
 		const liquidityFraction = calculateInventoryLiquidityRatio(
 			mockAmm.baseAssetAmountWithAmm,
@@ -550,11 +552,17 @@ describe('AMM Tests', () => {
 		);
 		console.log('liquidityFraction:', liquidityFraction.toString());
 		assert(liquidityFraction.eq(new BN(1000000))); // full
-
+		const liquidityFractionSigned = liquidityFraction.mul(
+			sigNum(
+				mockAmm.baseAssetAmountWithAmm.add(
+					mockAmm.baseAssetAmountWithUnsettledLp
+				)
+			)
+		);
 		const referencePriceOffset = calculateReferencePriceOffset(
 			reservePrice,
 			mockAmm.last24HAvgFundingRate,
-			liquidityFraction,
+			liquidityFractionSigned,
 			mockAmm.historicalOracleData.lastOraclePriceTwap5Min,
 			mockAmm.lastMarkPriceTwap5Min,
 			mockAmm.historicalOracleData.lastOraclePriceTwap,
@@ -562,17 +570,304 @@ describe('AMM Tests', () => {
 			maxOffset
 		);
 		console.log('referencePriceOffset:', referencePriceOffset.toString());
-		assert(referencePriceOffset.eq(new BN(5000)));
+		assert(referencePriceOffset.eq(new BN(10000)));
 		assert(referencePriceOffset.eq(new BN(maxOffset)));
 
+		// mockAmm.curveUpdateIntensity = 100;
+		const reserves3 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves3[0].baseAssetReserve.toString());
+		console.log(reserves3[0].quoteAssetReserve.toString());
+
+		assert(reserves3[0].baseAssetReserve.eq(new BN('1094581278')));
+		assert(reserves3[0].quoteAssetReserve.eq(new BN('913591359')));
+		assert(reserves3[1].baseAssetReserve.eq(new BN('989999998')));
+		assert(reserves3[1].quoteAssetReserve.eq(new BN('1010101010')));
+
+		const p1 = calculatePrice(
+			reserves3[0].baseAssetReserve,
+			reserves3[0].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+
+		const p2 = calculatePrice(
+			reserves3[1].baseAssetReserve,
+			reserves3[1].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+		console.log(p1.toString(), p2.toString());
+
+		assert(p1.eq(new BN(11312000)));
+		assert(p2.eq(new BN(13828180)));
+
+		mockAmm.curveUpdateIntensity = 110;
+		const reserves4 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves4[1].baseAssetReserve.toString());
+		console.log(reserves4[1].quoteAssetReserve.toString());
+
+		assert(reserves4[0].baseAssetReserve.eq(new BN('1097323599')));
+		assert(reserves4[0].quoteAssetReserve.eq(new BN('911308203')));
+		assert(reserves4[1].baseAssetReserve.eq(new BN('989999998')));
+		assert(reserves4[1].quoteAssetReserve.eq(new BN('1010101010')));
+
+		const p1RF = calculatePrice(
+			reserves4[0].baseAssetReserve,
+			reserves4[0].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+
+		const p2RF = calculatePrice(
+			reserves4[1].baseAssetReserve,
+			reserves4[1].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+		console.log(p1RF.toString(), p2RF.toString());
+
+		assert(p1RF.eq(new BN(11255531)));
+		assert(p2RF.eq(new BN(13828180)));
+		// no ref price offset at 100
+		mockAmm.curveUpdateIntensity = 100;
+		const reserves5 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves5[0].baseAssetReserve.toString());
+		console.log(reserves5[0].quoteAssetReserve.toString());
+
+		assert(reserves5[0].baseAssetReserve.eq(new BN('1100068201')));
+		assert(reserves5[0].quoteAssetReserve.eq(new BN('909034546')));
+		assert(reserves5[1].baseAssetReserve.eq(new BN('989999998')));
+		assert(reserves5[1].quoteAssetReserve.eq(new BN('1010101010')));
+
+		const p1RFNone = calculatePrice(
+			reserves5[0].baseAssetReserve,
+			reserves5[0].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+
+		const p2RFNone = calculatePrice(
+			reserves5[1].baseAssetReserve,
+			reserves5[1].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+		console.log(p1RFNone.toString(), p2RFNone.toString());
+
+		assert(p1RFNone.eq(new BN(11199437)));
+		assert(p2RFNone.eq(new BN(13828180)));
+		assert(p1RF.sub(p1RFNone).eq(new BN(56094)));
+		assert(p2RF.sub(p2RFNone).eq(new BN(0))); // todo?
+	});
+	it('Spread Reserves (with negative offset)', () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+		const mockAmm = mockMarket1.amm;
+		const now = new BN(new Date().getTime() / 1000); //todo
+
+		const oraclePriceData = {
+			price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+			slot: new BN(68 + 1),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+
+		const reserves = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		assert(reserves[0].baseAssetReserve.eq(new BN('1000000000')));
+		assert(reserves[0].quoteAssetReserve.eq(new BN('12000000000')));
+		assert(reserves[1].baseAssetReserve.eq(new BN('1000000000')));
+		assert(reserves[1].quoteAssetReserve.eq(new BN('12000000000')));
+
+		mockAmm.baseAssetReserve = new BN(1000000000);
+		mockAmm.quoteAssetReserve = new BN(1000000000);
+		mockAmm.sqrtK = new BN(1000000000);
+
+		mockAmm.baseAssetAmountWithAmm = new BN(0);
+		mockAmm.pegMultiplier = new BN(13.553 * PEG_PRECISION.toNumber());
+		mockAmm.ammJitIntensity = 200;
+		mockAmm.curveUpdateIntensity = 200;
+		mockAmm.baseSpread = 2500;
+		mockAmm.maxSpread = 25000;
+
+		mockAmm.last24HAvgFundingRate = new BN(-7590328523);
+
+		mockAmm.lastMarkPriceTwap = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 + 0.01) * 1e6
+		);
+		mockAmm.historicalOracleData.lastOraclePriceTwap = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 - 0.015) * 1e6
+		);
+
+		mockAmm.historicalOracleData.lastOraclePriceTwap5Min = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 + 0.005) * 1e6
+		);
+		mockAmm.lastMarkPriceTwap5Min = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 - 0.005) * 1e6
+		);
+
+		console.log('starting rr:');
+		let reservePrice = undefined;
+		if (!reservePrice) {
+			reservePrice = calculatePrice(
+				mockAmm.baseAssetReserve,
+				mockAmm.quoteAssetReserve,
+				mockAmm.pegMultiplier
+			);
+		}
+
+		const targetPrice = oraclePriceData?.price || reservePrice;
+		const confInterval = oraclePriceData.confidence || ZERO;
+		const targetMarkSpreadPct = reservePrice
+			.sub(targetPrice)
+			.mul(BID_ASK_SPREAD_PRECISION)
+			.div(reservePrice);
+
+		const confIntervalPct = confInterval
+			.mul(BID_ASK_SPREAD_PRECISION)
+			.div(reservePrice);
+
+		// now = now || new BN(new Date().getTime() / 1000); //todo
+		const liveOracleStd = calculateLiveOracleStd(mockAmm, oraclePriceData, now);
+		console.log('reservePrice:', reservePrice.toString());
+		console.log('targetMarkSpreadPct:', targetMarkSpreadPct.toString());
+		console.log('confIntervalPct:', confIntervalPct.toString());
+
+		console.log('liveOracleStd:', liveOracleStd.toString());
+
+		const tt = calculateSpread(mockAmm, oraclePriceData, now);
+		console.log(tt);
+
+		console.log('amm.baseAssetReserve:', mockAmm.baseAssetReserve.toString());
+		assert(mockAmm.baseAssetReserve.eq(new BN('1000000000')));
+		const reserves2 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves2[1].baseAssetReserve.toString());
+		console.log(reserves2[1].quoteAssetReserve.toString());
+
+		assert(reserves2[0].baseAssetReserve.eq(new BN('1006289308')));
+		assert(reserves2[0].quoteAssetReserve.eq(new BN('993750000')));
+		assert(reserves2[1].baseAssetReserve.eq(new BN('993788819')));
+		assert(reserves2[1].quoteAssetReserve.eq(new BN('1006250000')));
+
+		// create imbalance for reference price offset
+		mockAmm.baseAssetReserve = new BN(1000000000 / 1.1);
+		mockAmm.quoteAssetReserve = new BN(1000000000 * 1.1);
+		mockAmm.sqrtK = squareRootBN(
+			mockAmm.baseAssetReserve.mul(mockAmm.quoteAssetReserve)
+		);
+
+		mockAmm.baseAssetAmountWithAmm = new BN(-1000000000 * 0.1);
+
+		const maxOffset = Math.max(
+			mockAmm.maxSpread / 5,
+			(PERCENTAGE_PRECISION.toNumber() / 10000) *
+				(mockAmm.curveUpdateIntensity - 100)
+		);
+		const liquidityFraction = calculateInventoryLiquidityRatio(
+			mockAmm.baseAssetAmountWithAmm,
+			mockAmm.baseAssetReserve,
+			mockAmm.minBaseAssetReserve,
+			mockAmm.maxBaseAssetReserve
+		);
+		console.log('liquidityFraction:', liquidityFraction.toString());
+		assert(liquidityFraction.eq(new BN(1000000))); // full
+		const liquidityFractionSigned = liquidityFraction.mul(
+			sigNum(
+				mockAmm.baseAssetAmountWithAmm.add(
+					mockAmm.baseAssetAmountWithUnsettledLp
+				)
+			)
+		);
+		const referencePriceOffset = calculateReferencePriceOffset(
+			reservePrice,
+			mockAmm.last24HAvgFundingRate,
+			liquidityFractionSigned,
+			mockAmm.historicalOracleData.lastOraclePriceTwap5Min,
+			mockAmm.lastMarkPriceTwap5Min,
+			mockAmm.historicalOracleData.lastOraclePriceTwap,
+			mockAmm.lastMarkPriceTwap,
+			maxOffset
+		);
+		console.log('referencePriceOffset:', referencePriceOffset.toString());
+		assert(referencePriceOffset.eq(new BN(-10000))); // neg
+
+		// assert(referencePriceOffset.eq(new BN(maxOffset)));
+
+		// mockAmm.curveUpdateIntensity = 100;
 		const reserves3 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
-		console.log(reserves3[1].baseAssetReserve.toString());
-		console.log(reserves3[1].quoteAssetReserve.toString());
+		console.log(reserves3[0].baseAssetReserve.toString());
+		console.log(reserves3[0].quoteAssetReserve.toString());
+
+		assert(reserves3[0].baseAssetReserve.eq(new BN('1010101008')));
+		assert(reserves3[0].quoteAssetReserve.eq(new BN('990000000')));
+		assert(reserves3[1].baseAssetReserve.eq(new BN('913613747')));
+		assert(reserves3[1].quoteAssetReserve.eq(new BN('1094554456')));
+
+		const p1 = calculatePrice(
+			reserves3[0].baseAssetReserve,
+			reserves3[0].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+
+		const p2 = calculatePrice(
+			reserves3[1].baseAssetReserve,
+			reserves3[1].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+		console.log(p1.toString(), p2.toString());
+
+		assert(p1.eq(new BN(13283295)));
+		assert(p2.eq(new BN(16237164)));
+
+		mockAmm.curveUpdateIntensity = 110;
+		const reserves4 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves4[1].baseAssetReserve.toString());
+		console.log(reserves4[1].quoteAssetReserve.toString());
+
+		assert(reserves4[0].baseAssetReserve.eq(new BN('999999998')));
+		assert(reserves4[0].quoteAssetReserve.eq(new BN('1000000000')));
+		assert(reserves4[1].baseAssetReserve.eq(new BN('911313622')));
+		assert(reserves4[1].quoteAssetReserve.eq(new BN('1097317074')));
+
+		const p1RF = calculatePrice(
+			reserves4[0].baseAssetReserve,
+			reserves4[0].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+
+		const p2RF = calculatePrice(
+			reserves4[1].baseAssetReserve,
+			reserves4[1].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+		console.log(p1RF.toString(), p2RF.toString());
+
+		assert(p1RF.eq(new BN(13553000)));
+		assert(p2RF.eq(new BN(16319231)));
+
+		// no ref price offset at 100
+		mockAmm.curveUpdateIntensity = 100;
+		const reserves5 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves5[0].baseAssetReserve.toString());
+		console.log(reserves5[0].quoteAssetReserve.toString());
+
+		assert(reserves5[0].baseAssetReserve.eq(new BN('999999998')));
+		assert(reserves5[0].quoteAssetReserve.eq(new BN('1000000000')));
+		assert(reserves5[1].baseAssetReserve.eq(new BN('909034547')));
+		assert(reserves5[1].quoteAssetReserve.eq(new BN('1100068200')));
+
+		const p1RFNone = calculatePrice(
+			reserves5[0].baseAssetReserve,
+			reserves5[0].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+
+		const p2RFNone = calculatePrice(
+			reserves5[1].baseAssetReserve,
+			reserves5[1].quoteAssetReserve,
+			mockAmm.pegMultiplier
+		);
+		console.log(p1RFNone.toString(), p2RFNone.toString());
 
-		assert(reserves3[0].baseAssetReserve.eq(new BN('1164705879')));
-		assert(reserves3[0].quoteAssetReserve.eq(new BN('858585859')));
-		assert(reserves3[1].baseAssetReserve.eq(new BN('1042105261')));
-		assert(reserves3[1].quoteAssetReserve.eq(new BN('959595959')));
+		const rr = p2RF.sub(p2RFNone).mul(PERCENTAGE_PRECISION).div(p2RF);
+		console.log(rr.toNumber());
+		assert(p1RFNone.eq(new BN(13553000)));
+		assert(p2RFNone.eq(new BN(16401163)));
+		assert(p1RF.sub(p1RFNone).eq(new BN(0))); // todo?
+		assert(rr.eq(new BN(-5020)));
 	});
 
 	it('live update functions', () => {