@velocity-exchange/sdk 0.2.5 → 0.4.0

package/tests/sdkParity/memcmpOffsets.test.ts

@@ -0,0 +1,139 @@
+import {
+	getUserStatsIsReferredFilter,
+	getUserStatsIsReferredOrReferrerFilter,
+} from '../../src/memcmp';
+import velocityIDL from '../../src/idl/velocity.json';
+import { assert } from 'chai';
+import bs58 from 'bs58';
+
+const ANCHOR_DISCRIMINATOR_SIZE = 8;
+
+type IdlField = { name: string; type: unknown };
+type IdlStructType = {
+	name: string;
+	type: { kind: 'struct'; fields: IdlField[] };
+};
+
+function findIdlStruct(typeName: string): IdlStructType {
+	const idlType = (velocityIDL as { types: IdlStructType[] }).types.find(
+		(t) => t.name === typeName
+	);
+	if (!idlType) {
+		throw new Error(`IDL type '${typeName}' not found`);
+	}
+	return idlType;
+}
+
+// Byte size of a single IDL field type. Covers exactly the primitive/defined
+// types that appear in `UserStats` ahead of `referrer_status`. Throws on any
+// type it doesn't recognize so a future layout change with a new field type
+// fails loudly instead of silently computing a wrong offset.
+function idlTypeSize(type: unknown): number {
+	if (typeof type === 'string') {
+		switch (type) {
+			case 'pubkey':
+				return 32;
+			case 'u64':
+			case 'i64':
+				return 8;
+			case 'u32':
+			case 'i32':
+				return 4;
+			case 'u16':
+			case 'i16':
+				return 2;
+			case 'u8':
+			case 'i8':
+			case 'bool':
+				return 1;
+			default:
+				throw new Error(`Unrecognized primitive IDL type '${type}'`);
+		}
+	}
+
+	if (type && typeof type === 'object') {
+		const obj = type as Record<string, unknown>;
+
+		if ('array' in obj) {
+			const [elemType, len] = obj.array as [unknown, number];
+			return idlTypeSize(elemType) * len;
+		}
+
+		if ('defined' in obj) {
+			const defined = obj.defined as { name: string } | string;
+			const typeName = typeof defined === 'string' ? defined : defined.name;
+			const definedStruct = findIdlStruct(typeName);
+			return definedStruct.type.fields.reduce(
+				(sum, field) => sum + idlTypeSize(field.type),
+				0
+			);
+		}
+	}
+
+	throw new Error(`Unrecognized IDL type shape: ${JSON.stringify(type)}`);
+}
+
+// Computes the byte offset (including the 8-byte Anchor discriminator) of
+// `fieldName` within the given IDL struct, by summing the sizes of all
+// fields declared before it.
+function deriveFieldOffset(structTypeName: string, fieldName: string): number {
+	const struct = findIdlStruct(structTypeName);
+	let offset = ANCHOR_DISCRIMINATOR_SIZE;
+
+	for (const field of struct.type.fields) {
+		if (field.name === fieldName) {
+			return offset;
+		}
+		offset += idlTypeSize(field.type);
+	}
+
+	throw new Error(
+		`Field '${fieldName}' not found in IDL type '${structTypeName}'`
+	);
+}
+
+const REFERRER_STATUS_OFFSET = deriveFieldOffset(
+	'UserStats',
+	'referrer_status'
+);
+
+// Sanity check: this offset is also asserted as a literal in
+// `USER_STATS_REFERRER_STATUS_OFFSET` (packages/sdk/src/memcmp.ts). If the IDL
+// ever disagrees with that literal, the `it` blocks below will fail and
+// surface the discrepancy rather than silently passing.
+const USER_STATS_SIZE = 240; // includes the 8-byte discriminator
+
+function buildSyntheticUserStatsBuffer(referrerStatus: number): Buffer {
+	const buffer = Buffer.alloc(USER_STATS_SIZE);
+	buffer.writeUInt8(referrerStatus, REFERRER_STATUS_OFFSET);
+	return buffer;
+}
+
+describe('UserStats memcmp offsets', () => {
+	it('getUserStatsIsReferredFilter targets the IDL-derived referrer_status offset, not the stale 188', () => {
+		const filter = getUserStatsIsReferredFilter();
+
+		assert.equal(filter.memcmp.offset, REFERRER_STATUS_OFFSET);
+		assert.notEqual(filter.memcmp.offset, 188);
+		assert.equal(bs58.decode(filter.memcmp.bytes as string)[0], 2);
+	});
+
+	it('getUserStatsIsReferredOrReferrerFilter targets the IDL-derived referrer_status offset, not the stale 188', () => {
+		const filter = getUserStatsIsReferredOrReferrerFilter();
+
+		assert.equal(filter.memcmp.offset, REFERRER_STATUS_OFFSET);
+		assert.notEqual(filter.memcmp.offset, 188);
+		assert.equal(bs58.decode(filter.memcmp.bytes as string)[0], 3);
+	});
+
+	it('a synthetic UserStats buffer with referrer_status=2 (IsReferred) matches only at the corrected offset', () => {
+		const buffer = buildSyntheticUserStatsBuffer(2);
+		const filter = getUserStatsIsReferredFilter();
+		const expectedByte = bs58.decode(filter.memcmp.bytes as string)[0];
+
+		assert.equal(buffer[filter.memcmp.offset as number], expectedByte);
+		// The old hardcoded offset (188) lands on a zeroed padding byte, which is
+		// exactly why the filter previously matched zero accounts.
+		assert.equal(buffer[188], 0);
+	});
+});

