@velocity-exchange/sdk 0.2.5 → 0.4.0

package/tests/oracles/mmOracleGate.test.ts

@@ -0,0 +1,379 @@
+import * as _ from 'lodash';
+import {
+	BN,
+	OracleGuardRails,
+	OracleValidity,
+	PRICE_PRECISION,
+	getOracleValidity,
+	isOracleTooDivergent,
+	isFallbackAvailableLiquiditySource,
+	MMOraclePriceData,
+	StateAccount,
+	VelocityClient,
+} from '../../src';
+import { mockPerpMarkets } from '../dlob/helpers';
+import { mockOrder } from '../user/helpers';
+import { assert } from '../../src/assert/assert';
+
+// Pins the UseMMOraclePrice gating semantics from
+// `programs/velocity/src/state/perp_market.rs::get_mm_oracle_price_data`: the
+// fallback to the exchange oracle is driven by `is_oracle_valid_for_action`
+// (NonPositive/TooVolatile only), never by the twap-5min divergence band that
+// `isOracleTooDivergent` mirrors elsewhere (`validate_fill_price_within_price_bands`).
+describe('MM oracle validity gate (UseMMOraclePrice semantics)', () => {
+	it('does not fall back to the exchange oracle solely because mm price diverged from a stale 5min twap', () => {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		market.marketStats.historicalOracleData.lastOraclePriceTwap = new BN(
+			100
+		).mul(PRICE_PRECISION);
+		market.marketStats.historicalOracleData.lastOraclePriceTwap5Min = new BN(
+			100
+		).mul(PRICE_PRECISION);
+
+		// Market has moved a long way from the stale 5min twap, but the mm
+		// oracle and the current exchange oracle agree closely with each other.
+		const exchangeOraclePrice = new BN(160).mul(PRICE_PRECISION);
+		const mmOraclePrice = new BN(161).mul(PRICE_PRECISION);
+		const mmOracleSlot = new BN(1000);
+		const mmOracleConfidence = new BN(1000);
+
+		const oracleGuardRails: OracleGuardRails = {
+			priceDivergence: {
+				markOraclePercentDivergence: new BN(0),
+				oracleTwap5MinPercentDivergence: new BN(0),
+			},
+			validity: {
+				slotsBeforeStaleForAmm: new BN(10),
+				slotsBeforeStaleForMargin: new BN(60),
+				confidenceIntervalMaxSize: new BN(20000),
+				tooVolatileRatio: new BN(5),
+			},
+		};
+
+		// Old (incorrect) gate: mirrors validate_fill_price_within_price_bands,
+		// which is NOT what the program checks before using the mm oracle price.
+		const wasTooDivergentUnderOldGate = isOracleTooDivergent(
+			market.marketStats,
+			{
+				price: mmOraclePrice,
+				slot: mmOracleSlot,
+				confidence: mmOracleConfidence,
+				hasSufficientNumberOfDataPoints: true,
+			},
+			oracleGuardRails
+		);
+		assert(
+			wasTooDivergentUnderOldGate,
+			'expected the twap5min-divergence check to trip on the stale twap'
+		);
+
+		// Correct gate: is_oracle_valid_for_action(mm_oracle_validity, UseMMOraclePrice)
+		// only rejects NonPositive/TooVolatile.
+		const mmOracleValidity = getOracleValidity(
+			market,
+			{
+				price: mmOraclePrice,
+				slot: mmOracleSlot,
+				confidence: mmOracleConfidence,
+				hasSufficientNumberOfDataPoints: true,
+			},
+			oracleGuardRails,
+			mmOracleSlot
+		);
+		const isMMOracleInvalidForUse =
+			mmOracleValidity === OracleValidity.NonPositive ||
+			mmOracleValidity === OracleValidity.TooVolatile;
+
+		assert(
+			!isMMOracleInvalidForUse,
+			`expected mm oracle to remain valid for UseMMOraclePrice, got validity=${OracleValidity[mmOracleValidity]}`
+		);
+
+		// Sanity: the exchange oracle is not materially different from the mm
+		// oracle, so the 1% mm-vs-exchange fallback threshold used alongside this
+		// gate would not itself trigger a fallback either.
+		const pctDiff = mmOraclePrice
+			.sub(exchangeOraclePrice)
+			.abs()
+			.mul(new BN(1_000_000))
+			.div(exchangeOraclePrice);
+		assert(pctDiff.lt(new BN(10_000)), 'expected mm/exchange prices within 1%');
+	});
+
+	it('does fall back when the mm oracle itself is too volatile vs its own twap', () => {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		market.marketStats.historicalOracleData.lastOraclePriceTwap = new BN(
+			100
+		).mul(PRICE_PRECISION);
+		market.marketStats.historicalOracleData.lastOraclePriceTwap5Min = new BN(
+			100
+		).mul(PRICE_PRECISION);
+
+		const mmOraclePrice = new BN(600).mul(PRICE_PRECISION); // 6x the twap
+		const mmOracleSlot = new BN(1000);
+		const mmOracleConfidence = new BN(1000);
+
+		const oracleGuardRails: OracleGuardRails = {
+			priceDivergence: {
+				markOraclePercentDivergence: new BN(0),
+				oracleTwap5MinPercentDivergence: new BN(0),
+			},
+			validity: {
+				slotsBeforeStaleForAmm: new BN(10),
+				slotsBeforeStaleForMargin: new BN(60),
+				confidenceIntervalMaxSize: new BN(20000),
+				tooVolatileRatio: new BN(5),
+			},
+		};
+
+		const mmOracleValidity = getOracleValidity(
+			market,
+			{
+				price: mmOraclePrice,
+				slot: mmOracleSlot,
+				confidence: mmOracleConfidence,
+				hasSufficientNumberOfDataPoints: true,
+			},
+			oracleGuardRails,
+			mmOracleSlot
+		);
+
+		assert(mmOracleValidity === OracleValidity.TooVolatile);
+	});
+});
+
+// Pins the sequence-id recency ordering in
+// `VelocityClient.getMMOracleDataForPerpMarket` against the program's
+// `MMOraclePriceData::new` (`state/oracle.rs`). Two boundary cases the SDK
+// previously got wrong:
+//   1. Equal sequence ids: Rust uses `exchange_seq > mm_seq`, so equal ids mean
+//      the exchange oracle is NOT more recent and the MM price is used.
+//   2. The sequence-id path guard is `abs_diff < exchange_seq / 10_000`; the slot
+//      path is its negation and must fire on `>=`, not `>`.
+describe('MM oracle sequence-id recency (getMMOracleDataForPerpMarket)', () => {
+	const guardRails: OracleGuardRails = {
+		priceDivergence: {
+			markOraclePercentDivergence: new BN(0),
+			oracleTwap5MinPercentDivergence: new BN(0),
+		},
+		validity: {
+			slotsBeforeStaleForAmm: new BN(10),
+			slotsBeforeStaleForMargin: new BN(60),
+			confidenceIntervalMaxSize: new BN(20000),
+			tooVolatileRatio: new BN(5),
+		},
+	};
+
+	// exchange 100.0, mm 100.5 => 0.5% apart (within the 1% fallback threshold),
+	// so the only thing deciding which price is returned is the recency ordering.
+	const exchangePrice = new BN(100).mul(PRICE_PRECISION);
+	const mmOraclePrice = exchangePrice.add(PRICE_PRECISION.divn(2));
+
+	function callWith(
+		exchangeSequenceId: BN,
+		mmOracleSequenceId: BN
+	): MMOraclePriceData {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		// twaps == exchange price keeps the mm oracle Valid (not TooVolatile).
+		market.marketStats.historicalOracleData.lastOraclePriceTwap = exchangePrice;
+		market.marketStats.historicalOracleData.lastOraclePriceTwap5Min =
+			exchangePrice;
+		market.marketStats.mmOraclePrice = mmOraclePrice;
+		market.marketStats.mmOracleSlot = new BN(1000);
+		market.marketStats.mmOracleSequenceId = mmOracleSequenceId;
+
+		const oracleData = {
+			price: exchangePrice,
+			slot: new BN(1000),
+			confidence: new BN(1000),
+			hasSufficientNumberOfDataPoints: true,
+			sequenceId: exchangeSequenceId,
+		};
+
+		const fakeThis = {
+			getPerpMarketAccountOrThrow: () => market,
+			getOracleDataForPerpMarket: () => oracleData,
+			accountSubscriber: {
+				getStateAccountAndSlot: () => ({
+					data: { oracleGuardRails: guardRails },
+					slot: 1000,
+				}),
+			},
+		};
+
+		return VelocityClient.prototype.getMMOracleDataForPerpMarket.call(
+			fakeThis,
+			0
+		) as MMOraclePriceData;
+	}
+
+	it('uses the MM oracle when sequence ids are equal (mirrors exchange_seq > mm_seq)', () => {
+		// seq >= 10_000 so abs_diff(0) < seq/10_000, i.e. the sequence-id path is taken.
+		const result = callWith(new BN(20000), new BN(20000));
+		assert(
+			result.price.eq(mmOraclePrice),
+			`expected MM price on equal sequence ids, got ${result.price.toString()}`
+		);
+	});
+
+	it('uses the MM oracle when the exchange sequence id is older', () => {
+		// abs_diff (5) < threshold (100_000 / 10_000 = 10) => sequence-id path.
+		const result = callWith(new BN(100_000), new BN(100_005));
+		assert(
+			result.price.eq(mmOraclePrice),
+			`expected MM price when exchange seq < mm seq, got ${result.price.toString()}`
+		);
+	});
+
+	it('falls back to the exchange oracle when its sequence id is newer', () => {
+		// abs_diff (6) < threshold (100_006 / 10_000 = 10) => sequence-id path.
+		const result = callWith(new BN(100_006), new BN(100_000));
+		assert(
+			result.price.eq(exchangePrice),
+			`expected exchange price when exchange seq > mm seq, got ${result.price.toString()}`
+		);
+	});
+
+	it('switches to slot recency at the abs_diff == seq/10_000 boundary (>=, not >)', () => {
+		// exchange_seq = 100_000 => threshold = 10. abs_diff = 10 == threshold, so
+		// Rust takes the slot/delay path. With equal slots the exchange oracle is not
+		// more recent, so the MM price is used — a `>` guard would instead take the
+		// sequence path and, with exchange_seq (100_010) > mm_seq (100_000), wrongly
+		// fall back to the exchange oracle.
+		const result = callWith(new BN(100_010), new BN(100_000));
+		assert(
+			result.price.eq(mmOraclePrice),
+			`expected MM price at the slot-path boundary, got ${result.price.toString()}`
+		);
+	});
+});
+
+// M15: isFallbackAvailableLiquiditySource must mirror amm_fill_gates_ok's
+// mm_oracle_not_too_volatile gate: suppress AMM fills when the MM oracle is
+// enabled, at least as recent as the exchange oracle, and diverges >1% from it.
+describe('AMM fallback availability — MM-oracle volatility gate', () => {
+	const guardRails: OracleGuardRails = {
+		priceDivergence: {
+			markOraclePercentDivergence: new BN(0),
+			oracleTwap5MinPercentDivergence: new BN(0),
+		},
+		validity: {
+			slotsBeforeStaleForAmm: new BN(10),
+			slotsBeforeStaleForMargin: new BN(60),
+			confidenceIntervalMaxSize: new BN(20000),
+			tooVolatileRatio: new BN(5),
+		},
+	};
+
+	const slot = 1000;
+
+	function makeValidMarketAndState() {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		market.pausedOperations = 0;
+		market.marketStats.historicalOracleData.lastOraclePriceTwap = new BN(
+			100
+		).mul(PRICE_PRECISION);
+		market.marketStats.historicalOracleData.lastOraclePriceTwap5Min = new BN(
+			100
+		).mul(PRICE_PRECISION);
+		const state = { oracleGuardRails: guardRails } as StateAccount;
+		return { market, state };
+	}
+
+	// A fresh, on-price MM oracle => OracleValidity.Valid, so the only thing that
+	// can flip availability in these cases is the volatility gate.
+	function makeMMData(
+		overrides: Partial<MMOraclePriceData>
+	): MMOraclePriceData {
+		return {
+			price: new BN(100).mul(PRICE_PRECISION),
+			slot: new BN(slot),
+			confidence: new BN(1000),
+			hasSufficientNumberOfDataPoints: true,
+			isMMOracleActive: true,
+			isMMOracleEnabled: true,
+			isMMOracleAsRecent: true,
+			isMMExchangeDiffBpsHigh: false,
+			...overrides,
+		};
+	}
+
+	it('is available (baseline) when the mm oracle is valid and diff is within 1%', () => {
+		const { market, state } = makeValidMarketAndState();
+		const available = isFallbackAvailableLiquiditySource(
+			mockOrder,
+			makeMMData({}),
+			slot,
+			state,
+			market
+		);
+		assert(
+			available,
+			'expected AMM fallback available for a valid, low-diff mm oracle'
+		);
+	});
+
+	it('is blocked when mm oracle is enabled, as-recent, and diff > 1%', () => {
+		const { market, state } = makeValidMarketAndState();
+		const available = isFallbackAvailableLiquiditySource(
+			mockOrder,
+			makeMMData({ isMMExchangeDiffBpsHigh: true }),
+			slot,
+			state,
+			market
+		);
+		assert(
+			!available,
+			'expected AMM fallback blocked by mm-oracle volatility gate'
+		);
+	});
+
+	it('is NOT blocked by the volatility gate when the mm oracle is not as-recent (mirrors else{true})', () => {
+		const { market, state } = makeValidMarketAndState();
+		const available = isFallbackAvailableLiquiditySource(
+			mockOrder,
+			makeMMData({ isMMExchangeDiffBpsHigh: true, isMMOracleAsRecent: false }),
+			slot,
+			state,
+			market
+		);
+		assert(
+			available,
+			'expected volatility gate to not apply when mm oracle is stale'
+		);
+	});
+
+	it('is NOT blocked by the volatility gate when the mm oracle is disabled', () => {
+		const { market, state } = makeValidMarketAndState();
+		const available = isFallbackAvailableLiquiditySource(
+			mockOrder,
+			makeMMData({ isMMExchangeDiffBpsHigh: true, isMMOracleEnabled: false }),
+			slot,
+			state,
+			market
+		);
+		assert(
+			available,
+			'expected volatility gate to not apply when mm oracle disabled'
+		);
+	});
+
+	it('skips the volatility gate when the flags are absent (backward compat)', () => {
+		const { market, state } = makeValidMarketAndState();
+		const available = isFallbackAvailableLiquiditySource(
+			mockOrder,
+			makeMMData({
+				isMMOracleEnabled: undefined,
+				isMMOracleAsRecent: undefined,
+				isMMExchangeDiffBpsHigh: undefined,
+			}),
+			slot,
+			state,
+			market
+		);
+		assert(
+			available,
+			'expected gate skipped when mm volatility flags unpopulated'
+		);
+	});
+});

