@kehtus/proportion-sdk 0.1.1 → 0.1.3

package/src/account.ts

@@ -1,325 +0,0 @@
-import type { Address, Chain, Hash, PublicClient, WalletClient } from "viem";
-import { fundedAccountAbi } from "./abi/fundedAccount.js";
-import { AccountState, type AccountDetails } from "./types.js";
-
-type RawCheckpoint = {
-  accountValue: bigint | number;
-  timestamp: bigint | number;
-  profitable: boolean;
-};
-
-export function normalizeCheckpoints(
-  rawCheckpoints: readonly RawCheckpoint[],
-  totalCheckpoints: number,
-  checkpointIndex: number,
-): Array<{ accountValue: bigint; timestamp: number; profitable: boolean }> {
-  if (totalCheckpoints <= 0) return [];
-
-  const count = Math.min(totalCheckpoints, rawCheckpoints.length);
-  const start = count === rawCheckpoints.length ? checkpointIndex % count : 0;
-
-  return Array.from({ length: count }, (_, offset) => rawCheckpoints[(start + offset) % count]).map((cp) => ({
-    accountValue: BigInt(cp.accountValue),
-    timestamp: Number(cp.timestamp),
-    profitable: cp.profitable,
-  }));
-}
-
-export class AccountModule {
-  constructor(
-    private publicClient: PublicClient,
-    private walletClient: WalletClient | undefined,
-    private chain: Chain,
-  ) {}
-
-  // ── READS ───────────────────────────────────────────
-
-  async getDetails(account: Address): Promise<AccountDetails> {
-    const contract = { address: account, abi: fundedAccountAbi } as const;
-    const results = await this.publicClient.multicall({
-      contracts: [
-        { ...contract, functionName: "state" },
-        { ...contract, functionName: "owner" },
-        { ...contract, functionName: "builder" },
-        { ...contract, functionName: "accountSize" },
-        { ...contract, functionName: "drawdownBps" },
-        { ...contract, functionName: "dailyDrawdownEnabled" },
-        { ...contract, functionName: "subscriptionFeeMultiplier" },
-        { ...contract, functionName: "highWaterMark" },
-        { ...contract, functionName: "dayStartValue" },
-        { ...contract, functionName: "activatedAt" },
-        { ...contract, functionName: "subscriptionPaidUntil" },
-        { ...contract, functionName: "subscriptionCancelled" },
-        { ...contract, functionName: "pendingSubscriptionFee" },
-        { ...contract, functionName: "apiWallet" },
-        { ...contract, functionName: "checkpointIndex" },
-        { ...contract, functionName: "profitableDaysCount" },
-        { ...contract, functionName: "totalCheckpoints" },
-        { ...contract, functionName: "lastCheckpointDay" },
-        { ...contract, functionName: "closingInitiatedAt" },
-        { ...contract, functionName: "returnInitiatedAt" },
-        { ...contract, functionName: "pendingWithdrawal" },
-        { ...contract, functionName: "getTrailingFloor" },
-        { ...contract, functionName: "getDailyFloor" },
-        { ...contract, functionName: "getSubscriptionFee" },
-        { ...contract, functionName: "isSubscriptionActive" },
-        { ...contract, functionName: "canWithdrawProfit" },
-        { ...contract, functionName: "getAllCheckpoints" },
-      ],
-    });
-
-    const checkpointIndex = results[14].result!;
-    const totalCp = results[16].result!;
-    const profit = results[20].result! as bigint;
-    const rawCheckpoints = results[26].result!;
-    const checkpoints = normalizeCheckpoints(rawCheckpoints, totalCp, checkpointIndex);
-
-    return {
-      address: account,
-      state: results[0].result! as AccountState,
-      owner: results[1].result!,
-      builder: results[2].result!,
-      accountSize: results[3].result!,
-      drawdownBps: results[4].result!,
-      dailyDrawdownEnabled: results[5].result!,
-      subscriptionFeeMultiplier: results[6].result!,
-      highWaterMark: results[7].result!,
-      dayStartValue: results[8].result!,
-      activatedAt: results[9].result!,
-      subscriptionPaidUntil: results[10].result!,
-      subscriptionCancelled: results[11].result!,
-      pendingSubscriptionFee: results[12].result!,
-      apiWallet: results[13].result!,
-      checkpointIndex,
-      profitableDaysCount: results[15].result!,
-      totalCheckpoints: totalCp,
-      lastCheckpointDay: results[17].result!,
-      closingInitiatedAt: Number(results[18].result!),
-      returnInitiatedAt: Number(results[19].result!),
-      pendingWithdrawal: { profit },
-      trailingFloor: results[21].result!,
-      dailyFloor: results[22].result!,
-      subscriptionFee: results[23].result!,
-      isSubscriptionActive: results[24].result!,
-      canWithdrawProfit: results[25].result!,
-      checkpoints,
-    };
-  }
-
-  async getState(account: Address): Promise<AccountState> {
-    const raw = await this.publicClient.readContract({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "state",
-    });
-    return raw as AccountState;
-  }
-
-  async getTrailingFloor(account: Address): Promise<bigint> {
-    return this.publicClient.readContract({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "getTrailingFloor",
-    });
-  }
-
-  async getDailyFloor(account: Address): Promise<bigint> {
-    return this.publicClient.readContract({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "getDailyFloor",
-    });
-  }
-
-  async canWithdrawProfit(account: Address): Promise<boolean> {
-    return this.publicClient.readContract({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "canWithdrawProfit",
-    });
-  }
-
-  async isSubscriptionActive(account: Address): Promise<boolean> {
-    return this.publicClient.readContract({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "isSubscriptionActive",
-    });
-  }
-
-  async getCheckpoints(
-    account: Address,
-  ): Promise<Array<{ accountValue: bigint; timestamp: number; profitable: boolean }>> {
-    const [all, total, checkpointIndex] = await Promise.all([
-      this.publicClient.readContract({
-        address: account,
-        abi: fundedAccountAbi,
-        functionName: "getAllCheckpoints",
-      }),
-      this.publicClient.readContract({
-        address: account,
-        abi: fundedAccountAbi,
-        functionName: "totalCheckpoints",
-      }),
-      this.publicClient.readContract({
-        address: account,
-        abi: fundedAccountAbi,
-        functionName: "checkpointIndex",
-      }),
-    ]);
-    return normalizeCheckpoints(all, Number(total), Number(checkpointIndex));
-  }
-
-  async getPendingWithdrawal(account: Address): Promise<{ profit: bigint }> {
-    const profit = await this.publicClient.readContract({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "pendingWithdrawal",
-    }) as bigint;
-    return { profit };
-  }
-
-  async getAccountConfig(account: Address): Promise<{
-    usdc: Address;
-    vault: Address;
-    subscriptionFeeMultiplier: number;
-  }> {
-    const contract = { address: account, abi: fundedAccountAbi } as const;
-    const results = await this.publicClient.multicall({
-      contracts: [
-        { ...contract, functionName: "usdc" },
-        { ...contract, functionName: "vault" },
-        { ...contract, functionName: "subscriptionFeeMultiplier" },
-      ],
-    });
-    return {
-      usdc: results[0].result!,
-      vault: results[1].result!,
-      subscriptionFeeMultiplier: results[2].result!,
-    };
-  }
-
-  // ── 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);
-  }
-
-  // ── OWNER WRITES ────────────────────────────────────
-
-  async setApiWallet(account: Address, wallet: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "setApiWallet",
-      args: [wallet],
-    });
-  }
-
-  async requestWithdrawProfit(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "requestWithdrawProfit",
-    });
-  }
-
-  async cancelSubscription(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "cancelSubscription",
-    });
-  }
-
-  // ── PERMISSIONLESS WRITES ───────────────────────────
-
-  async checkpoint(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "checkpoint",
-    });
-  }
-
-  async initiateClose(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "initiateClose",
-    });
-  }
-
-  async initiateCloseForPerp(account: Address, perpIndex: number): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "initiateClose",
-      args: [perpIndex],
-    });
-  }
-
-  async initiateCloseAdmin(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "initiateCloseAdmin",
-    });
-  }
-
-  async closeAndReturn(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "closeAndReturn",
-    });
-  }
-
-  async bridgeToEvm(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "bridgeToEvm",
-    });
-  }
-
-  async finalizeReturn(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "finalizeReturn",
-    });
-  }
-
-  async claimWithdrawal(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "claimWithdrawal",
-    });
-  }
-
-  async claimSubscriptionFee(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "claimSubscriptionFee",
-    });
-  }
-
-  async rescueStuckFunds(account: Address): Promise<Hash> {
-    return this.write({
-      address: account,
-      abi: fundedAccountAbi,
-      functionName: "rescueStuckFunds",
-    });
-  }
-
-}