package/tests/spot/test.ts

@@ -6,6 +6,10 @@ import {
 	calculateSizePremiumLiabilityWeight,
 	calculateBorrowRate,
 	calculateDepositRate,
+	calculateWithdrawLimit,
+	getTokenValue,
+	getStrictTokenValue,
+	StrictOraclePrice,
 } from '../../src';
 import { mockSpotMarkets } from '../dlob/helpers';
 import * as _ from 'lodash';
@@ -223,4 +227,55 @@ describe('Spot Tests', () => {
 		// console.log(addBor1.toNumber());
 		assert(addBor1.eqn(20918)); // went up
 	});
+
+	function buildWithdrawLimitMarket(poolId: number) {
+		const mockSpot = _.cloneDeep(mockSpotMarkets[0]);
+		mockSpot.decimals = 9;
+		mockSpot.cumulativeDepositInterest = new BN(10).pow(new BN(10));
+		mockSpot.cumulativeBorrowInterest = new BN(10).pow(new BN(10));
+		mockSpot.depositBalance = new BN(100000);
+		mockSpot.borrowBalance = new BN(10000);
+		mockSpot.depositTokenTwap = new BN(70000);
+		mockSpot.borrowTokenTwap = new BN(10000);
+		mockSpot.lastTwapTs = new BN(0);
+		mockSpot.optimalUtilization = 900000;
+		mockSpot.utilizationTwap = new BN(0);
+		mockSpot.withdrawGuardThreshold = new BN(0);
+		mockSpot.maxTokenBorrowsFraction = 0;
+		mockSpot.poolId = poolId;
+		return mockSpot;
+	}
+
+	it('withdraw limit (main pool) uses lesserDepositAmount with /3, /5, /14', () => {
+		// depositTokenTwapLive works out to 85000 (< the 100000 raw deposit
+		// amount), so this pins both the divisors and that the twap-min'd
+		// amount -- not the raw deposit amount -- feeds the first max() term
+		const mockSpot = buildWithdrawLimitMarket(0);
+		const now = new BN(43200); // half of the 24h twap window since lastTwapTs
+
+		const result = calculateWithdrawLimit(mockSpot, now);
+		assert(result.maxBorrowAmount.eq(new BN(28333)));
+		assert(result.borrowLimit.eq(new BN(18333)));
+	});
+
+	it('withdraw limit (isolated pool) uses lesserDepositAmount with /2, /3, /20', () => {
+		const mockSpot = buildWithdrawLimitMarket(1);
+		const now = new BN(43200);
+
+		const result = calculateWithdrawLimit(mockSpot, now);
+		assert(result.maxBorrowAmount.eq(new BN(42500)));
+		assert(result.borrowLimit.eq(new BN(32500)));
+	});
+
+	it('getTokenValue floors (rounds toward -infinity) for a negative product', () => {
+		// -3 * 5 = -15; -15/10 truncates to -1 but floors to -2
+		const value = getTokenValue(new BN(-3), 1, { price: new BN(5) });
+		assert(value.eq(new BN(-2)));
+	});
+
+	it('getStrictTokenValue floors (rounds toward -infinity) for a negative product', () => {
+		const strictPrice = new StrictOraclePrice(new BN(5), new BN(5));
+		const value = getStrictTokenValue(new BN(-3), 1, strictPrice);
+		assert(value.eq(new BN(-2)));
+	});
 });