package/tests/oracles/pythPegSnap.test.ts

@@ -0,0 +1,76 @@
+import * as pythClientLib from '@pythnetwork/client';
+import * as sinon from 'sinon';
+import { PythClient } from '../../src/oracles/pythClient';
+import { PythLazerClient } from '../../src/oracles/pythLazerClient';
+import { BN, QUOTE_PRECISION } from '../../src';
+import { assert } from '../../src/assert/assert';
+
+// Program's `get_pyth_stable_coin_price` snaps to peg when
+// `|price - QUOTE_PRECISION| <= min(confidence, five_bps)` (note `<=`, not `<`).
+describe('Pyth stablecoin peg-snap boundary', () => {
+	afterEach(() => {
+		sinon.restore();
+	});
+
+	describe('PythClient', () => {
+		function stubParsePriceData(priceAboveQuote: number, confidence: number) {
+			sinon.stub(pythClientLib, 'parsePriceData').returns({
+				exponent: -6,
+				aggregate: { price: 1 + priceAboveQuote / 1_000_000 },
+				confidence: confidence / 1_000_000,
+				twap: { value: 1 },
+				twac: { value: 0 },
+				lastSlot: { toString: () => '1' },
+				numComponentPrices: 3,
+				numQuoters: 3,
+			} as any);
+		}
+
+		it('snaps to peg exactly at the confidence bound', () => {
+			// spread == min(confidence, fiveBPS) == 500 exactly
+			stubParsePriceData(500, 1000);
+			const client = new PythClient({} as any, undefined, true);
+			const data = client.getOraclePriceDataFromBuffer(Buffer.alloc(1));
+			assert(data.price.eq(QUOTE_PRECISION));
+		});
+
+		it('does not snap just past the confidence bound', () => {
+			stubParsePriceData(501, 1000);
+			const client = new PythClient({} as any, undefined, true);
+			const data = client.getOraclePriceDataFromBuffer(Buffer.alloc(1));
+			assert(!data.price.eq(QUOTE_PRECISION));
+			assert(data.price.eq(QUOTE_PRECISION.add(new BN(501))));
+		});
+	});
+
+	describe('PythLazerClient', () => {
+		function makeClient(priceAboveQuote: number, confidence: number) {
+			const client = new PythLazerClient(
+				{ commitment: 'confirmed' } as any,
+				undefined,
+				true
+			);
+			(client as any).decodeFunc = () => ({
+				price: QUOTE_PRECISION.add(new BN(priceAboveQuote)),
+				conf: new BN(confidence),
+				exponent: -6,
+				postedSlot: new BN(1),
+				publishTime: new BN(1),
+			});
+			return client;
+		}
+
+		it('snaps to peg exactly at the confidence bound', () => {
+			const client = makeClient(500, 1000);
+			const data = client.getOraclePriceDataFromBuffer(Buffer.alloc(1));
+			assert(data.price.eq(QUOTE_PRECISION));
+		});
+
+		it('does not snap just past the confidence bound', () => {
+			const client = makeClient(501, 1000);
+			const data = client.getOraclePriceDataFromBuffer(Buffer.alloc(1));
+			assert(!data.price.eq(QUOTE_PRECISION));
+			assert(data.price.eq(QUOTE_PRECISION.add(new BN(501))));
+		});
+	});
+});

