@wireio/stake 0.4.2 → 0.4.69

package/src/networks/ethereum/types.ts

@@ -1,27 +1,35 @@
 import { BigNumber, ethers } from 'ethers';
-import { BalanceView } from '../../types';
+import { BalanceView, ChainSymbol, WithdrawReceipt as UnifiedWithdrawReceipt } from '../../types';
 
 export const CONTRACT_NAMES = [
-    'Accounting',
-    'DepositManager',
-    'LiqEth',
-    'StakingModule',
-    'WithdrawalQueue',
-    'WithdrawalVault',
+    // LiqETH contracts
+    "LiqEthAuthority",
+    "BeaconState",
+    "WithdrawalQueue",
+    "LiqEthToken",
+    "Accounting",
+    "DepositManager",
+    "WithdrawalVault",
+    "StakingModule",
+    // "YieldOracle",
 
     //Outpost contracts
-    'Depositor',
-    'ReceiptNFT',
-    'OutpostManager',
-    'BAR',
-    'OPP',
-    'OPPCommon',
-    'OPPInbound',
-    'Pretoken',
-    'Aggregator',
-    'EthUsdPriceConsumer',
-    'Pool',
-
+    "OutpostManagerAuthority",
+    "iodata",
+    "Base58",
+    "sysio_merkle",
+    "ReceiptNFT",
+    "Pool",
+    "OutpostManager",
+    "sysio_write",
+    "EthUsdPriceConsumer",
+    "BAR",
+    "OPPCommon",
+    "OPP",
+    "Pretoken",
+    "OPPInbound",
+    "Depositor",
+    // "MockAggregator",
 ] as const;
 
 export type ContractName = typeof CONTRACT_NAMES[number];
@@ -82,7 +90,17 @@ export interface WithdrawnStakeEvent {
 export interface WithdrawnStakeResult extends Result {
     /** Parsed WithdrawnStake event, if present */
     withdrawnstake?: WithdrawnStakeEvent;
+}
 
+export interface DepositAndStakeResult extends Result {
+    /** Parsed Staked event, if present */
+    staked?: StakedEvent;
+}
+
+export interface DepositAndPurchaseResult extends Result {
+}
+
+export interface UnstakeAndWithdrawResult extends Result {
 }
 
 export interface SharesBurnedEvent {
@@ -91,15 +109,34 @@ export interface SharesBurnedEvent {
     tokenValue: BigNumber;
 }
 
+/**
+ * Legacy stake/pretoken receipt (kept for compatibility; not used in withdraw UI).
+ */
 export interface preLaunchReceipt {
     tokenId: bigint;
     receipt: {
-        account: string,
-        currency: number,
-        kind: number,
-        indexAtMint: BalanceView,
-        principal: BalanceView,
-        shares: BalanceView,
-        timestamp: string,
-    }
-}
+        account: string;
+        currency: number;
+        kind: number;
+        indexAtMint: BalanceView;
+        principal: BalanceView;
+        shares: BalanceView;
+        timestamp: string;
+    };
+}
+
+export interface ClaimedEvent {
+    user: string;
+    amount: BigNumber;
+}
+
+// Unified withdraw receipt type is defined centrally in src/types.ts
+export type WithdrawReceipt = UnifiedWithdrawReceipt;
+
+
+
+export interface ValidatorDepositedEvent {
+    sender: string;
+    amount: BigNumber;
+    shares: BigNumber
+}

package/src/networks/ethereum/utils.ts

@@ -111,53 +111,57 @@ export async function sendOPPFinalize(opp: ethers.Contract, gasLimit?: ethers.Bi
 }
 
 
+const BPS_DENOM = BigInt(10_000);
 
