@wireio/stake 0.2.3 → 0.2.4

package/src/networks/solana/utils.ts

@@ -1,5 +1,3 @@
-// src/networks/solana/utils.ts
-
 import { Program, BN, AnchorProvider } from '@coral-xyz/anchor';
 
 import {
@@ -52,7 +50,213 @@ import {
 
 import liqsolCoreIDL from '../../assets/solana/idl/liqsol_core.json';
 import { LiqsolCore } from '../../assets/solana/types/liqsol_core';
-import { TrancheState } from './types';
+import { GlobalState, TrancheState } from './types';
+import { TrancheLadderItem, TrancheSnapshot } from '../../types';
+import { ChainID } from '@wireio/core';
+
+
+// -----------------------------------------------------------------------------
+// Tranche Support
+// -----------------------------------------------------------------------------
+
+
+const INDEX_SCALE = BigInt(1_000_000_000_000); // 1e12
+const USD_SCALE = BigInt(100_000_000);         // 1e8
+const BPS = BigInt(10_000);
+
+/** BN | bigint -> bigint helper (keeps code readable) */
+export function toBigint(x: any): bigint {
+    if (typeof x === 'bigint') return x;
+    if (typeof x === 'number') return BigInt(x);
+    // Anchor BN
+    return BigInt(x.toString());
+}
+
+/**
+ * Convert token amount -> shares using the same rule as on-chain tests:
+ * shares = ceil(amount * INDEX_SCALE / currentIndex)
+ */
+export function tokensToShares(amount: bigint, currentIndex: bigint): bigint {
+    if (amount === BigInt(0)) return BigInt(0);
+    const num = amount * INDEX_SCALE;
+    const q = num / currentIndex;
+    const r = num % currentIndex;
+    return r === BigInt(0) ? q : q + BigInt(1);
+}
+
+/**
+ * Apply one forward growth step: value * (BPS + growthBps) / BPS.
+ * Simple integer round-half-up.
+ */
+function growOnce(value: bigint, growthBps: number): bigint {
+    const g = BigInt(growthBps);
+    return (value * (BPS + g) + BPS / BigInt(2)) / BPS;
+}
+
+/**
+ * Apply one backward step: value * BPS / (BPS + growthBps).
+ * Also integer round-half-up.
+ */
+function shrinkOnce(value: bigint, growthBps: number): bigint {
+    const g = BigInt(growthBps);
+    return (value * BPS + (BPS + g) / BigInt(2)) / (BPS + g);
+}
+
+/**
+ * Build a local tranche ladder around the current tranche
+ * using only on-chain config + current state.
+ *
+ * Rules (from liqsol_core tests):
+ *  - past tranches are fully sold
+ *  - current tranche has (initial - currentSupply) sold
+ *  - future tranches start with 0 sold
+ *  - supply/price grow by supplyGrowthBps/priceGrowthBps per tranche
+ */
+export function buildSolanaTrancheLadder(options: {
+    currentTranche: number;
+    initialTrancheSupply: bigint;
+    currentTrancheSupply: bigint;
+    totalWarrantsSold: bigint; // informational only
+    currentPriceUsd: bigint;
+    supplyGrowthBps: number;
+    priceGrowthBps: number;
+    windowBefore?: number;
+    windowAfter?: number;
+}): TrancheLadderItem[] {
+    const {
+        currentTranche,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore = 5,
+        windowAfter = 5,
+    } = options;
+
+    const startId = Math.max(0, currentTranche - windowBefore);
+    const endId = currentTranche + windowAfter;
+
+    const capacity = new Map<number, bigint>();
+    const price = new Map<number, bigint>();
+
+    // Seed current
+    capacity.set(currentTranche, initialTrancheSupply);
+    price.set(currentTranche, currentPriceUsd);
+
+    // Forward (future tranches)
+    for (let id = currentTranche + 1; id <= endId; id++) {
+        const prevCap = capacity.get(id - 1)!;
+        const prevPrice = price.get(id - 1)!;
+        capacity.set(id, growOnce(prevCap, supplyGrowthBps));
+        price.set(id, growOnce(prevPrice, priceGrowthBps));
+    }
+
+    // Backward (past tranches)
+    for (let id = currentTranche - 1; id >= startId; id--) {
+        const nextCap = capacity.get(id + 1)!;
+        const nextPrice = price.get(id + 1)!;
+        capacity.set(id, shrinkOnce(nextCap, supplyGrowthBps));
+        price.set(id, shrinkOnce(nextPrice, priceGrowthBps));
+    }
+
+    const ladder: TrancheLadderItem[] = [];
+    for (let id = startId; id <= endId; id++) {
+        const cap = capacity.get(id)!;
+        let sold: bigint;
+        if (id < currentTranche) {
+            sold = cap;
+        } else if (id === currentTranche) {
+            sold = cap - currentTrancheSupply;
+        } else {
+            sold = BigInt(0);
+        }
+
+        ladder.push({
+            id,
+            capacity: cap,
+            sold,
+            remaining: cap - sold,
+            priceUsd: price.get(id)!,
+        });
+    }
+
+    return ladder;
+}
+
+/**
+ * Turn raw liqsol_core accounts into a chain-agnostic TrancheSnapshot for SOL.
+ * All math stays here; TokenClient just wires accounts + connection.
+ */
+export function buildSolanaTrancheSnapshot(options: {
+    chainID: ChainID;
+    globalState: GlobalState;
+    trancheState: TrancheState;
+    solPriceUsd?: bigint;
+    nativePriceTimestamp?: number;
+    ladderWindowBefore?: number;
+    ladderWindowAfter?: number;
+}): TrancheSnapshot {
+    const {
+        chainID,
+        globalState,
+        trancheState,
+        solPriceUsd,
+        nativePriceTimestamp,
+        ladderWindowBefore,
+        ladderWindowAfter,
+    } = options;
+
+    const currentIndex = toBigint(globalState.currentIndex);
+    const totalShares = toBigint(globalState.totalShares);
+
+    const currentTranche = trancheState.currentTrancheNumber.toNumber();
+    const currentTrancheSupply = toBigint(trancheState.currentTrancheSupply);
+    const initialTrancheSupply = toBigint(trancheState.initialTrancheSupply);
+    const totalWarrantsSold = toBigint(trancheState.totalWarrantsSold);
+    const currentPriceUsd = toBigint(trancheState.currentTranchePriceUsd);
+
+    const supplyGrowthBps = trancheState.supplyGrowthBps;
+    const priceGrowthBps = trancheState.priceGrowthBps;
+
+    const minPriceUsd = trancheState.minPriceUsd
+        ? toBigint(trancheState.minPriceUsd)
+        : undefined;
+    const maxPriceUsd = trancheState.maxPriceUsd
+        ? toBigint(trancheState.maxPriceUsd)
+        : undefined;
+
+    const ladder = buildSolanaTrancheLadder({
+        currentTranche,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        totalWarrantsSold,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore: ladderWindowBefore,
+        windowAfter: ladderWindowAfter,
+    });
+
+    return {
+        chainID,
+        currentIndex,
+        totalShares,
+        currentTranche,
+        currentPriceUsd,
+        minPriceUsd,
+        maxPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        currentTrancheSupply,
+        initialTrancheSupply,
+        totalWarrantsSold,
+        nativePriceUsd: solPriceUsd,
+        nativePriceTimestamp,
+        ladder,
+    };
+}
+
 
 // -----------------------------------------------------------------------------
 // Read-only liqsol_core Program helper
@@ -367,10 +571,10 @@ export async function buildOutpostAccounts(
     // Chainlink program feeds
     let chainLinkFeed = CHAINLINK_FEED;
     let chainLinkProgram = CHAINLINK_PROGRAM
-    
+
     try {
         const program = getLiqsolCoreProgram(connection);
-        const ts : TrancheState = await program.account.trancheState.fetch(trancheState);
+        const ts: TrancheState = await program.account.trancheState.fetch(trancheState);
         if (ts.chainlinkFeed && ts.chainlinkProgram) {
             chainLinkFeed = ts.chainlinkFeed as PublicKey;
             chainLinkProgram = ts.chainlinkProgram as PublicKey;

package/src/types.ts

@@ -30,7 +30,11 @@ export interface IStakingClient {
      *  - `TrancheSnapshot` when the chain supports pretoken/tranches
      *  - `null` if this chain has no WIRE/pretoken integration
      */
-    getTrancheSnapshot(): Promise<TrancheSnapshot | null>;
+    getTrancheSnapshot(options?: {
+        chainID?: ChainID;
+        windowBefore?: number;
+        windowAfter?: number;
+    }): Promise<TrancheSnapshot | null>;
 
     /**  */
     getBuyQuote(amount: bigint, asset: PurchaseAsset): Promise<PurchaseQuote>;
@@ -51,7 +55,7 @@ export interface Portfolio {
     /** Extra PDAs and account addresses */
     extras?: Record<string, any>;
     /** Chain ID of the network for which this portfolio is from */
-    chainID: ChainID; 
+    chainID: ChainID;
 }
 
 export type BalanceView = {
@@ -61,45 +65,79 @@ export type BalanceView = {
     ata?: SolPubKey; // associated token account address
 };
 
+export interface TrancheLadderItem {
+    /** On-chain tranche id, 0-based (0,1,2,...) */
+    id: number;
+    /** Total capacity for this tranche (pretokens, 1e8 scale) */
+    capacity: bigint;
+    /** Sold amount in this tranche (1e8 scale) */
+    sold: bigint;
+    /** Remaining = capacity - sold (1e8 scale) */
+    remaining: bigint;
+    /** Price for this tranche in USD (1e8 scale) */
+    priceUsd: bigint;
+}
+
 /**
- * Program-global prelaunch WIRE / tranche state for a single chain.
- *
- * All integer values are raw on-chain integers:
- *  - `currentTranchePriceUsd`: 1e8 USD
- *  - supplies / warrants / shares: 1e8 WIRE units (per liqsol_core/ETH analog)
- *  - index: same scale the program uses (INDEX_SCALE = 1e12 on Solana today)
+ * Unified pretoken/tranche snapshot for any chain.
+ * ETH / other chains just fill the same shape from their own contracts.
  */
 export interface TrancheSnapshot {
     chainID: ChainID;
 
-    // From GlobalState
-    totalShares: bigint;      // globalState.totalShares
-    currentIndex: bigint;     // globalState.currentIndex
+    /** Global share index (1e12 on Sol today; other chains can use their own scale) */
+    currentIndex: bigint;
+    /** Total accounting shares (wire pretoken “shares”) */
+    totalShares: bigint;
+
+    /** Current tranche id as stored on chain (0-based) */
+    currentTranche: number;
+
+    /** Current tranche price in USD (1e8 scale) */
+    currentPriceUsd: bigint;
+    /** Optional min/max bounds for price validation (1e8 scale) */
+    minPriceUsd?: bigint;
+    maxPriceUsd?: bigint;
+
+    /** Tranche curve config (per-chain) */
+    supplyGrowthBps: number; // e.g. 100 = +1% per tranche
+    priceGrowthBps: number;  // e.g. 200 = +2% per tranche
 
-    // From TrancheState
-    currentTrancheNumber: bigint;     // trancheState.currentTrancheNumber
-    currentTrancheSupply: bigint;     // trancheState.currentTrancheSupply
-    totalWarrantsSold: bigint;        // trancheState.totalWarrantsSold
-    currentTranchePriceUsd: bigint;   // trancheState.currentTranchePriceUsd (1e8)
+    /** Current tranche supply state (1e8 scale) */
+    currentTrancheSupply: bigint;   // remaining in current tranche
+    initialTrancheSupply: bigint;   // capacity for current tranche
+    totalWarrantsSold: bigint;      // global cumulative sold (all tranches), 1e8
+
+    /** Native token → USD price if available (SOL/USD, ETH/USD, etc, 1e8 scale) */
+    nativePriceUsd?: bigint;
+    /** Optional timestamp (sec) for the last recorded native price */
+    nativePriceTimestamp?: number;
+
+    /**
+     * Local window of tranche “rows” centered around current.
+     * Used directly by the frontend for ladder graphs.
+     */
+    ladder: TrancheLadderItem[];
 }
 
-// Enum describing which asset is being used to buy pretoken
+/** Purchase asset selection used by staking client(s) */
 export enum PurchaseAsset {
-    SOL = "SOL",
-    LIQSOL = "LIQSOL",
-    ETH = "ETH",
-    LIQETH = "LIQETH",
-    YIELD = "YIELD",
+    SOL = 'SOL',
+    LIQSOL = 'LIQSOL',
+    ETH = 'ETH',
+    LIQETH = 'LIQETH',
+    YIELD = 'YIELD',
 }
 
 export interface PurchaseQuote {
     purchaseAsset: PurchaseAsset;
-    amountIn: bigint;          // smallest unit (lamports / wei / token units)
-    // share info (prelaunch WIRE)
-    wireShares: bigint;        // 1e8 precision
-    wireDecimals: number;      // always 8
-    // pricing info
-    wirePriceUsd: bigint;      // 1e8 precision
-    notionalUsd: bigint;       // 1e8 precision
-}
+    amountIn: bigint;       // lamports / wei / token units
+
+    /** Expected pretoken “shares” (pretokens) and decimals */
+    wireShares: bigint;     // 1e8 scale
+    wireDecimals: number;   // always 8 for now
 
+    /** Current price + notional in USD (1e8 scale) */
+    wirePriceUsd: bigint;
+    notionalUsd: bigint;
+}