package/tests/sdkParity/enumParity.test.ts

@@ -0,0 +1,84 @@
+import velocityIDL from '../../src/idl/velocity.json';
+import {
+	OracleSource,
+	ContractType,
+	PerpOperation,
+	OrderBitFlag,
+} from '../../src';
+import { assert } from 'chai';
+
+type IdlEnumVariant = { name: string };
+type IdlEnumType = {
+	name: string;
+	type: { kind: 'enum'; variants: IdlEnumVariant[] };
+};
+
+function idlVariantNames(typeName: string): string[] {
+	const idlType = (velocityIDL as { types: IdlEnumType[] }).types.find(
+		(t) => t.name === typeName
+	);
+	if (!idlType) {
+		throw new Error(`IDL type '${typeName}' not found`);
+	}
+	return idlType.type.variants.map((v) => v.name);
+}
+
+// Anchor's TS coder lowercases the first letter of a PascalCase Rust variant
+// name (e.g. `DeprecatedSwitchboard` -> `deprecatedSwitchboard`).
+function toCamelCase(pascalCase: string): string {
+	return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+
+function variantKeysOf(values: unknown[]): string[] {
+	return values.map((v) => Object.keys(v as Record<string, unknown>)[0]);
+}
+
+describe('SDK enum parity with IDL', () => {
+	it('OracleSource variant keys match every IDL variant, including the deprecated switchboard renames', () => {
+		const expectedKeys = idlVariantNames('OracleSource').map(toCamelCase);
+		const sdkKeys = variantKeysOf(Object.values(OracleSource));
+
+		for (const expected of expectedKeys) {
+			assert.include(
+				sdkKeys,
+				expected,
+				`OracleSource is missing IDL variant '${expected}'`
+			);
+		}
+
+		// The program renamed these discriminants; the SDK must key on the new
+		// names, or decode throws 'Invalid oracle source' for any market still
+		// wired to a switchboard oracle.
+		assert.notInclude(sdkKeys, 'switchboard');
+		assert.notInclude(sdkKeys, 'switchboardOnDemand');
+		assert.include(sdkKeys, 'deprecatedSwitchboard');
+		assert.include(sdkKeys, 'deprecatedSwitchboardOnDemand');
+	});
+
+	it('ContractType variant keys match the IDL exactly', () => {
+		const expectedKeys = idlVariantNames('ContractType').map(toCamelCase);
+		const sdkKeys = variantKeysOf(Object.values(ContractType));
+
+		assert.sameMembers(sdkKeys, expectedKeys);
+	});
+
+	it('PerpOperation bit flags match the on-chain 8-bit layout', () => {
+		assert.equal(PerpOperation.UPDATE_FUNDING, 1);
+		assert.equal(PerpOperation.AMM_FILL, 2);
+		assert.equal(PerpOperation.FILL, 4);
+		assert.equal(PerpOperation.SETTLE_PNL, 8);
+		assert.equal(PerpOperation.SETTLE_PNL_WITH_POSITION, 16);
+		assert.equal(PerpOperation.LIQUIDATION, 32);
+		assert.equal(PerpOperation.AMM_IMMEDIATE_FILL, 64);
+		assert.equal(PerpOperation.SETTLE_REV_POOL, 128);
+	});
+
+	it('OrderBitFlag values match the on-chain 6-bit layout', () => {
+		assert.equal(OrderBitFlag.SignedMessage, 1);
+		assert.equal(OrderBitFlag.OracleTriggerMarket, 2);
+		assert.equal(OrderBitFlag.SafeTriggerOrder, 4);
+		assert.equal(OrderBitFlag.NewTriggerReduceOnly, 8);
+		assert.equal(OrderBitFlag.HasBuilder, 16);
+		assert.equal(OrderBitFlag.IsIsolatedPosition, 32);
+	});
+});

package/tests/sdkParity/marginCategoryFill.test.ts

@@ -0,0 +1,143 @@
+import * as _ from 'lodash';
+import {
+	BN,
+	ZERO,
+	PRICE_PRECISION,
+	calculateMarketMarginRatio,
+	calculateUnrealizedAssetWeight,
+	calculateAssetWeight,
+	calculateLiabilityWeight,
+} from '../../src';
+import { mockPerpMarkets, mockSpotMarkets } from '../dlob/helpers';
+import { assert } from '../../src/assert/assert';
+
+// The MarginCategory type declares 'Fill', but calculateMarketMarginRatio used to
+// throw on it and calculateUnrealizedAssetWeight returned undefined. Both now mirror
+// PerpMarket::get_margin_ratio / get_unrealized_asset_weight (perp_market.rs).
+describe("MarginCategory 'Fill' parity", () => {
+	it('calculateMarketMarginRatio uses (initial + maintenance) / 2 for Fill', () => {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		market.marginRatioInitial = 1000;
+		market.marginRatioMaintenance = 500;
+		market.imfFactor = 0; // no size premium, so ratio == default
+
+		const initial = calculateMarketMarginRatio(market, ZERO, 'Initial');
+		const maintenance = calculateMarketMarginRatio(market, ZERO, 'Maintenance');
+		const fill = calculateMarketMarginRatio(market, ZERO, 'Fill');
+
+		assert(initial === 1000, `expected initial 1000, got ${initial}`);
+		assert(maintenance === 500, `expected maintenance 500, got ${maintenance}`);
+		// (1000 + 500) / 2 = 750
+		assert(fill === 750, `expected fill 750, got ${fill}`);
+	});
+
+	it('calculateMarketMarginRatio Fill uses integer division (floor)', () => {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		market.marginRatioInitial = 1001;
+		market.marginRatioMaintenance = 500;
+		market.imfFactor = 0;
+
+		// (1001 + 500) / 2 = 750.5 -> floored to 750, matching u32 division
+		const fill = calculateMarketMarginRatio(market, ZERO, 'Fill');
+		assert(fill === 750, `expected floored fill 750, got ${fill}`);
+	});
+
+	it('calculateUnrealizedAssetWeight weights Fill identically to Initial', () => {
+		const market = _.cloneDeep(mockPerpMarkets[0]);
+		const quoteSpot = _.cloneDeep(mockSpotMarkets[0]);
+		market.unrealizedPnlInitialAssetWeight = 8000;
+		market.unrealizedPnlMaintenanceAssetWeight = 10000;
+		market.unrealizedPnlMaxImbalance = ZERO; // no imbalance discount
+		market.unrealizedPnlImfFactor = 0; // no size discount
+
+		const unrealizedPnl = new BN(100).mul(PRICE_PRECISION);
+		const oraclePriceData = { price: new BN(100).mul(PRICE_PRECISION) };
+
+		const initial = calculateUnrealizedAssetWeight(
+			market,
+			quoteSpot,
+			unrealizedPnl,
+			'Initial',
+			oraclePriceData
+		);
+		const fill = calculateUnrealizedAssetWeight(
+			market,
+			quoteSpot,
+			unrealizedPnl,
+			'Fill',
+			oraclePriceData
+		);
+		const maintenance = calculateUnrealizedAssetWeight(
+			market,
+			quoteSpot,
+			unrealizedPnl,
+			'Maintenance',
+			oraclePriceData
+		);
+
+		assert(fill.eq(initial), `expected Fill weight == Initial weight`);
+		assert(fill.eq(new BN(8000)), `expected Fill weight 8000, got ${fill}`);
+		assert(
+			maintenance.eq(new BN(10000)),
+			`expected Maintenance weight 10000, got ${maintenance}`
+		);
+	});
+
+	it('spot calculateAssetWeight Fill = (scaledInitial + maintenance) / 2', () => {
+		const spotMarket = _.cloneDeep(mockSpotMarkets[0]);
+		spotMarket.imfFactor = 0; // no size discount
+		spotMarket.scaleInitialAssetWeightStart = ZERO; // scaledInitial == initial
+		spotMarket.initialAssetWeight = 8000;
+		spotMarket.maintenanceAssetWeight = 9000;
+
+		const balance = new BN(1);
+		const oraclePrice = new BN(100).mul(PRICE_PRECISION);
+
+		const initial = calculateAssetWeight(
+			balance,
+			oraclePrice,
+			spotMarket,
+			'Initial'
+		);
+		const maintenance = calculateAssetWeight(
+			balance,
+			oraclePrice,
+			spotMarket,
+			'Maintenance'
+		);
+		const fill = calculateAssetWeight(balance, oraclePrice, spotMarket, 'Fill');
+
+		assert(initial.eq(new BN(8000)), `expected initial 8000, got ${initial}`);
+		assert(
+			maintenance.eq(new BN(9000)),
+			`expected maintenance 9000, got ${maintenance}`
+		);
+		// (8000 + 9000) / 2 = 8500
+		assert(fill.eq(new BN(8500)), `expected fill 8500, got ${fill}`);
+	});
+
+	it('spot calculateLiabilityWeight Fill = (initial + maintenance) / 2', () => {
+		const spotMarket = _.cloneDeep(mockSpotMarkets[0]);
+		spotMarket.imfFactor = 0; // no size premium
+		spotMarket.initialLiabilityWeight = 12000;
+		spotMarket.maintenanceLiabilityWeight = 11000;
+
+		const size = new BN(1);
+
+		const initial = calculateLiabilityWeight(size, spotMarket, 'Initial');
+		const maintenance = calculateLiabilityWeight(
+			size,
+			spotMarket,
+			'Maintenance'
+		);
+		const fill = calculateLiabilityWeight(size, spotMarket, 'Fill');
+
+		assert(initial.eq(new BN(12000)), `expected initial 12000, got ${initial}`);
+		assert(
+			maintenance.eq(new BN(11000)),
+			`expected maintenance 11000, got ${maintenance}`
+		);
+		// (12000 + 11000) / 2 = 11500
+		assert(fill.eq(new BN(11500)), `expected fill 11500, got ${fill}`);
+	});
+});