-/**
- * Apply one forward growth step: value * (BPS + growthBps) / BPS.
- * Simple integer round-half-up.
- */
-function growOnce(value: bigint, growthBps: number): bigint {
+// On-chain USD: 1e18 (wei-style)
+const USD_ONCHAIN_SCALE = BigInt(1_000_000_000_000_000_000); // 1e18
+// Client snapshot USD: 1e8 (to match fromScale8)
+const USD_CLIENT_SCALE = BigInt(100_000_000);                // 1e8
+// Factor to go from 1e18 → 1e8
+const USD_SCALE_DOWN = USD_ONCHAIN_SCALE / USD_CLIENT_SCALE; // 1e10
+
+/** 2.5% growth in BPS for supply side */
+function growSupplyOnce(value: bigint, growthBps: number): bigint {
     const g = BigInt(growthBps);
-    return (value * (BPS + g) + BPS / BigInt(2)) / BPS;
+    return (value * (BPS_DENOM + g)) / BPS_DENOM;
 }
 
-
-/**
- * Apply one backward step: value * BPS / (BPS + growthBps).
- * Also integer round-half-up.
- */
-function shrinkOnce(value: bigint, growthBps: number): bigint {
+function shrinkSupplyOnce(value: bigint, growthBps: number): bigint {
     const g = BigInt(growthBps);
-    return (value * BPS + (BPS + g) / BigInt(2)) / (BPS + g);
+    return (value * BPS_DENOM) / (BPS_DENOM + g);
 }
 
+/** Linear USD price step in on-chain 1e18 scale */
+function growPriceOnceUsd1e18(value: bigint, stepUsd1e18: bigint): bigint {
+    return value + stepUsd1e18;
+}
 
-/**
- * Calculate the full supply for a given tranche using BigInt math.
- * trancheNumber is 1-based (tranche 1 = startSupply)
- */
-function getTrancheSize(startSupply: bigint, supplyGrowthBps: number, trancheNumber: number): bigint {
-    let supply = startSupply;
-    for (let i = 0; i < trancheNumber; i++) {
-        supply = (supply * (BPS + BigInt(supplyGrowthBps)) + BPS / BigInt(2)) / BPS;
-    }
-    return supply;
+function shrinkPriceOnceUsd1e18(value: bigint, stepUsd1e18: bigint): bigint {
+    if (value <= stepUsd1e18) return BigInt(0);
+    return value - stepUsd1e18;
 }
 
+/** Convert on-chain 1e18 USD to client 1e8 USD */
+function usd1e18To1e8(raw: bigint): bigint {
+    // 1e18 / 1e8 = 1e10 factor difference
+    return raw / USD_SCALE_DOWN;
+}
 
 /**
- * Build a local tranche ladder around the current tranche
- * using only on-chain config + current state.
+ * Build a local tranche ladder around the current tranche.
  *
+ * Inside this function:
+ *  - `currentPriceUsd` and `priceGrowthCents` are treated as 1e18-scaled USD.
+ *  - Output `priceUsd` is 1e8-scaled USD (for fromScale8()).
  */
 export function buildEthereumTrancheLadder(options: {
     currentTranche: number;
-    totalTrancheSupply: bigint,
+    totalTrancheSupply: bigint;   // not used in local window, but kept for API parity
     initialTrancheSupply: bigint;
-    currentTrancheSupply: bigint;
-    currentPriceUsd: bigint;
-    supplyGrowthBps: number;
-    priceGrowthBps: number;
+    currentTrancheSupply: bigint; // remaining in current tranche (1e8 scale)
+    currentPriceUsd: bigint;      // 1e18 scale
+    priceGrowthCents: bigint;     // 1e18 step, e.g. $0.02 → 2e16
+    supplyGrowthBps: number;      // 250 = 2.5%
     windowBefore?: number;
     windowAfter?: number;
 }): TrancheLadderItem[] {
@@ -166,44 +170,50 @@ export function buildEthereumTrancheLadder(options: {
         initialTrancheSupply,
         currentTrancheSupply,
         currentPriceUsd,
+        priceGrowthCents,
         supplyGrowthBps,
-        priceGrowthBps,
         windowBefore = 5,
         windowAfter = 5,
     } = options;
 
     const startId = Math.max(0, currentTranche - windowBefore);
     const endId = currentTranche + windowAfter;
-    
-    //calculate total tranche size (e.g. 60,600 on tranche 2)
-    const currentTrancheSize = getTrancheSize(initialTrancheSupply, supplyGrowthBps, currentTranche);
 
-    const capacity = new Map<number, bigint>();
-    const price = new Map<number, bigint>();
+    const capacity = new Map<number, bigint>(); // 1e8 pre-token units
+    const priceUsd = new Map<number, bigint>(); // 1e18 USD
+
+    // Capacity at the current tranche derived from initial supply & BPS growth
+    let currentCap = initialTrancheSupply;
+    for (let i = 0; i < currentTranche; i++) {
+        currentCap = growSupplyOnce(currentCap, supplyGrowthBps);
+    }
 
-    // Seed current
-    capacity.set(currentTranche, currentTrancheSize);
-    price.set(currentTranche, currentPriceUsd);
+    capacity.set(currentTranche, currentCap);
+    priceUsd.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));
+        const prevPrice = priceUsd.get(id - 1)!;
+
+        capacity.set(id, growSupplyOnce(prevCap, supplyGrowthBps));
+        priceUsd.set(id, growPriceOnceUsd1e18(prevPrice, priceGrowthCents));
     }
 
     // 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 nextPrice = priceUsd.get(id + 1)!;
+
+        capacity.set(id, shrinkSupplyOnce(nextCap, supplyGrowthBps));
+        priceUsd.set(id, shrinkPriceOnceUsd1e18(nextPrice, priceGrowthCents));
     }
 
+    // Build ladder view
     const ladder: TrancheLadderItem[] = [];
     for (let id = startId; id <= endId; id++) {
         const cap = capacity.get(id)!;
+
         let sold: bigint;
         if (id < currentTranche) {
             sold = cap;
@@ -213,19 +223,21 @@ export function buildEthereumTrancheLadder(options: {
             sold = BigInt(0);
         }
 
+        const remaining = cap - sold;
+        const priceClientScale = usd1e18To1e8(priceUsd.get(id)!); // 1e8
+
         ladder.push({
             id,
             capacity: cap,
             sold,
-            remaining: cap - sold,
-            priceUsd: price.get(id)!,
+            remaining,
+            priceUsd: priceClientScale,
         });
     }
 
     return ladder;
 }
 
-
 /**
  * Turn raw liqsol_core accounts into a chain-agnostic TrancheSnapshot for SOL.
  * All math stays here; TokenClient just wires accounts + connection.
@@ -236,11 +248,11 @@ export async function buildEthereumTrancheSnapshot(options: {
     indexBn;
     trancheNumberBn;
     currentTrancheSupply;
-    tranchePriceWadBn;
+    tranchePriceUsdBn;
     totalTrancheSupply;
     initialTrancheSupply;
     supplyGrowthBps;
-    priceGrowthBps;
+    priceGrowthCents;  // BigNumber from contract (1e18 for $0.02)
     minPriceUsd;
     maxPriceUsd;
 
@@ -256,53 +268,73 @@ export async function buildEthereumTrancheSnapshot(options: {
         ladderWindowBefore,
         ladderWindowAfter,
 
-        totalSharesBn, 
-        indexBn, 
-        trancheNumberBn, 
-        currentTrancheSupply, 
-        tranchePriceWadBn, 
+        totalSharesBn,
+        indexBn,
+        trancheNumberBn,
+        currentTrancheSupply,
+        tranchePriceUsdBn,
         totalTrancheSupply,
         initialTrancheSupply,
         supplyGrowthBps,
-        priceGrowthBps,
-        minPriceUsd, 
+        priceGrowthCents,
+        minPriceUsd,
         maxPriceUsd,
     } = options;
 
+    // ---- BigNumber -> bigint conversions ----
+
+    // Shares: keep your prior behaviour (1e8 scale) via /1e10
+    const totalShares = BigInt(totalSharesBn.toString()) / BigInt(10_000_000_000); // 1e10
 
-    // convert default BigNumber to bigint for hub to handle, and partially convert from 1e18 to 1e8 for the hub
-    const totalShares = BigInt(totalSharesBn.toString()) / BigInt(1e10);
     const currentIndex = BigInt(indexBn.toString()); // RAY (1e27)
+
     const currentTranche = Number(trancheNumberBn.toString());
-    const currentPriceUsd = BigInt(tranchePriceWadBn.toString()) / BigInt(1e10); // 1e18 WAD
 
+    // Prices & step in 1e18 scale from contract
+    const currentPriceUsd1e18 = BigInt(tranchePriceUsdBn.toString());
+    const priceGrowthStepUsd1e18 = BigInt(priceGrowthCents.toString());
+
+    // Convert price step to “cents” number for snapshot:
+    // 1 USD = 1e18 → 1 cent = 1e16.
+    const priceGrowthCentsNumber = Number(
+        priceGrowthStepUsd1e18 / BigInt(10_000_000_000_000_000) // 1e16
+    );
+
+    // Pre-token supplies (already 1e8-ish scale on-chain)
+    const currentTrancheSupplyBig = BigInt(currentTrancheSupply.toString());
+    const totalTrancheSupplyBig = BigInt(totalTrancheSupply.toString());
+    const initialTrancheSupplyBig = BigInt(initialTrancheSupply.toString());
+
+    // UI-current price (1e8 scale)
+    const currentPriceUsd = currentPriceUsd1e18 / BigInt(10_000_000_000); // 1e10
+
+    // ---- Build ladder ----
 
     const ladder = buildEthereumTrancheLadder({
         currentTranche,
-        totalTrancheSupply,
-        initialTrancheSupply,
-        currentTrancheSupply,
-        currentPriceUsd,
+        totalTrancheSupply: totalTrancheSupplyBig,
+        initialTrancheSupply: initialTrancheSupplyBig,
+        currentTrancheSupply: currentTrancheSupplyBig,
+        currentPriceUsd: currentPriceUsd1e18,      // 1e18
+        priceGrowthCents: priceGrowthStepUsd1e18,  // 1e18 step
         supplyGrowthBps,
-        priceGrowthBps,
         windowBefore: ladderWindowBefore,
         windowAfter: ladderWindowAfter,
     });
 
-
     return {
         chainID,
         currentIndex,
         totalShares,
         currentTranche,
-        currentPriceUsd,
+        currentPriceUsd,                // 1e8
         supplyGrowthBps,
-        priceGrowthBps,
-        currentTrancheSupply,
-        initialTrancheSupply,
-        totalPretokensSold: totalTrancheSupply,
+        priceGrowthCents: priceGrowthCentsNumber, // <-- number as required
+        totalPretokensSold: totalTrancheSupplyBig,
+        currentTrancheSupply: currentTrancheSupplyBig,
+        initialTrancheSupply: initialTrancheSupplyBig,
         nativePriceUsd: ethPriceUsd,
         nativePriceTimestamp,
         ladder,
     };
-}
+}