@wireio/stake 0.5.2 → 0.7.0

package/src/networks/solana/solana.ts

@@ -482,6 +482,46 @@ export class SolanaStakingClient implements IStakingClient {
     // READ-ONLY Public Methods
     // ---------------------------------------------------------------------
 
+    /**
+     * Unified, chain-agnostic tranche snapshot for Solana.
+     *
+     * Uses:
+     *  - liqsol_core.globalState (currentIndex, totalShares, etc.)
+     *  - liqsol_core.trancheState (price, supply, total sold, etc.)
+     *  - PriceHistory/Chainlink SOL/USD via TokenClient.getSolPriceUsdSafe()
+     *
+     * This is READ-ONLY and works even with no connected wallet.
+     */
+    async getTrancheSnapshot(options?: {
+        chainID?: ChainID;
+        windowBefore?: number;
+        windowAfter?: number;
+    }): Promise<TrancheSnapshot> {
+        const {
+            chainID = SolChainID.WireTestnet,
+            windowBefore,
+            windowAfter,
+        } = options ?? {};
+
+        const [globalState, trancheState] = await Promise.all([
+            this.tokenClient.fetchGlobalState(),
+            this.tokenClient.fetchTrancheState(),
+        ]);
+
+        const { price: solPriceUsd, timestamp } =
+            await this.tokenClient.getSolPriceUsdSafe();
+
+        return buildSolanaTrancheSnapshot({
+            chainID,
+            globalState,
+            trancheState,
+            solPriceUsd,
+            nativePriceTimestamp: timestamp,
+            ladderWindowBefore: windowBefore,
+            ladderWindowAfter: windowAfter,
+        });
+    }
+
     /**
      * Returns the system APY (percent) for Solana,
      * using compound interest per epoch and a
@@ -490,19 +530,12 @@ export class SolanaStakingClient implements IStakingClient {
     async getSystemAPY(): Promise<number> {
         // 1) Per-epoch rate (decimal) from on-chain stakeMetrics
         const ratePerEpoch = await this.getEpochRateDecimalFromProgram();
-        console.log('epochRateDecimal', ratePerEpoch);
-
         // 2) Live epochs-per-year estimate from cluster
         const epochsPerYear = await this.getEpochsPerYearFromCluster();
-        console.log('epochsPerYear', epochsPerYear);
-
         // 3) Compound: (1 + r)^N - 1
         const apyDecimal = Math.pow(1 + ratePerEpoch, epochsPerYear) - 1;
-        console.log('apyDecimal', apyDecimal);
-
         // 4) Convert to percent
         const apyPercent = apyDecimal * 100;
-        console.log('apyPercent', apyPercent);
 
         return apyPercent;
     }
@@ -524,9 +557,6 @@ export class SolanaStakingClient implements IStakingClient {
         // Convert to JS number in **decimal per epoch** units
         const rateDecimal = Number(raw) / Number(PAY_RATE_SCALE_FACTOR);
 
-        console.log('solSystemPayRate(raw)', raw.toString());
-        console.log('epochRateDecimal(computed)', rateDecimal);
-
         return rateDecimal;
     }
 
@@ -643,112 +673,145 @@ export class SolanaStakingClient implements IStakingClient {
     }
 
     /**
-     * Unified, chain-agnostic tranche snapshot for Solana.
+     * Compute a conservative "deposit buffer" in lamports that should be left
+     * in the wallet so that a MAX deposit (balance - buffer) will succeed.
      *
-     * Uses:
-     *  - liqsol_core.globalState (currentIndex, totalShares, etc.)
-     *  - liqsol_core.trancheState (price, supply, total sold, etc.)
-     *  - PriceHistory/Chainlink SOL/USD via TokenClient.getSolPriceUsdSafe()
+     * It accounts for:
+     *   - Runtime tx fees (via a dummy self-transfer)
+     *   - Protocol deposit fee (via getDepositFee(amount))
      *
-     * This is READ-ONLY and works even with no connected wallet.
+     * Intended UI usage:
+     *   const buffer = await client.getDepositBuffer();
+     *   const balance = portfolio.native.amount;
+     *   const maxDeposit = balance > buffer ? balance - buffer : BigInt(0);
      */
-    async getTrancheSnapshot(options?: {
-        chainID?: ChainID;
-        windowBefore?: number;
-        windowAfter?: number;
-    }): Promise<TrancheSnapshot> {
-        const {
-            chainID = SolChainID.WireTestnet,
-            windowBefore,
-            windowAfter,
-        } = options ?? {};
+    async getDepositBuffer(options?: {
+        txCount?: number;                 // how many txs to cover in gas buffer (default 2)
+        safetyMultiplier?: number;        // safety multiplier on per-tx fee (default 3x)
+        minBufferLamports?: bigint;       // minimum gas buffer (default ~0.01 SOL)
+        balanceOverrideLamports?: bigint; // for tests/custom callers
+    }): Promise<bigint> {
+        this.ensureUser();
 
-        const [globalState, trancheState] = await Promise.all([
-            this.tokenClient.fetchGlobalState(),
-            this.tokenClient.fetchTrancheState(),
-        ]);
+        const payer = this.solPubKey;
 
-        const { price: solPriceUsd, timestamp } =
-            await this.tokenClient.getSolPriceUsdSafe();
+        // -------------------------------------------------------------
+        // 1) Current wallet balance
+        // -------------------------------------------------------------
+        const balanceLamports: bigint =
+            options?.balanceOverrideLamports ??
+            BigInt(await this.connection.getBalance(payer, commitment));
 
-        return buildSolanaTrancheSnapshot({
-            chainID,
-            globalState,
-            trancheState,
-            solPriceUsd,
-            nativePriceTimestamp: timestamp,
-            ladderWindowBefore: windowBefore,
-            ladderWindowAfter: windowAfter,
-        });
-    }
+        if (balanceLamports <= BigInt(0)) {
+            return BigInt(0);
+        }
 
-    /**
-     * Estimate a conservative SOL buffer (lamports) to leave in the wallet
-     * so the user can pay fees for the current deposit and at least one
-     * more transaction, plus a bit extra for future interactions.
-     *
-     * Intended usage in UI:
-     *   const bufferLamports = await client.estimateGasBuffer();
-     *   const maxSpendable = balanceLamports > bufferLamports
-     *       ? balanceLamports - bufferLamports
-     *       : 0n;
-     *
-     * @param options.txCount          How many transactions to cover (default 2)
-     * @param options.safetyMultiplier Extra safety multiplier (default 3x)
-     * @param options.minBufferLamports Optional override minimum buffer (default ~0.01 SOL)
-     */
-    async estimateGasBuffer(options?: {
-        txCount?: number;
-        safetyMultiplier?: number;
-        minBufferLamports?: bigint;
-    }): Promise<bigint> {
-        this.ensureUser();
+        // -------------------------------------------------------------
+        // 2) Estimate gas buffer via dummy self-transfer
+        // -------------------------------------------------------------
+        let gasBuffer = BigInt(0);
+
+        try {
+            const dummyIx = SystemProgram.transfer({
+                fromPubkey: payer,
+                toPubkey: payer,
+                lamports: 0,
+            });
+
+            const tx = new Transaction().add(dummyIx);
+            const { blockhash } = await this.connection.getLatestBlockhash(
+                commitment,
+            );
+            tx.recentBlockhash = blockhash;
+            tx.feePayer = payer;
 
-        const payer = this.solPubKey;
+            const message = tx.compileMessage();
+            const feeInfo = await this.connection.getFeeForMessage(
+                message,
+                commitment,
+            );
 
-        // 1) Build a small dummy transaction (self-transfer of 0 lamports).
-        const dummyIx = SystemProgram.transfer({
-            fromPubkey: payer,
-            toPubkey: payer,
-            lamports: 0,
-        });
+            // Fallback to a conservative default if RPC doesn't give a value.
+            const singleTxFeeLamports = BigInt(feeInfo.value ?? 5000);
 
-        const tx = new Transaction().add(dummyIx);
-        const { blockhash } = await this.connection.getLatestBlockhash(commitment);
-        tx.recentBlockhash = blockhash;
-        tx.feePayer = payer;
+            const txCount = BigInt(options?.txCount ?? 2);
+            const safetyMultiplier = options?.safetyMultiplier ?? 3;
+            const safetyScaled = BigInt(Math.round(safetyMultiplier * 100)); // e.g. 300
+
+            let buf =
+                (singleTxFeeLamports * txCount * safetyScaled) /
+                BigInt(100);
+
+            const defaultMinBufferLamports = BigInt(10_000_000); // ~0.01 SOL
+            const minBufferLamports =
+                options?.minBufferLamports ?? defaultMinBufferLamports;
 
-        // 2) Ask the cluster what it would charge in lamports for this tx.
-        const message = tx.compileMessage();
-        const feeInfo = await this.connection.getFeeForMessage(message, commitment);
+            if (buf < minBufferLamports) {
+                buf = minBufferLamports;
+            }
+
+            gasBuffer = buf;
+        } catch {
+            // If fee estimation fails, fall back to zero gas buffer
+            // (we will still leave room for protocol fee below).
+            gasBuffer = BigInt(0);
+        }
 
-        // Fallback to a conservative default if RPC doesn't give a value.
-        const singleTxFeeLamports = BigInt(feeInfo.value ?? 5000);
+        // If fees alone eat the whole balance, just keep everything as buffer.
+        if (balanceLamports <= gasBuffer) {
+            return balanceLamports;
+        }
 
-        // 3) How many txs do we want to cover?
-        //    Default: 2 (deposit + one extra operation).
-        const txCount = BigInt(options?.txCount ?? 2);
+        const spendable = balanceLamports - gasBuffer;
+
+        // -------------------------------------------------------------
+        // 3) If we can't compute deposit fee, buffer == gasBuffer
+        // -------------------------------------------------------------
+        if (typeof this.getDepositFee !== 'function') {
+            return gasBuffer;
+        }
 
-        // 4) Apply a safety multiplier (default 3x to be very safe).
-        const safetyMultiplier = options?.safetyMultiplier ?? 3;
-        const safetyScaled = BigInt(Math.round(safetyMultiplier * 100)); // e.g. 300
+        // -------------------------------------------------------------
+        // 4) Binary search for max principal p such that:
+        //          p + fee(p) <= spendable
+        //    Then buffer = balance - pEffective.
+        // -------------------------------------------------------------
+        let lo = BigInt(0);
+        let hi = spendable;
+
+        for (let i = 0; i < 20 && hi - lo > BigInt(1); i++) {
+            const mid = (lo + hi) / BigInt(2);
+
+            let fee: bigint;
+            try {
+                fee = await this.getDepositFee(mid);
+            } catch {
+                // If fee lookup fails mid-search, fall back to gas-only buffer.
+                return gasBuffer;
+            }
 
-        let bufferLamports =
-            (singleTxFeeLamports *
-                txCount *
-                safetyScaled) /
-            BigInt(100);
+            if (mid + fee <= spendable) {
+                lo = mid; // mid is affordable → try bigger
+            } else {
+                hi = mid; // mid too big → go smaller
+            }
+        }
 
-        // 5) Enforce a minimum buffer (default ~0.01 SOL).
-        const defaultMinBufferLamports = BigInt(10_000_000); // 0.01 SOL (1e9 / 100)
-        const minBufferLamports =
-            options?.minBufferLamports ?? defaultMinBufferLamports;
+        // Tiny safety haircut to avoid off-by-one lamport issues.
+        const fudge = BigInt(1_000); // ≈ 0.000001 SOL
+        let effectivePrincipal =
+            lo > fudge ? lo - fudge : lo;
 
-        if (bufferLamports < minBufferLamports) {
-            bufferLamports = minBufferLamports;
+        if (effectivePrincipal < BigInt(0)) {
+            effectivePrincipal = BigInt(0);
         }
 
-        return bufferLamports;
+        const buffer = balanceLamports > effectivePrincipal
+            ? balanceLamports - effectivePrincipal
+            : balanceLamports;
+
+        // Ensure we never *under*-reserve gas
+        return buffer < gasBuffer ? gasBuffer : buffer;
     }
 
     // ---------------------------------------------------------------------

package/src/networks/solana/utils.ts

@@ -55,11 +55,51 @@ 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 USD_SCALE = BigInt(100_000_000);       // 1e8
 const BPS = BigInt(10_000);
 
+/**
+ * Apply one forward growth step: value * (BPS + growthBps) / BPS.
+ * Simple integer round-half-up.
+ */
+function growSupplyOnce(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 shrinkSupplyOnce(value: bigint, growthBps: number): bigint {
+    const g = BigInt(growthBps);
+    return (value * BPS + (BPS + g) / BigInt(2)) / (BPS + g);
+}
+
+/**
+ * Price step is expressed in *cents*, while prices are 1e8 USD.
+ * 1 cent = 0.01 * 1e8 = 1e6, so:
+ *   step = priceGrowthCents * 1e6
+ */
+function priceStepUsd1e8(priceGrowthCents: number): bigint {
+    if (!priceGrowthCents) return BigInt(0);
+    const CENT_SCALE = USD_SCALE / BigInt(100); // 1e6
+    return BigInt(priceGrowthCents) * CENT_SCALE;
+}
+
+function growPriceOnceUsd1e8(value: bigint, priceGrowthCents: number): bigint {
+    const step = priceStepUsd1e8(priceGrowthCents);
+    return value + step;
+}
+
+function shrinkPriceOnceUsd1e8(value: bigint, priceGrowthCents: number): bigint {
+    const step = priceStepUsd1e8(priceGrowthCents);
+    if (step === BigInt(0)) return value;
+    if (value <= step) return BigInt(0);
+    return value - step;
+}
+
 /** BN | bigint -> bigint helper (keeps code readable) */
 export function toBigint(x: any): bigint {
     if (typeof x === 'bigint') return x;
@@ -80,24 +120,6 @@ export function tokensToShares(amount: bigint, currentIndex: bigint): bigint {
     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.
@@ -112,9 +134,9 @@ export function buildSolanaTrancheLadder(options: {
     currentTranche: number;
     initialTrancheSupply: bigint;
     currentTrancheSupply: bigint;
-    currentPriceUsd: bigint;
+    currentPriceUsd: bigint;    // 1e8 scale
     supplyGrowthBps: number;
-    priceGrowthCents: number;
+    priceGrowthCents: number;   // e.g. 2 -> $0.02 per tranche
     windowBefore?: number;
     windowAfter?: number;
 }): TrancheLadderItem[] {
@@ -135,35 +157,41 @@ export function buildSolanaTrancheLadder(options: {
     const capacity = new Map<number, bigint>();
     const price = new Map<number, bigint>();
 
-    // Seed current
+    // Seed current tranche
     capacity.set(currentTranche, initialTrancheSupply);
     price.set(currentTranche, currentPriceUsd);
 
-    // Forward (future tranches)
+    // Forward (future tranches): grow supply by BPS, price by +cents (linear)
     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, priceGrowthCents));
+
+        capacity.set(id, growSupplyOnce(prevCap, supplyGrowthBps));
+        price.set(id, growPriceOnceUsd1e8(prevPrice, priceGrowthCents));
     }
 
-    // Backward (past tranches)
+    // Backward (past tranches): shrink supply by inverse BPS, price by -cents
     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, priceGrowthCents));
+
+        capacity.set(id, shrinkSupplyOnce(nextCap, supplyGrowthBps));
+        price.set(id, shrinkPriceOnceUsd1e8(nextPrice, priceGrowthCents));
     }
 
     const ladder: TrancheLadderItem[] = [];
     for (let id = startId; id <= endId; id++) {
         const cap = capacity.get(id)!;
+
         let sold: bigint;
         if (id < currentTranche) {
+            // Past tranches fully sold
             sold = cap;
         } else if (id === currentTranche) {
+            // Current tranche: cap - remaining
             sold = cap - currentTrancheSupply;
         } else {
+            // Future tranches not yet opened
             sold = BigInt(0);
         }
 
@@ -172,7 +200,7 @@ export function buildSolanaTrancheLadder(options: {
             capacity: cap,
             sold,
             remaining: cap - sold,
-            priceUsd: price.get(id)!,
+            priceUsd: price.get(id)!, // still 1e8 scale
         });
     }
 

package/src/staker.ts

@@ -37,9 +37,11 @@ export class Staker {
         config.forEach((cfg) => {
             switch (cfg.network.chainId) {
                 case SolChainID.Devnet:
+                case SolChainID.WireTestnet:
                     this.clients.set(cfg.network.chainId, new SolanaStakingClient(cfg));
                     break;
 
+                case EvmChainID.Ethereum:
                 case EvmChainID.Hoodi:
                     this.clients.set(EvmChainID.Hoodi, new EthereumStakingClient(cfg));
                     break;

package/src/types.ts

@@ -26,13 +26,6 @@ export interface IStakingClient {
     // Estimated total APY for staking yeild
     getSystemAPY(): Promise<number>;
 
-    /**
-     * Protocol fee charged for deposit from Native to LIQ
-     * in Solana: amount in lamports
-     * in Ethereum: amount in wei
-     */
-    getDepositFee(amount: bigint): Promise<bigint>;
-
     /**
      * Program-level prelaunch WIRE/tranche snapshot for this chain.
      *
@@ -46,15 +39,23 @@ export interface IStakingClient {
         windowAfter?: number;
     }): Promise<TrancheSnapshot | null>;
 
+    /**
+     * Protocol fee charged for deposit from Native to LIQ
+     * in Solana: amount in lamports
+     * in Ethereum: amount in wei
+     */
+    getDepositFee(amount: bigint): Promise<bigint>;
+
     /**
      * Estimate a conservative ETH(wei) / SOL(lamports) buffer to leave in the wallet
      * so the user can pay fees for the current deposit and at least one
      * more transaction, plus a bit extra for future interactions.
     */
-    estimateGasBuffer(options?: {
-        txCount?: number;
-        safetyMultiplier?: number;
-        minBuffer?: bigint;
+    getDepositBuffer(options?: {
+        txCount?: number;                // how many txs to cover in gas buffer (default 2)
+        safetyMultiplier?: number;       // safety multiplier on per-tx fee (default 3x)
+        minBufferLamports?: bigint;      // minimum gas buffer (default ~0.01 SOL)
+        balanceOverrideLamports?: bigint; // for tests/custom callers
     }): Promise<bigint>
 }