@kehtus/proportion-sdk 0.1.1 → 0.1.3

package/src/__tests__/lifecycle.test.ts

@@ -1,231 +0,0 @@
-import { describe, it, expect, beforeAll } from "vitest";
-import { createPublicClient, createWalletClient, http, parseEther, type Address } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import { hyperEvm, ADDRESSES, HYPE_FOR_GAS } from "../constants.js";
-import { VaultModule } from "../vault.js";
-import { AccountModule } from "../account.js";
-import { FactoryModule } from "../factory.js";
-import { AccountState } from "../types.js";
-import { toUsdc } from "../utils.js";
-import "dotenv/config";
-
-// ── Config ───────────────────────────────────────────
-
-const PRIVATE_KEY = process.env.PRIVATE_KEY;
-if (!PRIVATE_KEY) throw new Error("PRIVATE_KEY required in .env for lifecycle tests");
-
-const RPC_URL = process.env.RPC_URL ?? hyperEvm.rpcUrls.default.http[0];
-
-// Test amounts — keep small
-const DEPOSIT_AMOUNT = toUsdc(200); // $200 USDC
-const ACCOUNT_SIZE = toUsdc(100); // $100 funded account
-const DRAWDOWN_BPS = 500; // 5%
-const DAILY_DD = false;
-
-// ── Setup ────────────────────────────────────────────
-
-const account = privateKeyToAccount(PRIVATE_KEY as `0x${string}`);
-
-const publicClient = createPublicClient({
-  chain: hyperEvm,
-  transport: http(RPC_URL),
-});
-
-const walletClient = createWalletClient({
-  account,
-  chain: hyperEvm,
-  transport: http(RPC_URL),
-});
-
-const addresses = {
-  vault: ADDRESSES.MAIN_VAULT as Address,
-  usdc: ADDRESSES.USDC as Address,
-};
-
-const vault = new VaultModule(publicClient, walletClient, hyperEvm, addresses);
-const acc = new AccountModule(publicClient, walletClient, hyperEvm);
-const factory = new FactoryModule(publicClient, ADDRESSES.FACTORY as Address);
-
-let fundedAccountAddress: Address | null = null;
-
-async function waitForTx(hash: `0x${string}`) {
-  const receipt = await publicClient.waitForTransactionReceipt({ hash, timeout: 60_000 });
-  if (receipt.status !== "success") {
-    throw new Error(`Transaction reverted: ${hash}`);
-  }
-  return receipt;
-}
-
-// ── Lifecycle (sequential) ───────────────────────────
-
-describe("lifecycle", { sequential: true }, () => {
-  // ── 1. Approve USDC ────────────────────────────────
-
-  it("1. approve USDC for vault", async () => {
-    const hash = await vault.approveUsdc(DEPOSIT_AMOUNT);
-    console.log(`  approve tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-  });
-
-  // ── 2. Deposit to vault ────────────────────────────
-
-  it("2. deposit USDC to vault", async () => {
-    const beforePos = await vault.getLPPosition(account.address);
-    const hash = await vault.deposit(DEPOSIT_AMOUNT);
-    console.log(`  deposit tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-
-    const afterPos = await vault.getLPPosition(account.address);
-    expect(afterPos.shares).toBeGreaterThan(beforePos.shares);
-    console.log(`  shares: ${beforePos.shares} → ${afterPos.shares}`);
-  });
-
-  // ── 3. Register builder ────────────────────────────
-
-  it("3. register as builder (skip if already registered)", async () => {
-    const info = await vault.getBuilderInfo(account.address);
-    if (info.active) {
-      console.log("  builder already registered, skipping");
-      return;
-    }
-
-    const hash = await vault.registerBuilder();
-    console.log(`  registerBuilder tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-
-    const after = await vault.getBuilderInfo(account.address);
-    expect(after.active).toBe(true);
-  });
-
-  // ── 4. Activate funded account ─────────────────────
-
-  it("4. activate funded account", async () => {
-    // Predict address first
-    fundedAccountAddress = await factory.predictAddress(account.address, account.address);
-    console.log(`  predicted account: ${fundedAccountAddress}`);
-
-    const hash = await vault.activateFunded({
-      trader: account.address,
-      accountSize: ACCOUNT_SIZE,
-      drawdownBps: DRAWDOWN_BPS,
-      dailyDrawdownEnabled: DAILY_DD,
-    });
-    console.log(`  activateFunded tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-  });
-
-  // ── 5. Read account details ────────────────────────
-
-  it("5. read created account details", async () => {
-    expect(fundedAccountAddress).not.toBeNull();
-
-    const details = await acc.getDetails(fundedAccountAddress!);
-    console.log(`  state: ${AccountState[details.state]}`);
-    console.log(`  accountSize: ${details.accountSize}`);
-    console.log(`  drawdownBps: ${details.drawdownBps}`);
-    console.log(`  owner: ${details.owner}`);
-
-    expect(details.state).toBe(AccountState.Active);
-    expect(details.owner.toLowerCase()).toBe(account.address.toLowerCase());
-    expect(details.accountSize).toBe(ACCOUNT_SIZE);
-    expect(details.drawdownBps).toBe(DRAWDOWN_BPS);
-    expect(details.dailyDrawdownEnabled).toBe(DAILY_DD);
-  });
-
-  // ── 6. Set API wallet ──────────────────────────────
-
-  it("6. set API wallet", async () => {
-    expect(fundedAccountAddress).not.toBeNull();
-
-    const newApiWallet = "0x0000000000000000000000000000000000000042" as Address;
-    const hash = await acc.setApiWallet(fundedAccountAddress!, newApiWallet);
-    console.log(`  setApiWallet tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-
-    const details = await acc.getDetails(fundedAccountAddress!);
-    expect(details.apiWallet.toLowerCase()).toBe(newApiWallet.toLowerCase());
-  });
-
-  // ── 7. Checkpoint (soft fail — 24h gate) ───────────
-
-  it("7. checkpoint (may revert if < 24h)", async () => {
-    expect(fundedAccountAddress).not.toBeNull();
-
-    try {
-      const hash = await acc.checkpoint(fundedAccountAddress!);
-      console.log(`  checkpoint tx: ${hash}`);
-      const receipt = await waitForTx(hash);
-      expect(receipt.status).toBe("success");
-    } catch (e: unknown) {
-      const msg = e instanceof Error ? e.message : String(e);
-      console.log(`  [EXPECTED] checkpoint reverted: ${msg.slice(0, 120)}`);
-      // Not a failure — time-gated operation
-    }
-  });
-
-  // ── 8. Initiate close ──────────────────────────────
-
-  it("8. initiate close", async () => {
-    expect(fundedAccountAddress).not.toBeNull();
-
-    const hash = await acc.initiateClose(fundedAccountAddress!);
-    console.log(`  initiateClose tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-
-    const state = await acc.getState(fundedAccountAddress!);
-    expect(state).toBe(AccountState.Closing);
-  });
-
-  // ── 9. Close and return (soft fail — open positions or orders may still block) ─
-
-  it("9. closeAndReturn (may revert if < 3 days)", async () => {
-    expect(fundedAccountAddress).not.toBeNull();
-
-    try {
-      const hash = await acc.closeAndReturn(fundedAccountAddress!);
-      console.log(`  closeAndReturn tx: ${hash}`);
-      const receipt = await waitForTx(hash);
-      expect(receipt.status).toBe("success");
-    } catch (e: unknown) {
-      const msg = e instanceof Error ? e.message : String(e);
-      console.log(`  [EXPECTED] closeAndReturn reverted (positions/orders still block return): ${msg.slice(0, 120)}`);
-    }
-  });
-
-  // ── 10. Finalize return (soft fail) ────────────────
-
-  it("10. finalizeReturn (may revert if not in Returning state)", async () => {
-    expect(fundedAccountAddress).not.toBeNull();
-
-    try {
-      const hash = await acc.finalizeReturn(fundedAccountAddress!);
-      console.log(`  finalizeReturn tx: ${hash}`);
-      const receipt = await waitForTx(hash);
-      expect(receipt.status).toBe("success");
-    } catch (e: unknown) {
-      const msg = e instanceof Error ? e.message : String(e);
-      console.log(`  [EXPECTED] finalizeReturn reverted: ${msg.slice(0, 120)}`);
-    }
-  });
-
-  // ── 11. Withdraw LP shares ─────────────────────────
-
-  it("11. withdraw LP shares", async () => {
-    const pos = await vault.getLPPosition(account.address);
-    if (pos.withdrawableShares === 0n) {
-      console.log("  no withdrawable shares, skipping");
-      return;
-    }
-
-    const hash = await vault.withdraw(pos.withdrawableShares);
-    console.log(`  withdraw tx: ${hash}`);
-    const receipt = await waitForTx(hash);
-    expect(receipt.status).toBe("success");
-  });
-});

package/src/__tests__/reads.test.ts

@@ -1,208 +0,0 @@
-import { describe, it, expect, beforeAll } from "vitest";
-import { createPublicClient, http, type Address } from "viem";
-import { hyperEvm, ADDRESSES } from "../constants.js";
-import { VaultModule } from "../vault.js";
-import { AccountModule } from "../account.js";
-import { FactoryModule } from "../factory.js";
-import { AccountState } from "../types.js";
-import { activationFee } from "../utils.js";
-
-// ── Setup ────────────────────────────────────────────
-
-const publicClient = createPublicClient({
-  chain: hyperEvm,
-  transport: http(hyperEvm.rpcUrls.default.http[0]),
-});
-
-const vault = new VaultModule(publicClient, undefined, hyperEvm, {
-  vault: ADDRESSES.MAIN_VAULT as Address,
-  usdc: ADDRESSES.USDC as Address,
-});
-
-const factory = new FactoryModule(publicClient, ADDRESSES.FACTORY as Address);
-const account = new AccountModule(publicClient, undefined, hyperEvm);
-
-// We'll find an existing account to test reads against
-let existingAccount: Address | null = null;
-
-beforeAll(async () => {
-  try {
-    const count = await factory.getAccountsCount();
-    if (count > 0n) {
-      const accounts = await factory.getAccounts(0n, 1n);
-      existingAccount = accounts[0];
-    }
-  } catch {
-    // factory enumeration may be unavailable on empty or unreachable networks
-  }
-});
-
-// ── Vault reads ──────────────────────────────────────
-
-describe("vault reads", () => {
-  it("getStats returns valid vault stats", async () => {
-    const stats = await vault.getStats();
-    expect(stats.totalAssets).toBeTypeOf("bigint");
-    expect(stats.sharePrice).toBeTypeOf("bigint");
-    expect(stats.utilizationBps).toBeTypeOf("bigint");
-    expect(stats.availableForAllocation).toBeTypeOf("bigint");
-    expect(stats.maxAccountSize).toBeTypeOf("bigint");
-    expect(stats.remainingCap).toBeTypeOf("bigint");
-    expect(typeof stats.paused).toBe("boolean");
-  });
-
-  it("getLPPosition returns zeroes for random address", async () => {
-    const pos = await vault.getLPPosition("0x0000000000000000000000000000000000000001");
-    expect(pos.shares).toBe(0n);
-    expect(pos.sharesValue).toBe(0n);
-  });
-
-  it("getAllowedPerps returns array of numbers", async () => {
-    const perps = await vault.getAllowedPerps();
-    expect(Array.isArray(perps)).toBe(true);
-    for (const p of perps) {
-      expect(typeof p).toBe("number");
-    }
-  });
-
-  it("isAllowedPerp returns boolean", async () => {
-    const result = await vault.isAllowedPerp(0);
-    expect(typeof result).toBe("boolean");
-  });
-
-  it("isPaused returns boolean", async () => {
-    const paused = await vault.isPaused();
-    expect(typeof paused).toBe("boolean");
-  });
-
-  it("calculateFee matches utils.activationFee (cross-validation)", async () => {
-    const size = 5_000_000_000n; // $5000 USDC (6-dec)
-    const bps = 500;
-
-    const stats = await vault.getStats();
-    const fm = stats.feeMultiplier;
-
-    const onChain = await vault.calculateFee(size, bps, false);
-    const local = activationFee(size, bps, false, fm);
-    expect(local).toBe(onChain);
-
-    const onChainDD = await vault.calculateFee(size, bps, true);
-    const localDD = activationFee(size, bps, true, fm);
-    expect(localDD).toBe(onChainDD);
-  });
-});
-
-// ── Factory reads ────────────────────────────────────
-
-describe("factory reads", () => {
-  it("getAccountsCount returns bigint >= 0", async () => {
-    const count = await factory.getAccountsCount();
-    expect(count).toBeTypeOf("bigint");
-    expect(count >= 0n).toBe(true);
-  });
-
-  it("getAccounts returns array of addresses", async () => {
-    const count = await factory.getAccountsCount();
-    if (count === 0n) return; // skip if no accounts
-
-    const accounts = await factory.getAccounts(0n, BigInt(Math.min(Number(count), 5)));
-    expect(Array.isArray(accounts)).toBe(true);
-    expect(accounts.length).toBeGreaterThan(0);
-    for (const addr of accounts) {
-      expect(addr).toMatch(/^0x[0-9a-fA-F]{40}$/);
-    }
-  });
-
-  it("predictAddress returns valid address", async () => {
-    const owner = "0x0000000000000000000000000000000000000001" as Address;
-    const builder = "0x0000000000000000000000000000000000000002" as Address;
-    const predicted = await factory.predictAddress(owner, builder);
-    expect(predicted).toMatch(/^0x[0-9a-fA-F]{40}$/);
-  });
-
-  it("getTraderBuilderNonce returns bigint", async () => {
-    const owner = "0x0000000000000000000000000000000000000001" as Address;
-    const builder = "0x0000000000000000000000000000000000000002" as Address;
-    const nonce = await factory.getTraderBuilderNonce(owner, builder);
-    expect(nonce).toBeTypeOf("bigint");
-  });
-});
-
-// ── Account reads ────────────────────────────────────
-
-describe("account reads", () => {
-  it("getDetails returns full structure for existing account", async () => {
-    if (!existingAccount) {
-      console.log("  [SKIP] no existing accounts on-chain");
-      return;
-    }
-
-    const details = await account.getDetails(existingAccount);
-    expect(details.address).toBe(existingAccount);
-    expect(details.owner).toMatch(/^0x[0-9a-fA-F]{40}$/);
-    expect(details.builder).toMatch(/^0x[0-9a-fA-F]{40}$/);
-    expect(details.accountSize).toBeTypeOf("bigint");
-    expect(typeof details.drawdownBps).toBe("number");
-    expect(typeof details.dailyDrawdownEnabled).toBe("boolean");
-    expect(typeof details.subscriptionFeeMultiplier).toBe("number");
-    expect(details.highWaterMark).toBeTypeOf("bigint");
-    expect(details.dayStartValue).toBeTypeOf("bigint");
-    expect(typeof details.checkpointIndex).toBe("number");
-    expect(typeof details.subscriptionCancelled).toBe("boolean");
-    expect(typeof details.isSubscriptionActive).toBe("boolean");
-    expect(typeof details.canWithdrawProfit).toBe("boolean");
-    expect(Array.isArray(details.checkpoints)).toBe(true);
-
-    // State should be a valid enum value
-    expect(details.state).toBeGreaterThanOrEqual(AccountState.Uninitialized);
-    expect(details.state).toBeLessThanOrEqual(AccountState.Closed);
-  });
-
-  it("getState returns valid enum", async () => {
-    if (!existingAccount) return;
-    const state = await account.getState(existingAccount);
-    expect(state).toBeGreaterThanOrEqual(AccountState.Uninitialized);
-    expect(state).toBeLessThanOrEqual(AccountState.Closed);
-  });
-
-  it("getTrailingFloor returns bigint", async () => {
-    if (!existingAccount) return;
-    const floor = await account.getTrailingFloor(existingAccount);
-    expect(floor).toBeTypeOf("bigint");
-  });
-
-  it("getDailyFloor returns bigint", async () => {
-    if (!existingAccount) return;
-    const floor = await account.getDailyFloor(existingAccount);
-    expect(floor).toBeTypeOf("bigint");
-  });
-
-  it("canWithdrawProfit returns boolean", async () => {
-    if (!existingAccount) return;
-    const can = await account.canWithdrawProfit(existingAccount);
-    expect(typeof can).toBe("boolean");
-  });
-
-  it("isSubscriptionActive returns boolean", async () => {
-    if (!existingAccount) return;
-    const active = await account.isSubscriptionActive(existingAccount);
-    expect(typeof active).toBe("boolean");
-  });
-
-  it("getCheckpoints returns array", async () => {
-    if (!existingAccount) return;
-    const checkpoints = await account.getCheckpoints(existingAccount);
-    expect(Array.isArray(checkpoints)).toBe(true);
-    for (const cp of checkpoints) {
-      expect(cp.accountValue).toBeTypeOf("bigint");
-      expect(typeof cp.timestamp).toBe("number");
-      expect(typeof cp.profitable).toBe("boolean");
-    }
-  });
-
-  it("getPendingWithdrawal returns struct", async () => {
-    if (!existingAccount) return;
-    const pw = await account.getPendingWithdrawal(existingAccount);
-    expect(pw.profit).toBeTypeOf("bigint");
-  });
-});

package/src/__tests__/utils.test.ts

@@ -1,245 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  activationFee,
-  subscriptionFee,
-  splitProfit,
-  trailingFloor,
-  dailyFloor,
-  isTrailingBreached,
-  isDailyBreached,
-  fromUsdc,
-  toUsdc,
-  from8Dec,
-  to8Dec,
-  toUsdc6,
-  formatUsd,
-  stateToLabel,
-  labelToState,
-} from "../utils.js";
-import { AccountState } from "../types.js";
-
-// ── Helpers ──────────────────────────────────────────
-
-const usdc = (n: number) => BigInt(n) * 1_000_000n; // 6-dec USDC
-const dec8 = (n: number) => BigInt(n) * 100_000_000n; // 8-dec internal
-
-// ── Decimal conversions ──────────────────────────────
-
-describe("decimal conversions", () => {
-  it("toUsdc converts number to 6-dec bigint", () => {
-    expect(toUsdc(100)).toBe(100_000_000n);
-    expect(toUsdc(0.5)).toBe(500_000n);
-    expect(toUsdc(5000)).toBe(5_000_000_000n);
-  });
-
-  it("fromUsdc converts 6-dec bigint to number", () => {
-    expect(fromUsdc(100_000_000n)).toBe(100);
-    expect(fromUsdc(500_000n)).toBe(0.5);
-  });
-
-  it("to8Dec scales 6-dec to 8-dec (*100)", () => {
-    expect(to8Dec(usdc(1000))).toBe(dec8(1000));
-  });
-
-  it("toUsdc6 scales 8-dec down to 6-dec (/100)", () => {
-    expect(toUsdc6(dec8(1000))).toBe(usdc(1000));
-  });
-
-  it("from8Dec converts 8-dec bigint to number", () => {
-    expect(from8Dec(dec8(5000))).toBe(5000);
-    expect(from8Dec(50_000_000n)).toBe(0.5);
-  });
-
-  it("roundtrip: toUsdc -> to8Dec -> toUsdc6", () => {
-    const original = toUsdc(1234);
-    const up = to8Dec(original);
-    const down = toUsdc6(up);
-    expect(down).toBe(original);
-  });
-});
-
-// ── Activation fee ───────────────────────────────────
-
-describe("activationFee", () => {
-  const FM = 120; // current contract feeMultiplier
-
-  it("$5000 account, 500bps, no daily DD → $300", () => {
-    // 5000 * 500 * 120 / 1_000_000 = 300
-    expect(activationFee(usdc(5000), 500, false, FM)).toBe(usdc(300));
-  });
-
-  it("$5000 account, 500bps, daily DD → $240", () => {
-    // 300 * 8000 / 10000 = 240 (20% discount)
-    expect(activationFee(usdc(5000), 500, true, FM)).toBe(usdc(240));
-  });
-
-  it("$10000 account, 1000bps, no daily DD → $1200", () => {
-    // 10000 * 1000 * 120 / 1_000_000 = 1200
-    expect(activationFee(usdc(10000), 1000, false, FM)).toBe(usdc(1200));
-  });
-
-  it("$10000 account, 1000bps, daily DD → $960", () => {
-    // 1200 * 8000 / 10000 = 960 (20% discount)
-    expect(activationFee(usdc(10000), 1000, true, FM)).toBe(usdc(960));
-  });
-
-  it("min params: $100 account, 500bps → $6", () => {
-    // 100 * 500 * 120 / 1_000_000 = 6
-    const fee = activationFee(usdc(100), 500, false, FM);
-    expect(fee).toBe(usdc(6));
-  });
-});
-
-// ── Subscription fee ─────────────────────────────────
-
-describe("subscriptionFee", () => {
-  const SFM = 150; // current contract subscriptionFeeMultiplier
-
-  it("$5000 account → $75/month", () => {
-    // 5000 * 150 / 10000 = 75
-    expect(subscriptionFee(usdc(5000), SFM)).toBe(usdc(75));
-  });
-
-  it("legacy signature is still accepted for compatibility", () => {
-    expect(subscriptionFee(usdc(5000), 500, true, SFM)).toBe(usdc(75));
-  });
-
-  it("$10000 account → $150/month", () => {
-    expect(subscriptionFee(usdc(10000), SFM)).toBe(usdc(150));
-  });
-});
-
-// ── Profit split ─────────────────────────────────────
-
-describe("splitProfit", () => {
-  it("$1000 profit → 80% owner, 7% protocol, 13% vault", () => {
-    const { owner, vault, protocol } = splitProfit(usdc(1000));
-    expect(owner).toBe(usdc(800));
-    expect(protocol).toBe(usdc(70));
-    expect(vault).toBe(usdc(130));
-  });
-
-  it("sum of parts equals total", () => {
-    const profit = usdc(7777);
-    const { owner, vault, protocol } = splitProfit(profit);
-    expect(owner + vault + protocol).toBe(profit);
-  });
-
-  it("zero profit", () => {
-    const { owner, vault, protocol } = splitProfit(0n);
-    expect(owner).toBe(0n);
-    expect(vault).toBe(0n);
-    expect(protocol).toBe(0n);
-  });
-
-  it("small profit — rounding goes to vault (remainder)", () => {
-    // $1 = 1_000_000
-    // owner = 1_000_000 * 8000 / 10000 = 800_000
-    // protocol = 1_000_000 * 700 / 10000 = 70_000
-    // vault = 1_000_000 - 800_000 - 70_000 = 130_000
-    const { owner, vault, protocol } = splitProfit(usdc(1));
-    expect(owner).toBe(800_000n);
-    expect(protocol).toBe(70_000n);
-    expect(vault).toBe(130_000n);
-  });
-});
-
-// ── Drawdown floors ──────────────────────────────────
-
-describe("trailingFloor", () => {
-  it("500bps = 5% drawdown from HWM", () => {
-    const hwm = dec8(10000); // $10,000 in 8-dec
-    expect(trailingFloor(hwm, 500)).toBe(dec8(9500));
-  });
-
-  it("1000bps = 10% drawdown", () => {
-    const hwm = dec8(5000);
-    expect(trailingFloor(hwm, 1000)).toBe(dec8(4500));
-  });
-});
-
-describe("dailyFloor", () => {
-  it("500bps → daily = 250bps = 2.5% from day start", () => {
-    const dsv = dec8(10000);
-    // dailyBps = 500 / 2 = 250
-    // floor = 10000 - 10000 * 250 / 10000 = 10000 - 250 = 9750
-    expect(dailyFloor(dsv, 500)).toBe(dec8(9750));
-  });
-
-  it("1000bps → daily = 500bps = 5%", () => {
-    const dsv = dec8(10000);
-    expect(dailyFloor(dsv, 1000)).toBe(dec8(9500));
-  });
-});
-
-describe("breach checks", () => {
-  const hwm = dec8(10000);
-  const dsv = dec8(10000);
-
-  it("isTrailingBreached — below floor → true", () => {
-    expect(isTrailingBreached(dec8(9499), hwm, 500)).toBe(true);
-  });
-
-  it("isTrailingBreached — at floor → false", () => {
-    expect(isTrailingBreached(dec8(9500), hwm, 500)).toBe(false);
-  });
-
-  it("isTrailingBreached — above floor → false", () => {
-    expect(isTrailingBreached(dec8(9501), hwm, 500)).toBe(false);
-  });
-
-  it("isDailyBreached — below floor → true", () => {
-    expect(isDailyBreached(dec8(9749), dsv, 500)).toBe(true);
-  });
-
-  it("isDailyBreached — at floor → false", () => {
-    expect(isDailyBreached(dec8(9750), dsv, 500)).toBe(false);
-  });
-});
-
-// ── Enum mapping ─────────────────────────────────────
-
-describe("state enum mapping", () => {
-  it("stateToLabel maps all states", () => {
-    expect(stateToLabel(AccountState.Uninitialized)).toBe("UNINITIALIZED");
-    expect(stateToLabel(AccountState.Active)).toBe("ACTIVE");
-    expect(stateToLabel(AccountState.Closing)).toBe("CLOSING");
-    expect(stateToLabel(AccountState.Closed)).toBe("CLOSED");
-    expect(stateToLabel(AccountState.WithdrawalPending)).toBe("WITHDRAWAL_PENDING");
-    expect(stateToLabel(AccountState.Returning)).toBe("RETURNING");
-    expect(stateToLabel(AccountState.Initialized)).toBe("INITIALIZED");
-  });
-
-  it("labelToState reverses correctly", () => {
-    expect(labelToState("UNINITIALIZED")).toBe(AccountState.Uninitialized);
-    expect(labelToState("ACTIVE")).toBe(AccountState.Active);
-    expect(labelToState("CLOSED")).toBe(AccountState.Closed);
-    expect(labelToState("CLOSING")).toBe(AccountState.Closing);
-  });
-
-  it("roundtrip: state → label → state", () => {
-    for (const state of [
-      AccountState.Initialized,
-      AccountState.Active,
-      AccountState.WithdrawalPending,
-      AccountState.Closing,
-      AccountState.Returning,
-      AccountState.Closed,
-    ]) {
-      expect(labelToState(stateToLabel(state))).toBe(state);
-    }
-  });
-});
-
-// ── formatUsd ────────────────────────────────────────
-
-describe("formatUsd", () => {
-  it("formats 6-dec bigint as USD", () => {
-    expect(formatUsd(usdc(1000))).toBe("$1,000.00");
-    expect(formatUsd(usdc(0))).toBe("$0.00");
-  });
-
-  it("formats with custom decimals", () => {
-    expect(formatUsd(dec8(5000), 8)).toBe("$5,000.00");
-  });
-});