package/src/constants.ts

@@ -1,51 +0,0 @@
-import type { Chain } from "viem";
-
-export const CHAIN_ID = 999;
-
-export const hyperEvm = {
-  id: 999,
-  name: "HyperEVM",
-  nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
-  rpcUrls: { default: { http: ["https://rpc.hyperliquid.xyz/evm"] } },
-  contracts: {
-    multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" },
-  },
-} as const satisfies Chain;
-
-export const ADDRESSES = {
-  MAIN_VAULT: "0xA89F85eC9350e64295B199ee8011454d891e19B1",
-  FACTORY: "0xE056F0D2A476CCd9A24230C7DB7c9d6AF44a0161",
-  FORWARDER: "0x4fDc2489dE19BECC9FAeA59672F377bf740E4ecF",
-  USDC: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
-} as const;
-
-// BPS
-export const BPS = 10_000n;
-export const MIN_DRAWDOWN_BPS = 500;
-export const MAX_DRAWDOWN_BPS = 2500;
-export const DAILY_DD_DISCOUNT_BPS = 2000n;
-export const PROTOCOL_FEE_BPS = 1000n;
-export const OWNER_PROFIT_BPS = 8000n;
-export const PROTOCOL_PROFIT_BPS = 700n;
-export const BUILDER_LEVERAGE = 10n;
-export const MAX_UTILIZATION_BPS = 8000n;
-export const MAX_SINGLE_ACCOUNT_BPS = 1000n;
-export const HYPE_FOR_GAS = 1_000_000_000_000_000n; // 0.001 ether
-
-// Decimals
-export const USDC_DECIMALS = 6;
-export const ACCOUNT_VALUE_DECIMALS = 8; // spotBalance, spotSend
-export const DECIMALS_MULTIPLIER = 100n; // 6dec→8dec (used for spotSend conversion)
-// Note: accountValue, HWM, dayStartValue, floors are all 6dec (accountMarginSummary returns 6dec)
-
-// Time (seconds)
-export const SUBSCRIPTION_PERIOD = 30 * 86400;
-export const BRIDGE_DELAY = 30;
-export const CLOSING_TIMEOUT = 3 * 86400;
-export const CHECKPOINT_INTERVAL = 86400;
-
-// Trading rules
-export const TRADING_DAYS_REQUIRED = 7;
-export const PROFITABLE_DAYS_REQUIRED = 3;
-export const MIN_PROFIT_BPS = 50;
-export const MAX_LEVERAGE = 5;

