@kehtus/proportion-sdk 0.1.0

package/src/__tests__/indexer.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { IndexerModule } from "../indexer.js";
+import "dotenv/config";
+
+// ── Setup ────────────────────────────────────────────
+
+const GRAPHQL_URL = process.env.GRAPHQL_URL;
+if (!GRAPHQL_URL) throw new Error("GRAPHQL_URL required in .env for indexer tests");
+
+const indexer = new IndexerModule(GRAPHQL_URL);
+
+// We'll find an existing account address from the indexer to test detail queries
+let existingAccountId: string | null = null;
+let existingOwner: string | null = null;
+let activeVaultId: string | null = null;
+let activeFactoryId: string | null = null;
+
+beforeAll(async () => {
+  try {
+    const protocol = await indexer.getProtocolConfig();
+    if (protocol) {
+      activeVaultId = protocol.vaultAddress;
+      activeFactoryId = protocol.factoryAddress;
+    }
+  } catch {
+    // protocol config may be unavailable on older indexers
+  }
+
+  try {
+    const accounts = await indexer.getAccountsByState("ACTIVE");
+    if (accounts.length > 0) {
+      existingAccountId = accounts[0].id;
+      existingOwner = accounts[0].owner;
+    }
+  } catch {
+    // indexer may have no active accounts
+  }
+});
+
+// ── Protocol ───────────────────────────────────────
+
+describe("indexer: protocol", () => {
+  it("getProtocolConfig returns deployment pointer or null", async () => {
+    const protocol = await indexer.getProtocolConfig();
+    if (!protocol) {
+      console.log("  [SKIP] no ProtocolConfig entity in indexer yet");
+      return;
+    }
+    expect(protocol.id).toBeTruthy();
+    expect(protocol.vaultAddress).toBeTruthy();
+    expect(protocol.factoryAddress).toBeTruthy();
+  });
+});
+
+// ── Vault ────────────────────────────────────────────
+
+describe("indexer: vault", () => {
+  it("getVault returns vault data or null", async () => {
+    const vault = await indexer.getVault();
+    if (!vault) {
+      console.log("  [SKIP] no Vault entity in indexer yet");
+      return;
+    }
+    expect(vault.id).toBeTruthy();
+    expect(vault.address).toBeTruthy();
+    expect(typeof vault.totalAccountsActivated).toBe("number");
+    expect(typeof vault.paused).toBe("boolean");
+    expect(typeof vault.totalAccountsActive).toBe("number");
+    expect(vault).toHaveProperty("cumulativeProtocolFeesRouted");
+    expect(vault).toHaveProperty("cumulativeRescuedFunds");
+  });
+});
+
+// ── Accounts ─────────────────────────────────────────
+
+describe("indexer: accounts", () => {
+  it("getAccountsByState returns array", async () => {
+    const accounts = await indexer.getAccountsByState("ACTIVE");
+    expect(Array.isArray(accounts)).toBe(true);
+    if (accounts.length > 0) {
+      expect(accounts[0].state).toBe("ACTIVE");
+      expect(accounts[0].id).toBeTruthy();
+      expect(accounts[0].owner).toBeTruthy();
+    }
+  });
+
+  it("getAccountsByStates returns array", async () => {
+    const accounts = await indexer.getAccountsByStates(["ACTIVE", "CLOSING"]);
+    expect(Array.isArray(accounts)).toBe(true);
+    for (const acc of accounts) {
+      expect(["ACTIVE", "CLOSING"]).toContain(acc.state);
+    }
+  });
+
+  it("getAccount returns single account or null", async () => {
+    if (!existingAccountId) {
+      console.log("  [SKIP] no existing accounts");
+      return;
+    }
+    const acc = await indexer.getAccount(existingAccountId);
+    expect(acc).not.toBeNull();
+    expect(acc!.id).toBe(existingAccountId);
+    expect(acc!.owner).toBeTruthy();
+    expect(acc!.vaultAddress).toBeTruthy();
+    expect(acc!.factoryAddress).toBeTruthy();
+    expect(typeof acc!.drawdownBps).toBe("number");
+    expect(typeof acc!.dailyDrawdownEnabled).toBe("boolean");
+    expect(acc).toHaveProperty("closePendingSubFee");
+    expect(acc).toHaveProperty("closePendingProfit");
+  });
+
+  it("getAccountsByOwner returns accounts", async () => {
+    if (!existingOwner) {
+      console.log("  [SKIP] no existing owner");
+      return;
+    }
+    const accounts = await indexer.getAccountsByOwner(existingOwner);
+    expect(Array.isArray(accounts)).toBe(true);
+    expect(accounts.length).toBeGreaterThan(0);
+    expect(accounts[0].owner.toLowerCase()).toBe(existingOwner.toLowerCase());
+  });
+});
+
+// ── History ──────────────────────────────────────────
+
+describe("indexer: history", () => {
+  it("getCheckpoints returns array", async () => {
+    if (!existingAccountId) return;
+    const checkpoints = await indexer.getCheckpoints(existingAccountId);
+    expect(Array.isArray(checkpoints)).toBe(true);
+    if (checkpoints.length > 0) {
+      expect(checkpoints[0].dayNumber).toBeTruthy();
+      expect(typeof checkpoints[0].profitable).toBe("boolean");
+    }
+  });
+
+  it("getWithdrawals returns array", async () => {
+    if (!existingAccountId) return;
+    const withdrawals = await indexer.getWithdrawals(existingAccountId);
+    expect(Array.isArray(withdrawals)).toBe(true);
+  });
+
+  it("getSubscriptionPayments returns array", async () => {
+    if (!existingAccountId) return;
+    const payments = await indexer.getSubscriptionPayments(existingAccountId);
+    expect(Array.isArray(payments)).toBe(true);
+  });
+
+  it("getEvents returns array", async () => {
+    if (!existingAccountId) return;
+    const events = await indexer.getEvents(existingAccountId);
+    expect(Array.isArray(events)).toBe(true);
+    if (events.length > 0) {
+      expect(events[0].eventType).toBeTruthy();
+      expect(events[0].txHash).toBeTruthy();
+    }
+  });
+
+  it("getEventsByType returns array", async () => {
+    const events = await indexer.getEventsByType("Initialized", 5);
+    expect(Array.isArray(events)).toBe(true);
+  });
+});
+
+// ── LP ───────────────────────────────────────────────
+
+describe("indexer: LP", () => {
+  it("getLP returns null for unknown address", async () => {
+    const lp = await indexer.getLP("0x0000000000000000000000000000000000000001");
+    expect(lp).toBeNull();
+  });
+
+  it("getLPDeposits returns array", async () => {
+    if (!existingOwner) return;
+    const deposits = await indexer.getLPDeposits(existingOwner);
+    expect(Array.isArray(deposits)).toBe(true);
+  });
+
+  it("getLPWithdrawals returns array", async () => {
+    if (!existingOwner) return;
+    const withdrawals = await indexer.getLPWithdrawals(existingOwner);
+    expect(Array.isArray(withdrawals)).toBe(true);
+  });
+
+  it("getLPDayData returns array", async () => {
+    const dayData = await indexer.getLPDayData(existingOwner ?? "0x0000000000000000000000000000000000000001");
+    expect(Array.isArray(dayData)).toBe(true);
+  });
+});
+
+// ── Builder ──────────────────────────────────────────
+
+describe("indexer: builder", () => {
+  it("getBuilder returns null for unknown address", async () => {
+    const builder = await indexer.getBuilder("0x0000000000000000000000000000000000000001");
+    expect(builder).toBeNull();
+  });
+
+  it("getDelegates returns array", async () => {
+    if (!existingOwner) return;
+    const delegates = await indexer.getDelegates(existingOwner);
+    expect(Array.isArray(delegates)).toBe(true);
+  });
+});
+
+// ── Config ───────────────────────────────────────────
+
+describe("indexer: config", () => {
+  it("getMainVaultConfig returns config or null", async () => {
+    if (!activeVaultId) {
+      console.log("  [SKIP] no active vault in ProtocolConfig");
+      return;
+    }
+    const config = await indexer.getMainVaultConfig(activeVaultId);
+    expect(config).not.toBeNull();
+    expect(config!.vaultAddress.toLowerCase()).toBe(activeVaultId.toLowerCase());
+    expect(typeof config!.subscriptionFeeMultiplier).toBe("number");
+  });
+
+  it("getFactoryConfig returns config or null", async () => {
+    if (!activeFactoryId) {
+      console.log("  [SKIP] no active factory in ProtocolConfig");
+      return;
+    }
+    const config = await indexer.getFactoryConfig(activeFactoryId);
+    expect(config).not.toBeNull();
+    expect(config!.factoryAddress.toLowerCase()).toBe(activeFactoryId.toLowerCase());
+  });
+
+  it("getConfigChanges returns array", async () => {
+    const changes = await indexer.getConfigChanges({
+      contractAddress: activeVaultId ?? undefined,
+      limit: 5,
+    });
+    expect(Array.isArray(changes)).toBe(true);
+  });
+
+  it("getAllowedPerps returns array", async () => {
+    const perps = await indexer.getAllowedPerps();
+    expect(Array.isArray(perps)).toBe(true);
+    if (perps.length > 0) {
+      expect(typeof perps[0].perpIndex).toBe("number");
+      expect(perps[0].allowed).toBe(true);
+    }
+  });
+
+  it("getVaultDayData returns array", async () => {
+    const days = await indexer.getVaultDayData(activeVaultId ?? undefined, { limit: 5 });
+    expect(Array.isArray(days)).toBe(true);
+    if (days.length > 0) {
+      expect(typeof days[0].dayNumber).toBe("number");
+      expect(days[0].totalAssets).toBeTruthy();
+    }
+  });
+});

package/src/__tests__/lifecycle.test.ts

@@ -0,0 +1,231 @@
+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

@@ -0,0 +1,209 @@
+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");
+    expect(typeof pw.requestedAt).toBe("number");
+  });
+});