@kehtus/proportion-sdk 0.1.0

package/src/vault.ts

@@ -0,0 +1,479 @@
+import type { Address, Chain, Hash, PublicClient, WalletClient } from "viem";
+import { mainVaultAbi } from "./abi/mainVault.js";
+import type { BuilderInfo, LPPosition, VaultStats } from "./types.js";
+
+const erc20Abi = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+  },
+] as const;
+
+export class VaultModule {
+  constructor(
+    private publicClient: PublicClient,
+    private walletClient: WalletClient | undefined,
+    private chain: Chain,
+    private addresses: { vault: Address; usdc: Address },
+  ) {}
+
+  // ── READS ───────────────────────────────────────────
+
+  async getStats(): Promise<VaultStats> {
+    const contract = { address: this.addresses.vault, abi: mainVaultAbi } as const;
+    const results = await this.publicClient.multicall({
+      contracts: [
+        { ...contract, functionName: "totalAssets" },
+        { ...contract, functionName: "sharePrice" },
+        { ...contract, functionName: "getUtilizationBps" },
+        { ...contract, functionName: "getAvailableForAllocation" },
+        { ...contract, functionName: "getMaxAccountSize" },
+        { ...contract, functionName: "getRemainingCap" },
+        { ...contract, functionName: "paused" },
+        { ...contract, functionName: "feeMultiplier" },
+        { ...contract, functionName: "subscriptionFeeMultiplier" },
+        { ...contract, functionName: "totalShares" },
+        { ...contract, functionName: "totalAllocated" },
+        { ...contract, functionName: "owner" },
+        { ...contract, functionName: "pendingOwner" },
+        { ...contract, functionName: "relayer" },
+        { ...contract, functionName: "protocolFeeReceiver" },
+        { ...contract, functionName: "maxCap" },
+        { ...contract, functionName: "hypeForSpot" },
+        { ...contract, functionName: "factory" },
+        { ...contract, functionName: "MIN_BUILDER_SHARES" },
+        { ...contract, functionName: "BUILDER_LEVERAGE" },
+        { ...contract, functionName: "PROTOCOL_FEE_BPS" },
+        { ...contract, functionName: "MIN_ACCOUNT_SIZE" },
+        { ...contract, functionName: "MAX_ACCOUNT_SIZE" },
+        { ...contract, functionName: "MIN_DRAWDOWN_BPS" },
+        { ...contract, functionName: "MAX_DRAWDOWN_BPS" },
+        { ...contract, functionName: "MAX_UTILIZATION_BPS" },
+        { ...contract, functionName: "MAX_SINGLE_ACCOUNT_BPS" },
+        { ...contract, functionName: "DAILY_DD_DISCOUNT_BPS" },
+      ],
+    });
+    return {
+      totalAssets: results[0].result!,
+      sharePrice: results[1].result!,
+      utilizationBps: results[2].result!,
+      availableForAllocation: results[3].result!,
+      maxAccountSize: results[4].result!,
+      remainingCap: results[5].result!,
+      paused: results[6].result!,
+      feeMultiplier: results[7].result!,
+      subscriptionFeeMultiplier: results[8].result!,
+      totalShares: results[9].result!,
+      totalAllocated: results[10].result!,
+      owner: results[11].result!,
+      pendingOwner: results[12].result!,
+      relayer: results[13].result!,
+      protocolFeeReceiver: results[14].result!,
+      maxCap: results[15].result!,
+      hypeForSpot: results[16].result!,
+      factory: results[17].result!,
+      minBuilderShares: results[18].result!,
+      builderLeverage: results[19].result!,
+      protocolFeeBps: results[20].result!,
+      minAccountSize: results[21].result!,
+      maxAccountSizeLimit: results[22].result!,
+      minDrawdownBps: results[23].result!,
+      maxDrawdownBps: results[24].result!,
+      maxUtilizationBps: results[25].result!,
+      maxSingleAccountBps: results[26].result!,
+      dailyDdDiscountBps: results[27].result!,
+    };
+  }
+
+  async getLPPosition(account: Address): Promise<LPPosition> {
+    const contract = { address: this.addresses.vault, abi: mainVaultAbi } as const;
+    const results = await this.publicClient.multicall({
+      contracts: [
+        { ...contract, functionName: "shares", args: [account] },
+        { ...contract, functionName: "sharesValue", args: [account] },
+        { ...contract, functionName: "withdrawableShares", args: [account] },
+      ],
+    });
+    return {
+      shares: results[0].result!,
+      sharesValue: results[1].result!,
+      withdrawableShares: results[2].result!,
+    };
+  }
+
+  async getBuilderInfo(builder: Address): Promise<BuilderInfo> {
+    const contract = { address: this.addresses.vault, abi: mainVaultAbi } as const;
+    const results = await this.publicClient.multicall({
+      contracts: [
+        { ...contract, functionName: "builders", args: [builder] },
+        { ...contract, functionName: "builderAvailableFunded", args: [builder] },
+      ],
+    });
+    const [active, activeFunded] = results[0].result!;
+    return {
+      active,
+      activeFunded,
+      availableFunded: results[1].result!,
+    };
+  }
+
+  async getAllowedPerps(): Promise<number[]> {
+    const result = await this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "getAllowedPerps",
+    });
+    return result.map(Number);
+  }
+
+  async isAllowedPerp(index: number): Promise<boolean> {
+    return this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "isAllowedPerp",
+      args: [index],
+    });
+  }
+
+  async calculateFee(size: bigint, bps: number, dailyDD: boolean): Promise<bigint> {
+    return this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "calculateActivationFee",
+      args: [size, bps, dailyDD],
+    });
+  }
+
+  async isPaused(): Promise<boolean> {
+    return this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "paused",
+    });
+  }
+
+  async getRemainingCap(): Promise<bigint> {
+    return this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "getRemainingCap",
+    });
+  }
+
+  async isFundedAccount(account: Address): Promise<boolean> {
+    return this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "isFundedAccount",
+      args: [account],
+    });
+  }
+
+  async getDelegateBuilder(delegate: Address): Promise<Address> {
+    return this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "delegateBuilder",
+      args: [delegate],
+    });
+  }
+
+  // ── WRITES ──────────────────────────────────────────
+
+  private requireWallet(): WalletClient {
+    if (!this.walletClient) throw new Error("WalletClient required for write operations");
+    return this.walletClient;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private async write(params: Record<string, unknown>): Promise<Hash> {
+    const wallet = this.requireWallet();
+    return wallet.writeContract({ chain: this.chain, ...params } as any);
+  }
+
+  async deposit(amount: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "deposit",
+      args: [amount],
+    });
+  }
+
+  async withdraw(shares: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "withdraw",
+      args: [shares],
+    });
+  }
+
+  async approveUsdc(amount: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.usdc,
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [this.addresses.vault, amount],
+    });
+  }
+
+  async registerBuilder(): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "registerBuilder",
+    });
+  }
+
+  async setDelegate(delegate: Address): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setDelegate",
+      args: [delegate],
+    });
+  }
+
+  async removeDelegate(delegate: Address): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "removeDelegate",
+      args: [delegate],
+    });
+  }
+
+  async activateFunded(p: {
+    trader: Address;
+    accountSize: bigint;
+    drawdownBps: number;
+    dailyDrawdownEnabled: boolean;
+    hypeValue?: bigint;
+  }): Promise<Hash> {
+    const hypeValue = p.hypeValue ?? await this.publicClient.readContract({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "hypeForSpot",
+    });
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "activateFunded",
+      args: [p.trader, p.accountSize, p.drawdownBps, p.dailyDrawdownEnabled],
+      value: hypeValue,
+    });
+  }
+
+  // ── ADMIN ───────────────────────────────────────────
+
+  async pause(): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "pause",
+    });
+  }
+
+  async unpause(): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "unpause",
+    });
+  }
+
+  async addAllowedPerp(index: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "addAllowedPerp",
+      args: [index],
+    });
+  }
+
+  async removeAllowedPerp(index: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "removeAllowedPerp",
+      args: [index],
+    });
+  }
+
+  async setRelayer(addr: Address): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setRelayer",
+      args: [addr],
+    });
+  }
+
+  async setFactory(addr: Address): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setFactory",
+      args: [addr],
+    });
+  }
+
+  async setProtocolFeeReceiver(addr: Address): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setProtocolFeeReceiver",
+      args: [addr],
+    });
+  }
+
+  async transferOwnership(newOwner: Address): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "transferOwnership",
+      args: [newOwner],
+    });
+  }
+
+  async acceptOwnership(): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "acceptOwnership",
+    });
+  }
+
+  async setFeeMultiplier(value: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setFeeMultiplier",
+      args: [value],
+    });
+  }
+
+  async setSubscriptionFeeMultiplier(value: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setSubscriptionFeeMultiplier",
+      args: [value],
+    });
+  }
+
+  async setHypeForSpot(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setHypeForSpot",
+      args: [value],
+    });
+  }
+
+  async setMaxCap(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMaxCap",
+      args: [value],
+    });
+  }
+
+  async setMinBuilderShares(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMinBuilderShares",
+      args: [value],
+    });
+  }
+
+  async setBuilderLeverage(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setBuilderLeverage",
+      args: [value],
+    });
+  }
+
+  async setProtocolFeeBps(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setProtocolFeeBps",
+      args: [value],
+    });
+  }
+
+  async setMinAccountSize(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMinAccountSize",
+      args: [value],
+    });
+  }
+
+  async setMaxAccountSize(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMaxAccountSize",
+      args: [value],
+    });
+  }
+
+  async setMinDrawdownBps(value: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMinDrawdownBps",
+      args: [value],
+    });
+  }
+
+  async setMaxDrawdownBps(value: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMaxDrawdownBps",
+      args: [value],
+    });
+  }
+
+  async setMaxUtilizationBps(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMaxUtilizationBps",
+      args: [value],
+    });
+  }
+
+  async setMaxSingleAccountBps(value: bigint): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setMaxSingleAccountBps",
+      args: [value],
+    });
+  }
+
+  async setDailyDdDiscountBps(value: number): Promise<Hash> {
+    return this.write({
+      address: this.addresses.vault,
+      abi: mainVaultAbi,
+      functionName: "setDailyDdDiscountBps",
+      args: [value],
+    });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    testTimeout: 120_000,
+    hookTimeout: 120_000,
+  },
+});