package/src/factory.ts

@@ -1,157 +0,0 @@
-import type { Address, PublicClient } from "viem";
-import { factoryAbi } from "./abi/factory.js";
-
-export class FactoryModule {
-  constructor(
-    private publicClient: PublicClient,
-    private factoryAddress: Address,
-  ) {}
-
-  private isOutOfBoundsError(error: unknown): boolean {
-    const message = error instanceof Error ? error.message : String(error);
-    return /out of bounds|execution reverted|returned no data|position out of bounds/i.test(message);
-  }
-
-  private async accountExistsAt(index: bigint): Promise<boolean> {
-    try {
-      await this.getAccountAt(index);
-      return true;
-    } catch (error) {
-      if (this.isOutOfBoundsError(error)) return false;
-      throw error;
-    }
-  }
-
-  async predictAddress(owner: Address, builder: Address): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.factoryAddress,
-      abi: factoryAbi,
-      functionName: "predictFundedAccountAddress",
-      args: [owner, builder],
-    });
-  }
-
-  async getAccountAt(index: bigint): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.factoryAddress,
-      abi: factoryAbi,
-      functionName: "allAccounts",
-      args: [index],
-    });
-  }
-
-  async getAccountIndex(account: Address): Promise<bigint> {
-    return this.publicClient.readContract({
-      address: this.factoryAddress,
-      abi: factoryAbi,
-      functionName: "allAccountsIndex",
-      args: [account],
-    });
-  }
-
-  async hasAccount(account: Address): Promise<boolean> {
-    try {
-      const index = await this.getAccountIndex(account);
-      const candidate = await this.getAccountAt(index);
-      return candidate.toLowerCase() === account.toLowerCase();
-    } catch {
-      return false;
-    }
-  }
-
-  async findAccountIndex(account: Address): Promise<bigint | null> {
-    const index = await this.getAccountIndex(account);
-    const candidate = await this.getAccountAt(index).catch(() => null);
-    if (!candidate || candidate.toLowerCase() !== account.toLowerCase()) return null;
-    return index;
-  }
-
-  async getTraderBuilderNonce(owner: Address, builder: Address): Promise<bigint> {
-    return this.publicClient.readContract({
-      address: this.factoryAddress,
-      abi: factoryAbi,
-      functionName: "traderBuilderNonce",
-      args: [owner, builder],
-    });
-  }
-
-  async getAccountsCount(maxScan: bigint = 10_000n): Promise<bigint> {
-    if (!(await this.accountExistsAt(0n))) return 0n;
-
-    let lo = 0n;
-    let hi = 1n;
-
-    while (hi < maxScan && await this.accountExistsAt(hi)) {
-      lo = hi;
-      hi *= 2n;
-    }
-
-    if (hi >= maxScan && await this.accountExistsAt(hi)) {
-      throw new Error(`Factory account count exceeds scan limit ${maxScan}`);
-    }
-
-    while (lo + 1n < hi) {
-      const mid = (lo + hi) / 2n;
-      if (await this.accountExistsAt(mid)) {
-        lo = mid;
-      } else {
-        hi = mid;
-      }
-    }
-
-    return lo + 1n;
-  }
-
-  async getAccounts(offset: bigint, limit: bigint): Promise<Address[]> {
-    if (limit <= 0n) return [];
-
-    const contracts = [];
-    for (let i = 0n; i < limit; i++) {
-      contracts.push({
-        address: this.factoryAddress,
-        abi: factoryAbi,
-        functionName: "allAccounts",
-        args: [offset + i],
-      } as const);
-    }
-
-    const results = await this.publicClient.multicall({
-      contracts,
-      allowFailure: true,
-    });
-
-    const accounts: Address[] = [];
-    for (const result of results) {
-      if (result.status !== "success") break;
-      accounts.push(result.result);
-    }
-    return accounts;
-  }
-
-  async getConfig(): Promise<{
-    implementation: Address;
-    owner: Address;
-    pendingOwner: Address;
-    usdc: Address;
-    vault: Address;
-  }> {
-    const contract = { address: this.factoryAddress, abi: factoryAbi } as const;
-    const results = await this.publicClient.multicall({
-      contracts: [
-        { ...contract, functionName: "implementation" },
-        { ...contract, functionName: "owner" },
-        { ...contract, functionName: "pendingOwner" },
-        { ...contract, functionName: "usdc" },
-        { ...contract, functionName: "vault" },
-      ],
-    });
-
-    return {
-      implementation: results[0].result!,
-      owner: results[1].result!,
-      pendingOwner: results[2].result!,
-      usdc: results[3].result!,
-      vault: results[4].result!,
-    };
-  }
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-// Main
-export { ProportionSDK } from "./sdk.js";
-
-// Modules
-export { VaultModule } from "./vault.js";
-export { AccountModule } from "./account.js";
-export { FactoryModule } from "./factory.js";
-export { IndexerModule } from "./indexer.js";
-
-// Core
-export * from "./types.js";
-export * from "./constants.js";
-export * from "./utils.js";
-export { mainVaultAbi } from "./abi/mainVault.js";
-export { fundedAccountAbi } from "./abi/fundedAccount.js";
-export { factoryAbi } from "./abi/factory.js";