package/tests/user/bankruptcy.ts

@@ -0,0 +1,165 @@
+import { assert } from 'chai';
+import _ from 'lodash';
+import { PositionFlag } from '../../src/types';
+import {
+	BASE_PRECISION,
+	QUOTE_PRECISION,
+} from '../../src/constants/numericConstants';
+import { BN } from '../../src';
+import { mockPerpMarkets, mockSpotMarkets } from '../dlob/helpers';
+import {
+	mockUserAccount as baseMockUserAccount,
+	makeMockUser,
+} from './helpers';
+import {
+	isUserBankrupt,
+	isIsolatedPositionBankrupt,
+	hasIsolatedMarginBankrupt,
+} from '../../src/math/bankruptcy';
+
+async function makeUserWithAccount(account) {
+	const user = await makeMockUser(
+		_.cloneDeep(mockPerpMarkets),
+		_.cloneDeep(mockSpotMarkets),
+		account,
+		[1, 1, 1, 1, 1, 1, 1, 1],
+		[1, 1, 1, 1, 1, 1, 1, 1]
+	);
+	return user;
+}
+
+describe('isUserBankrupt', () => {
+	it('cross-bankrupt user is still bankrupt when an open isolated position is present', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		// cross position: no base, negative quote (liability), no open orders -> cross-bankrupt shape
+		account.perpPositions[0].marketIndex = 0;
+		account.perpPositions[0].baseAssetAmount = new BN(0);
+		account.perpPositions[0].quoteAssetAmount = new BN(-100).mul(
+			QUOTE_PRECISION
+		);
+		account.perpPositions[0].positionFlag = 0;
+
+		// isolated position: still open (nonzero base) - would have tripped the old
+		// unconditional loop into reporting "not bankrupt"
+		account.perpPositions[1].marketIndex = 1;
+		account.perpPositions[1].baseAssetAmount = new BN(5).mul(BASE_PRECISION);
+		account.perpPositions[1].quoteAssetAmount = new BN(0);
+		account.perpPositions[1].positionFlag = PositionFlag.IsolatedPosition;
+
+		const user = await makeUserWithAccount(account);
+
+		assert.equal(isUserBankrupt(user), true);
+	});
+
+	it('user with no liability is not bankrupt', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+		const user = await makeUserWithAccount(account);
+		assert.equal(isUserBankrupt(user), false);
+	});
+});
+
+describe('isIsolatedPositionBankrupt', () => {
+	it('isolated position with no deposit, no base, and a quote liability is bankrupt', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		account.perpPositions[0].marketIndex = 0;
+		account.perpPositions[0].baseAssetAmount = new BN(0);
+		account.perpPositions[0].quoteAssetAmount = new BN(-50).mul(
+			QUOTE_PRECISION
+		);
+		account.perpPositions[0].positionFlag = PositionFlag.IsolatedPosition;
+		account.perpPositions[0].isolatedPositionScaledBalance = new BN(0);
+
+		const user = await makeUserWithAccount(account);
+
+		assert.equal(isIsolatedPositionBankrupt(user, 0), true);
+	});
+
+	it('isolated position with a remaining deposit is not bankrupt', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		account.perpPositions[0].marketIndex = 0;
+		account.perpPositions[0].baseAssetAmount = new BN(0);
+		account.perpPositions[0].quoteAssetAmount = new BN(-50).mul(
+			QUOTE_PRECISION
+		);
+		account.perpPositions[0].positionFlag = PositionFlag.IsolatedPosition;
+		account.perpPositions[0].isolatedPositionScaledBalance = new BN(1000);
+
+		const user = await makeUserWithAccount(account);
+
+		assert.equal(isIsolatedPositionBankrupt(user, 0), false);
+	});
+
+	it('throws (InvalidPerpPosition) on a non-isolated position', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		account.perpPositions[0].marketIndex = 0;
+		account.perpPositions[0].baseAssetAmount = new BN(0);
+		account.perpPositions[0].quoteAssetAmount = new BN(-50).mul(
+			QUOTE_PRECISION
+		);
+		account.perpPositions[0].positionFlag = 0; // not isolated
+		account.perpPositions[0].isolatedPositionScaledBalance = new BN(0);
+
+		const user = await makeUserWithAccount(account);
+
+		assert.throws(() => isIsolatedPositionBankrupt(user, 0), /not an isolated/);
+	});
+});
+
+describe('hasIsolatedMarginBankrupt', () => {
+	it('detects an economically-bankrupt isolated position (flag not yet set on-chain)', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		// isolated: drained deposit, flat base, quote liability, no open orders,
+		// but the on-chain Bankrupt status flag has NOT been set yet.
+		account.perpPositions[0].marketIndex = 1;
+		account.perpPositions[0].baseAssetAmount = new BN(0);
+		account.perpPositions[0].quoteAssetAmount = new BN(-25).mul(
+			QUOTE_PRECISION
+		);
+		account.perpPositions[0].positionFlag = PositionFlag.IsolatedPosition;
+		account.perpPositions[0].isolatedPositionScaledBalance = new BN(0);
+
+		const user = await makeUserWithAccount(account);
+
+		// isUserBankrupt (cross) deliberately skips isolated positions, and
+		// user.isBankrupt() only reads UserStatus.BANKRUPT -> both miss this.
+		assert.equal(isUserBankrupt(user), false);
+		assert.equal(user.isBankrupt(), false);
+		assert.equal(hasIsolatedMarginBankrupt(user), true);
+	});
+
+	it('detects an isolated position already flagged Bankrupt on-chain', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		// still has collateral / non-flat, so not economically bankrupt by shape,
+		// but the program already set the Bankrupt position flag.
+		account.perpPositions[0].marketIndex = 1;
+		account.perpPositions[0].baseAssetAmount = new BN(3).mul(BASE_PRECISION);
+		account.perpPositions[0].quoteAssetAmount = new BN(0);
+		account.perpPositions[0].isolatedPositionScaledBalance = new BN(1000);
+		account.perpPositions[0].positionFlag =
+			PositionFlag.IsolatedPosition | PositionFlag.Bankruptcy;
+
+		const user = await makeUserWithAccount(account);
+
+		assert.equal(hasIsolatedMarginBankrupt(user), true);
+	});
+
+	it('returns false for a healthy isolated position', async () => {
+		const account = _.cloneDeep(baseMockUserAccount);
+
+		account.perpPositions[0].marketIndex = 1;
+		account.perpPositions[0].baseAssetAmount = new BN(3).mul(BASE_PRECISION);
+		account.perpPositions[0].quoteAssetAmount = new BN(0);
+		account.perpPositions[0].positionFlag = PositionFlag.IsolatedPosition;
+		account.perpPositions[0].isolatedPositionScaledBalance = new BN(1000);
+
+		const user = await makeUserWithAccount(account);
+
+		assert.equal(hasIsolatedMarginBankrupt(user), false);
+	});
+});

