@drift-labs/sdk 2.18.0-beta.0 → 2.18.0-beta.2

package/lib/constants/perpMarkets.js

@@ -44,6 +44,16 @@ exports.DevnetPerpMarkets = [
         launchTs: 1675610186000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'Bonk',
+        category: ['Meme'],
+        symbol: 'BONK-PERP',
+        baseAssetSymbol: 'BONK',
+        marketIndex: 4,
+        oracle: new web3_js_1.PublicKey('6bquU99ktV1VRiHDr8gMhDFt3kMfhCQo5nfNrg2Urvsn'),
+        launchTs: 1677068931000,
+        oracleSource: __1.OracleSource.PYTH_1000,
+    },
 ];
 exports.MainnetPerpMarkets = [
     {

package/lib/dlob/DLOB.d.ts

@@ -88,11 +88,11 @@ export declare class DLOB {
     getMakerLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackAsk?: BN): Generator<DLOBNode>;
     getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getBids(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
-    findCrossingRestingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
+    findCrossingRestingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
     determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
         takerNode: DLOBNode;
         makerNode: DLOBNode;
-    };
+    } | undefined;
     getBestAsk(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
     getBestBid(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
     findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType, stateAccount: StateAccount): NodeToTrigger[];

package/lib/dlob/DLOB.js

@@ -310,7 +310,7 @@ class DLOB {
     }
     findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        const crossingNodes = this.findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData, minAuctionDuration, fallbackAsk, fallbackBid);
+        const crossingNodes = this.findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
         for (const crossingNode of crossingNodes) {
             nodesToFill.push(crossingNode);
         }
@@ -711,40 +711,30 @@ class DLOB {
                 .gt(currentNode.getPrice(oraclePriceData, slot));
         });
     }
-    findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData, minAuctionDuration, fallbackAsk, fallbackBid) {
+    findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData) {
         const nodesToFill = new Array();
         for (const askNode of this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
-            for (const bidNode of this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
+            const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
+            for (const bidNode of bidGenerator) {
                 const bidPrice = bidNode.getPrice(oraclePriceData, slot);
                 const askPrice = askNode.getPrice(oraclePriceData, slot);
-                // orders don't cross - we're done walking the book
+                // orders don't cross
                 if (bidPrice.lt(askPrice)) {
-                    return nodesToFill;
+                    break;
                 }
                 const bidOrder = bidNode.order;
                 const askOrder = askNode.order;
                 // Can't match orders from the same user
                 const sameUser = bidNode.userAccount.equals(askNode.userAccount);
-                if (sameUser || (bidOrder.postOnly && askOrder.postOnly)) {
+                if (sameUser) {
                     continue;
                 }
-                const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
-                // extra guard against bad fills for limit orders where auction is incomplete
-                if (!__1.isFallbackAvailableLiquiditySource(takerNode.order, minAuctionDuration, slot)) {
-                    let bidPrice;
-                    let askPrice;
-                    if (__1.isVariant(takerNode.order.direction, 'long')) {
-                        bidPrice = __1.BN.min(takerNode.getPrice(oraclePriceData, slot), fallbackAsk || __1.BN_MAX);
-                        askPrice = makerNode.getPrice(oraclePriceData, slot);
-                    }
-                    else {
-                        bidPrice = makerNode.getPrice(oraclePriceData, slot);
-                        askPrice = __1.BN.max(takerNode.getPrice(oraclePriceData, slot), fallbackBid || __1.ZERO);
-                    }
-                    if (bidPrice.lt(askPrice)) {
-                        continue;
-                    }
+                const makerAndTaker = this.determineMakerAndTaker(askNode, bidNode);
+                // unable to match maker and taker due to post only or slot
+                if (!makerAndTaker) {
+                    continue;
                 }
+                const { takerNode, makerNode } = makerAndTaker;
                 const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
                 const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
                 const baseFilled = __1.BN.min(bidBaseRemaining, askBaseRemaining);
@@ -769,30 +759,23 @@ class DLOB {
         return nodesToFill;
     }
     determineMakerAndTaker(askNode, bidNode) {
-        if (bidNode.order.postOnly) {
-            return {
-                takerNode: askNode,
-                makerNode: bidNode,
-            };
-        }
-        else if (askNode.order.postOnly) {
-            return {
-                takerNode: bidNode,
-                makerNode: askNode,
-            };
-        }
-        else if (askNode.order.slot.lt(bidNode.order.slot)) {
+        const askSlot = askNode.order.slot.add(new __1.BN(askNode.order.auctionDuration));
+        const bidSlot = bidNode.order.slot.add(new __1.BN(bidNode.order.auctionDuration));
+        if (askSlot.lte(bidSlot) && !bidNode.order.postOnly) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
             };
         }
-        else {
+        else if (bidSlot.lte(askSlot) && !askNode.order.postOnly) {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
             };
         }
+        else {
+            return undefined;
+        }
     }
     getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
         return this.getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData)

package/lib/driftClient.js

@@ -2094,7 +2094,7 @@ class DriftClient {
             writablePerpMarketIndexes: [marketIndex],
             writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const spotMarket = this.getQuoteSpotMarketAccount();
         return await this.program.instruction.resolvePerpBankruptcy(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),

package/lib/factory/oracleClient.js

@@ -5,10 +5,14 @@ const types_1 = require("../types");
 const pythClient_1 = require("../oracles/pythClient");
 // import { SwitchboardClient } from '../oracles/switchboardClient';
 const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+const anchor_1 = require("@project-serum/anchor");
 function getOracleClient(oracleSource, connection) {
     if (types_1.isVariant(oracleSource, 'pyth')) {
         return new pythClient_1.PythClient(connection);
     }
+    if (types_1.isVariant(oracleSource, 'pyth1000')) {
+        return new pythClient_1.PythClient(connection, new anchor_1.BN(1000));
+    }
     // if (isVariant(oracleSource, 'switchboard')) {
     // 	return new SwitchboardClient(connection);
     // }

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.18.0-beta.0",
+    "version": "2.18.0-beta.2",
     "name": "drift",
     "instructions": [
         {
@@ -6237,6 +6237,9 @@
                     {
                         "name": "Pyth"
                     },
+                    {
+                        "name": "Pyth1000"
+                    },
                     {
                         "name": "Switchboard"
                     },

package/lib/math/trade.d.ts

@@ -9,6 +9,9 @@ import { Orderbook } from '@project-serum/serum';
 export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
+ *
+ * @deprecated use calculateEstimatedPerpEntryPrice instead
+ *
  * @param direction
  * @param amount
  * @param market
@@ -40,6 +43,9 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
+ *
+ * @deprecated
+ *
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.

package/lib/math/trade.js

@@ -12,6 +12,9 @@ const types_2 = require("../types");
 const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
+ *
+ * @deprecated use calculateEstimatedPerpEntryPrice instead
+ *
  * @param direction
  * @param amount
  * @param market
@@ -120,6 +123,9 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
+ *
+ * @deprecated
+ *
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.

package/lib/oracles/pythClient.d.ts

@@ -1,12 +1,13 @@
-/// <reference types="node" />
 /// <reference types="bn.js" />
+/// <reference types="node" />
 import { Connection, PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
 export declare class PythClient implements OracleClient {
     private connection;
-    constructor(connection: Connection);
+    private multiple;
+    constructor(connection: Connection, multiple?: BN);
     getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
     getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
 }
-export declare function convertPythPrice(price: number, exponent: number): BN;
+export declare function convertPythPrice(price: number, exponent: number, multiple: BN): BN;

package/lib/oracles/pythClient.js

@@ -5,8 +5,9 @@ const client_1 = require("@pythnetwork/client");
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 class PythClient {
-    constructor(connection) {
+    constructor(connection, multiple = numericConstants_1.ONE) {
         this.connection = connection;
+        this.multiple = multiple;
     }
     async getOraclePriceData(pricePublicKey) {
         const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
@@ -15,19 +16,19 @@ class PythClient {
     getOraclePriceDataFromBuffer(buffer) {
         const priceData = client_1.parsePriceData(buffer);
         return {
-            price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
+            price: convertPythPrice(priceData.aggregate.price, priceData.exponent, this.multiple),
             slot: new anchor_1.BN(priceData.lastSlot.toString()),
-            confidence: convertPythPrice(priceData.confidence, priceData.exponent),
-            twap: convertPythPrice(priceData.twap.value, priceData.exponent),
-            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+            confidence: convertPythPrice(priceData.confidence, priceData.exponent, this.multiple),
+            twap: convertPythPrice(priceData.twap.value, priceData.exponent, this.multiple),
+            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent, this.multiple),
             hasSufficientNumberOfDataPoints: true,
         };
     }
 }
 exports.PythClient = PythClient;
-function convertPythPrice(price, exponent) {
+function convertPythPrice(price, exponent, multiple) {
     exponent = Math.abs(exponent);
-    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs());
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs()).div(multiple);
     return new anchor_1.BN(price * Math.pow(10, exponent))
         .mul(numericConstants_1.PRICE_PRECISION)
         .div(pythPrecision);

package/lib/types.d.ts

@@ -130,6 +130,9 @@ export declare class OracleSource {
     static readonly PYTH: {
         pyth: {};
     };
+    static readonly PYTH_1000: {
+        pyth1000: {};
+    };
     static readonly QUOTE_ASSET: {
         quoteAsset: {};
     };

package/lib/types.js

@@ -78,6 +78,7 @@ class OracleSource {
 }
 exports.OracleSource = OracleSource;
 OracleSource.PYTH = { pyth: {} };
+OracleSource.PYTH_1000 = { pyth1000: {} };
 // static readonly SWITCHBOARD = { switchboard: {} };
 OracleSource.QUOTE_ASSET = { quoteAsset: {} };
 class OrderType {

package/lib/user.js

@@ -400,11 +400,13 @@ class User {
             }
             totalLiabilityValue = totalLiabilityValue.add(new _1.BN(spotPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
         }
-        if (netQuoteValue.gt(numericConstants_1.ZERO)) {
-            totalAssetValue = totalAssetValue.add(netQuoteValue);
-        }
-        else {
-            totalLiabilityValue = totalLiabilityValue.add(netQuoteValue.abs());
+        if (marketIndex === undefined || marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+            if (netQuoteValue.gt(numericConstants_1.ZERO)) {
+                totalAssetValue = totalAssetValue.add(netQuoteValue);
+            }
+            else {
+                totalLiabilityValue = totalLiabilityValue.add(netQuoteValue.abs());
+            }
         }
         return { totalAssetValue, totalLiabilityValue };
     }

package/package.json

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

package/src/constants/perpMarkets.ts

@@ -54,6 +54,16 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1675610186000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'Bonk',
+		category: ['Meme'],
+		symbol: 'BONK-PERP',
+		baseAssetSymbol: 'BONK',
+		marketIndex: 4,
+		oracle: new PublicKey('6bquU99ktV1VRiHDr8gMhDFt3kMfhCQo5nfNrg2Urvsn'),
+		launchTs: 1677068931000,
+		oracleSource: OracleSource.PYTH_1000,
+	},
 ];
 
 export const MainnetPerpMarkets: PerpMarketConfig[] = [

package/src/dlob/DLOB.ts

@@ -6,7 +6,6 @@ import {
 	calculateBidPrice,
 	DriftClient,
 	convertToNumber,
-	isAuctionComplete,
 	isOrderExpired,
 	isOneOfVariant,
 	isVariant,
@@ -25,8 +24,6 @@ import {
 	UserMap,
 	OrderRecord,
 	OrderActionRecord,
-	ZERO,
-	BN_MAX,
 	isRestingLimitOrder,
 	isTakingOrder,
 	isFallbackAvailableLiquiditySource,
@@ -536,10 +533,7 @@ export class DLOB {
 			marketIndex,
 			slot,
 			marketType,
-			oraclePriceData,
-			minAuctionDuration,
-			fallbackAsk,
-			fallbackBid
+			oraclePriceData
 		);
 
 		for (const crossingNode of crossingNodes) {
@@ -1295,10 +1289,7 @@ export class DLOB {
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
-		oraclePriceData: OraclePriceData,
-		minAuctionDuration: number,
-		fallbackAsk: BN | undefined,
-		fallbackBid: BN | undefined
+		oraclePriceData: OraclePriceData
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -1308,18 +1299,20 @@ export class DLOB {
 			marketType,
 			oraclePriceData
 		)) {
-			for (const bidNode of this.getRestingLimitBids(
+			const bidGenerator = this.getRestingLimitBids(
 				marketIndex,
 				slot,
 				marketType,
 				oraclePriceData
-			)) {
+			);
+
+			for (const bidNode of bidGenerator) {
 				const bidPrice = bidNode.getPrice(oraclePriceData, slot);
 				const askPrice = askNode.getPrice(oraclePriceData, slot);
 
-				// orders don't cross - we're done walking the book
+				// orders don't cross
 				if (bidPrice.lt(askPrice)) {
-					return nodesToFill;
+					break;
 				}
 
 				const bidOrder = bidNode.order;
@@ -1327,44 +1320,19 @@ export class DLOB {
 
 				// Can't match orders from the same user
 				const sameUser = bidNode.userAccount.equals(askNode.userAccount);
-				if (sameUser || (bidOrder.postOnly && askOrder.postOnly)) {
+				if (sameUser) {
 					continue;
 				}
 
-				const { takerNode, makerNode } = this.determineMakerAndTaker(
-					askNode,
-					bidNode
-				);
+				const makerAndTaker = this.determineMakerAndTaker(askNode, bidNode);
 
-				// extra guard against bad fills for limit orders where auction is incomplete
-				if (
-					!isFallbackAvailableLiquiditySource(
-						takerNode.order,
-						minAuctionDuration,
-						slot
-					)
-				) {
-					let bidPrice: BN;
-					let askPrice: BN;
-					if (isVariant(takerNode.order.direction, 'long')) {
-						bidPrice = BN.min(
-							takerNode.getPrice(oraclePriceData, slot),
-							fallbackAsk || BN_MAX
-						);
-						askPrice = makerNode.getPrice(oraclePriceData, slot);
-					} else {
-						bidPrice = makerNode.getPrice(oraclePriceData, slot);
-						askPrice = BN.max(
-							takerNode.getPrice(oraclePriceData, slot),
-							fallbackBid || ZERO
-						);
-					}
-
-					if (bidPrice.lt(askPrice)) {
-						continue;
-					}
+				// unable to match maker and taker due to post only or slot
+				if (!makerAndTaker) {
+					continue;
 				}
 
+				const { takerNode, makerNode } = makerAndTaker;
+
 				const bidBaseRemaining = bidOrder.baseAssetAmount.sub(
 					bidOrder.baseAssetAmountFilled
 				);
@@ -1408,27 +1376,25 @@ export class DLOB {
 	determineMakerAndTaker(
 		askNode: DLOBNode,
 		bidNode: DLOBNode
-	): { takerNode: DLOBNode; makerNode: DLOBNode } {
-		if (bidNode.order.postOnly) {
-			return {
-				takerNode: askNode,
-				makerNode: bidNode,
-			};
-		} else if (askNode.order.postOnly) {
-			return {
-				takerNode: bidNode,
-				makerNode: askNode,
-			};
-		} else if (askNode.order.slot.lt(bidNode.order.slot)) {
+	): { takerNode: DLOBNode; makerNode: DLOBNode } | undefined {
+		const askSlot = askNode.order.slot.add(
+			new BN(askNode.order.auctionDuration)
+		);
+		const bidSlot = bidNode.order.slot.add(
+			new BN(bidNode.order.auctionDuration)
+		);
+		if (askSlot.lte(bidSlot) && !bidNode.order.postOnly) {
 			return {
 				takerNode: bidNode,
 				makerNode: askNode,
 			};
-		} else {
+		} else if (bidSlot.lte(askSlot) && !askNode.order.postOnly) {
 			return {
 				takerNode: askNode,
 				makerNode: bidNode,
 			};
+		} else {
+			return undefined;
 		}
 	}
 

package/src/driftClient.ts

@@ -3695,7 +3695,7 @@ export class DriftClient {
 			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getQuoteSpotMarketAccount();
 
 		return await this.program.instruction.resolvePerpBankruptcy(
 			QUOTE_SPOT_MARKET_INDEX,

package/src/factory/oracleClient.ts

@@ -4,6 +4,7 @@ import { OracleClient } from '../oracles/types';
 import { PythClient } from '../oracles/pythClient';
 // import { SwitchboardClient } from '../oracles/switchboardClient';
 import { QuoteAssetOracleClient } from '../oracles/quoteAssetOracleClient';
+import { BN } from '@project-serum/anchor';
 
 export function getOracleClient(
 	oracleSource: OracleSource,
@@ -13,6 +14,10 @@ export function getOracleClient(
 		return new PythClient(connection);
 	}
 
+	if (isVariant(oracleSource, 'pyth1000')) {
+		return new PythClient(connection, new BN(1000));
+	}
+
 	// if (isVariant(oracleSource, 'switchboard')) {
 	// 	return new SwitchboardClient(connection);
 	// }

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.18.0-beta.0",
+  "version": "2.18.0-beta.2",
   "name": "drift",
   "instructions": [
     {
@@ -6237,6 +6237,9 @@
           {
             "name": "Pyth"
           },
+          {
+            "name": "Pyth1000"
+          },
           {
             "name": "Switchboard"
           },

package/src/math/trade.ts

@@ -52,6 +52,9 @@ export type PriceImpactUnit =
 
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
+ *
+ * @deprecated use calculateEstimatedPerpEntryPrice instead
+ *
  * @param direction
  * @param amount
  * @param market
@@ -200,6 +203,9 @@ export function calculateTradeAcquiredAmounts(
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
+ *
+ * @deprecated
+ *
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.

package/src/oracles/pythClient.ts

@@ -2,13 +2,15 @@ import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { ONE, PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
 export class PythClient implements OracleClient {
 	private connection: Connection;
+	private multiple: BN;
 
-	public constructor(connection: Connection) {
+	public constructor(connection: Connection, multiple = ONE) {
 		this.connection = connection;
+		this.multiple = multiple;
 	}
 
 	public async getOraclePriceData(
@@ -21,22 +23,39 @@ export class PythClient implements OracleClient {
 	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
 		const priceData = parsePriceData(buffer);
 		return {
-			price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
+			price: convertPythPrice(
+				priceData.aggregate.price,
+				priceData.exponent,
+				this.multiple
+			),
 			slot: new BN(priceData.lastSlot.toString()),
-			confidence: convertPythPrice(priceData.confidence, priceData.exponent),
-			twap: convertPythPrice(priceData.twap.value, priceData.exponent),
+			confidence: convertPythPrice(
+				priceData.confidence,
+				priceData.exponent,
+				this.multiple
+			),
+			twap: convertPythPrice(
+				priceData.twap.value,
+				priceData.exponent,
+				this.multiple
+			),
 			twapConfidence: convertPythPrice(
 				priceData.twac.value,
-				priceData.exponent
+				priceData.exponent,
+				this.multiple
 			),
 			hasSufficientNumberOfDataPoints: true,
 		};
 	}
 }
 
-export function convertPythPrice(price: number, exponent: number): BN {
+export function convertPythPrice(
+	price: number,
+	exponent: number,
+	multiple: BN
+): BN {
 	exponent = Math.abs(exponent);
-	const pythPrecision = TEN.pow(new BN(exponent).abs());
+	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
 	return new BN(price * Math.pow(10, exponent))
 		.mul(PRICE_PRECISION)
 		.div(pythPrecision);

package/src/types.ts

@@ -76,6 +76,7 @@ export class DepositDirection {
 
 export class OracleSource {
 	static readonly PYTH = { pyth: {} };
+	static readonly PYTH_1000 = { pyth1000: {} };
 	// static readonly SWITCHBOARD = { switchboard: {} };
 	static readonly QUOTE_ASSET = { quoteAsset: {} };
 }

package/src/user.ts

@@ -697,10 +697,12 @@ export class User {
 			);
 		}
 
-		if (netQuoteValue.gt(ZERO)) {
-			totalAssetValue = totalAssetValue.add(netQuoteValue);
-		} else {
-			totalLiabilityValue = totalLiabilityValue.add(netQuoteValue.abs());
+		if (marketIndex === undefined || marketIndex === QUOTE_SPOT_MARKET_INDEX) {
+			if (netQuoteValue.gt(ZERO)) {
+				totalAssetValue = totalAssetValue.add(netQuoteValue);
+			} else {
+				totalLiabilityValue = totalLiabilityValue.add(netQuoteValue.abs());
+			}
 		}
 
 		return { totalAssetValue, totalLiabilityValue };

package/tests/dlob/test.ts

@@ -3435,7 +3435,7 @@ describe('DLOB Perp Tests', () => {
 			PositionDirection.LONG,
 			vBid,
 			vAsk,
-			new BN(slot - 1), // later order becomes taker
+			new BN(slot + 1), // later order becomes taker
 			new BN(200),
 			undefined,
 			undefined,
@@ -5109,7 +5109,8 @@ describe('DLOB Spot Tests', () => {
 			BASE_PRECISION, // quantity
 			PositionDirection.SHORT,
 			vBid,
-			vAsk
+			vAsk,
+			new BN(1)
 		);
 		insertOrderToDLOB(
 			dlob,
@@ -5122,7 +5123,8 @@ describe('DLOB Spot Tests', () => {
 			BASE_PRECISION, // quantity
 			PositionDirection.SHORT,
 			vBid,
-			vAsk
+			vAsk,
+			new BN(1)
 		);
 
 		// should have no crossing orders
@@ -5152,7 +5154,7 @@ describe('DLOB Spot Tests', () => {
 			PositionDirection.LONG,
 			vBid,
 			vAsk,
-			undefined,
+			new BN(0),
 			undefined,
 			undefined,
 			true
@@ -5169,7 +5171,7 @@ describe('DLOB Spot Tests', () => {
 			PositionDirection.LONG,
 			vBid,
 			vAsk,
-			undefined,
+			new BN(0),
 			undefined,
 			undefined,
 			true
@@ -5205,6 +5207,186 @@ describe('DLOB Spot Tests', () => {
 		expect(nodesToFillAfter[1].makerNode?.order?.orderId).to.equal(3);
 	});
 
+	it('Test limit orders skipping more recent post onlys', () => {
+		const vAsk = new BN(15);
+		const vBid = new BN(8);
+
+		const user0 = Keypair.generate();
+		const user1 = Keypair.generate();
+
+		const dlob = new DLOB();
+		const marketIndex = 0;
+
+		const slot = 12;
+		const oracle = {
+			price: vBid.add(vAsk).div(new BN(2)),
+			slot: new BN(slot),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+
+		// insert some limit sells below vAMM ask, above bid
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			1, // orderId
+			marketIndex,
+			new BN(14), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk,
+			new BN(1)
+		);
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			2, // orderId
+			marketIndex,
+			new BN(13), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk,
+			new BN(1)
+		);
+
+		// should have no crossing orders
+		const nodesToFillBefore = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			12, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle,
+			mockStateAccount,
+			mockPerpMarkets[marketIndex]
+		);
+		expect(nodesToFillBefore.length).to.equal(0);
+
+		// add post only orders that are newer than resting limit orders and thus cant match
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			3, // orderId
+			marketIndex,
+			new BN(15), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk,
+			new BN(2),
+			undefined,
+			undefined,
+			true
+		);
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			4, // orderId
+			marketIndex,
+			new BN(14), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk,
+			new BN(2),
+			undefined,
+			undefined,
+			true
+		);
+
+		let nodesToFillAfter = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			slot, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle,
+			mockStateAccount,
+			mockPerpMarkets[marketIndex]
+		);
+
+		expect(nodesToFillAfter.length).to.equal(0);
+
+		// add post only orders that are older than resting limit orders
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			5, // orderId
+			marketIndex,
+			new BN(15), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk,
+			new BN(0),
+			undefined,
+			undefined,
+			true
+		);
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			6, // orderId
+			marketIndex,
+			new BN(14), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk,
+			new BN(0),
+			undefined,
+			undefined,
+			true
+		);
+
+		nodesToFillAfter = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			slot, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle,
+			mockStateAccount,
+			mockPerpMarkets[marketIndex]
+		);
+
+		expect(nodesToFillAfter.length).to.equal(2);
+
+		printBookState(dlob, marketIndex, vBid, vAsk, slot, oracle);
+
+		for (const n of nodesToFillAfter) {
+			console.log(
+				`cross found: taker orderId: ${n.node.order?.orderId.toString()}: BAA: ${n.node.order?.baseAssetAmountFilled.toString()}/${n.node.order?.baseAssetAmount.toString()}, maker orderId: ${n.makerNode?.order?.orderId.toString()}: BAA: ${n.makerNode?.order?.baseAssetAmountFilled.toString()}/${n.makerNode?.order?.baseAssetAmount.toString()}`
+			);
+		}
+		expect(nodesToFillAfter.length).to.equal(2);
+
+		// taker should fill completely with best maker
+		expect(nodesToFillAfter[0].node.order?.orderId).to.equal(2);
+		expect(nodesToFillAfter[0].makerNode?.order?.orderId).to.equal(6);
+
+		// taker should fill completely with second best maker
+		expect(nodesToFillAfter[1].node.order?.orderId).to.equal(1);
+		expect(nodesToFillAfter[1].makerNode?.order?.orderId).to.equal(5);
+	});
+
 	it('Test trigger orders', () => {
 		const vAsk = new BN(15);
 		const vBid = new BN(8);