package/tests/user/feeAndWithdrawLimits.ts

@@ -0,0 +1,284 @@
+import {
+	BN,
+	ZERO,
+	User,
+	MarketType,
+	SpotBalanceType,
+	ReferrerStatus,
+	UserStatsAccount,
+	SPOT_MARKET_BALANCE_PRECISION,
+} from '../../src';
+import { assert } from '../../src/assert/assert';
+import { mockPerpMarkets, mockSpotMarkets } from '../dlob/helpers';
+import {
+	mockUserAccount as baseMockUserAccount,
+	makeMockUser,
+} from './helpers';
+import * as _ from 'lodash';
+
+const mockFeeTier = {
+	feeNumerator: 1,
+	feeDenominator: 1000,
+	makerRebateNumerator: 0,
+	makerRebateDenominator: 1000,
+	referrerRewardNumerator: 0,
+	referrerRewardDenominator: 100,
+	refereeFeeNumerator: 25,
+	refereeFeeDenominator: 100,
+};
+
+const mockFeeStructure = {
+	feeTiers: Array.from({ length: 6 }, () => ({ ...mockFeeTier })),
+	fillerRewardStructure: {
+		rewardNumerator: 0,
+		rewardDenominator: 1,
+		timeBasedRewardLowerBound: ZERO,
+	},
+	flatFillerFee: ZERO,
+	ammFeeNumerator: 0,
+	ifFeeNumerator: 0,
+};
+
+const mockUserStatsAccount: UserStatsAccount = {
+	numberOfSubAccounts: 1,
+	numberOfSubAccountsCreated: 1,
+	makerVolume30D: ZERO,
+	takerVolume30D: ZERO,
+	fillerVolume30D: ZERO,
+	lastMakerVolume30DTs: ZERO,
+	lastTakerVolume30DTs: ZERO,
+	lastFillerVolume30DTs: ZERO,
+	fees: {
+		totalFeePaid: ZERO,
+		totalFeeRebate: ZERO,
+		totalTokenDiscount: ZERO,
+		totalRefereeDiscount: ZERO,
+	},
+	referrer: undefined as any,
+	referrerStatus: 0,
+	disableUpdatePerpBidAskTwap: 0,
+	pausedOperations: 0,
+	authority: undefined as any,
+	ifStakedQuoteAssetAmount: ZERO,
+	delegatePermissions: 0,
+};
+
+async function makeFeeMockUser(referrerStatus: number): Promise<User> {
+	const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+	const myMockSpotMarkets = _.cloneDeep(mockSpotMarkets);
+	const myMockUserAccount = _.cloneDeep(baseMockUserAccount);
+
+	const user = await makeMockUser(
+		myMockPerpMarkets,
+		myMockSpotMarkets,
+		myMockUserAccount,
+		[1, 1, 1, 1, 1, 1, 1, 1],
+		[1, 1, 1, 1, 1, 1, 1, 1]
+	);
+
+	user.velocityClient.getStateAccount = () =>
+		({
+			perpFeeStructure: mockFeeStructure,
+			spotFeeStructure: mockFeeStructure,
+		}) as any;
+
+	const userStatsAccount = {
+		..._.cloneDeep(mockUserStatsAccount),
+		referrerStatus,
+	};
+	user.velocityClient.getUserStatsOrThrow = () =>
+		({
+			getAccountOrThrow: () => userStatsAccount,
+		}) as any;
+	// getMarketFees reads referee status via getUserStats()?.getAccount()
+	user.velocityClient.getUserStats = () =>
+		({
+			getAccount: () => userStatsAccount,
+		}) as any;
+	// getMarketFees(marketIndex) reads the market's feeAdjustment
+	user.velocityClient.getPerpMarketAccountOrThrow = () =>
+		({
+			marketIndex: 0,
+			feeAdjustment: 0,
+		}) as any;
+
+	return user;
+}
+
+describe('User fee calculation', () => {
+	it('taker fee for a non-market-index quote amount rounds up (ceil)', async () => {
+		const user = await makeFeeMockUser(0);
+
+		// 1_000_007 * 1 / 1000 = 1000.007 -> ceil = 1001, floor would be 1000
+		const fee = user.calculatePerpTakerFee(new BN(1_000_007));
+		assert(
+			fee.eq(new BN(1001)),
+			`expected ceil-rounded fee of 1001, got ${fee.toString()}`
+		);
+	});
+
+	it('referee discount is not applied for a non-referred user', async () => {
+		const user = await makeFeeMockUser(0);
+
+		const fee = user.calculatePerpTakerFee(new BN(1_000_000));
+		// 1_000_000 * 1 / 1000 = 1000, no referee discount
+		assert(
+			fee.eq(new BN(1000)),
+			`expected undiscounted fee, got ${fee.toString()}`
+		);
+	});
+
+	it('referee discount is applied when the user stats account marks them as referred', async () => {
+		const user = await makeFeeMockUser(ReferrerStatus.IsReferred);
+
+		const fee = user.calculatePerpTakerFee(new BN(1_000_000));
+		// base fee = 1000, referee discount = 25% of 1000 = 250 -> fee = 750
+		assert(
+			fee.eq(new BN(750)),
+			`expected 25% referee discount applied, got ${fee.toString()}`
+		);
+	});
+
+	it('an explicit isReferee override applies the discount regardless of user stats', async () => {
+		const user = await makeFeeMockUser(0);
+
+		const fee = user.calculatePerpTakerFee(new BN(1_000_000), undefined, true);
+		assert(
+			fee.eq(new BN(750)),
+			`expected 25% referee discount applied via override, got ${fee.toString()}`
+		);
+	});
+
+	// M11: getMarketFees (the primary fee-prediction entry point) must apply the
+	// referee discount, not just calculatePerpTakerFee's volume-tier branch.
+	it('getMarketFees applies the referee discount to the taker fee for a referred user', async () => {
+		const referred = await makeFeeMockUser(ReferrerStatus.IsReferred);
+		const notReferred = await makeFeeMockUser(0);
+
+		const { takerFee: referredTakerFee } =
+			referred.velocityClient.getMarketFees(MarketType.PERP, 0, referred);
+		const { takerFee: baseTakerFee } = notReferred.velocityClient.getMarketFees(
+			MarketType.PERP,
+			0,
+			notReferred
+		);
+
+		// base taker fee = 1/1000 = 0.001; referee discount = 25% -> 0.00075
+		assert(
+			Math.abs(baseTakerFee - 0.001) < 1e-12,
+			`expected base taker fee 0.001, got ${baseTakerFee}`
+		);
+		assert(
+			Math.abs(referredTakerFee - 0.00075) < 1e-12,
+			`expected discounted taker fee 0.00075, got ${referredTakerFee}`
+		);
+	});
+
+	// M11: the calculatePerpTakerFee marketIndex path (which delegates to
+	// getMarketFees) must now also reflect the referee discount.
+	it('calculatePerpTakerFee marketIndex path applies the referee discount', async () => {
+		const user = await makeFeeMockUser(ReferrerStatus.IsReferred);
+
+		const fee = user.calculatePerpTakerFee(new BN(1_000_000), 0);
+		// 1_000_000 * 0.00075 = 750
+		assert(
+			fee.eq(new BN(750)),
+			`expected discounted market-index fee 750, got ${fee.toString()}`
+		);
+	});
+
+	// M12: builder fee must be added by getMarketFees when orderParams carry a builder code.
+	it('getMarketFees adds the builder fee fraction to the taker fee', async () => {
+		const user = await makeFeeMockUser(0);
+
+		const { takerFee } = user.velocityClient.getMarketFees(
+			MarketType.PERP,
+			0,
+			user,
+			{ builderIdx: 0, builderFeeTenthBps: 10 }
+		);
+		// base 0.001 + builder 10/100_000 = 0.0001 -> 0.0011
+		assert(
+			Math.abs(takerFee - 0.0011) < 1e-12,
+			`expected taker fee incl. builder 0.0011, got ${takerFee}`
+		);
+	});
+
+	// M12: builder fee must also be applied by calculatePerpTakerFee on both
+	// the volume-tier branch and the marketIndex branch.
+	it('calculatePerpTakerFee adds the builder fee on the volume-tier branch', async () => {
+		const user = await makeFeeMockUser(0);
+
+		const fee = user.calculatePerpTakerFee(
+			new BN(1_000_000),
+			undefined,
+			false,
+			{ builderIdx: 0, builderFeeTenthBps: 10 }
+		);
+		// base 1000 + builderFee(1_000_000, 10) = 1_000_000*10/100_000 = 100 -> 1100
+		assert(
+			fee.eq(new BN(1100)),
+			`expected fee incl. builder 1100, got ${fee.toString()}`
+		);
+	});
+
+	it('calculatePerpTakerFee adds the builder fee on the marketIndex branch', async () => {
+		const user = await makeFeeMockUser(0);
+
+		const fee = user.calculatePerpTakerFee(new BN(1_000_000), 0, false, {
+			builderIdx: 0,
+			builderFeeTenthBps: 10,
+		});
+		// 1_000_000 * (0.001 + 0.0001) = 1100
+		assert(
+			fee.eq(new BN(1100)),
+			`expected market-index fee incl. builder 1100, got ${fee.toString()}`
+		);
+	});
+});
+
+describe('User canBypassWithdrawLimits', () => {
+	async function makeWithdrawMockUser(cumulativeDeposits: BN): Promise<User> {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const myMockSpotMarkets = _.cloneDeep(mockSpotMarkets);
+		const myMockUserAccount = _.cloneDeep(baseMockUserAccount);
+
+		// generous withdraw guard threshold so canBypass isn't gated on deposit size
+		myMockSpotMarkets[0].withdrawGuardThreshold = new BN(100_000).mul(
+			SPOT_MARKET_BALANCE_PRECISION
+		);
+
+		myMockUserAccount.totalDeposits = new BN(1000).mul(
+			SPOT_MARKET_BALANCE_PRECISION
+		);
+		myMockUserAccount.totalWithdraws = ZERO;
+		myMockUserAccount.spotPositions[0].balanceType = SpotBalanceType.DEPOSIT;
+		myMockUserAccount.spotPositions[0].scaledBalance = new BN(100).mul(
+			SPOT_MARKET_BALANCE_PRECISION
+		);
+		myMockUserAccount.spotPositions[0].cumulativeDeposits = cumulativeDeposits;
+
+		return makeMockUser(
+			myMockPerpMarkets,
+			myMockSpotMarkets,
+			myMockUserAccount,
+			[1, 1, 1, 1, 1, 1, 1, 1],
+			[1, 1, 1, 1, 1, 1, 1, 1]
+		);
+	}
+
+	it('can bypass when net deposits and cumulative deposits are both non-negative', async () => {
+		const user = await makeWithdrawMockUser(new BN(100));
+		const { canBypass } = user.canBypassWithdrawLimits(0);
+		assert(canBypass, 'expected canBypass to be true');
+	});
+
+	it('cannot bypass when cumulative deposits on the position are negative', async () => {
+		const user = await makeWithdrawMockUser(new BN(-1));
+		const { canBypass } = user.canBypassWithdrawLimits(0);
+		assert(
+			!canBypass,
+			'expected canBypass to be false with negative cumulativeDeposits'
+		);
+	});
+});