@wireio/stake 0.7.0 → 0.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "0.7.0",
+    "version": "0.7.2",
     "description": "LIQ Staking Module for Wire Network",
     "homepage": "https://gitea.gitgo.app/Wire/sdk-stake",
     "license": "FSL-1.1-Apache-2.0",

package/src/networks/ethereum/ethereum.ts

@@ -375,7 +375,7 @@ export class EthereumStakingClient implements IStakingClient {
             // let ethPriceUsd: bigint = BigInt(answer.toString());)
 
             let ethPriceUsdBn = await this.contract.EthUsdPriceConsumer.getPrice18Decimals();
-            let ethPriceUsd: bigint = BigInt(ethPriceUsdBn.toString()) / 10n;
+            let ethPriceUsd: bigint = BigInt(ethPriceUsdBn.toString()) / BigInt(1e10);
 
             let nativePriceTimestamp: number = Number(updatedAt);
 

package/src/networks/solana/solana.ts

@@ -677,7 +677,7 @@ export class SolanaStakingClient implements IStakingClient {
      * in the wallet so that a MAX deposit (balance - buffer) will succeed.
      *
      * It accounts for:
-     *   - Runtime tx fees (via a dummy self-transfer)
+     *   - Runtime tx fees (via cached dummy self-transfer fee)
      *   - Protocol deposit fee (via getDepositFee(amount))
      *
      * Intended UI usage:
@@ -696,7 +696,7 @@ export class SolanaStakingClient implements IStakingClient {
         const payer = this.solPubKey;
 
         // -------------------------------------------------------------
-        // 1) Current wallet balance
+        // 1) Current wallet balance (prefer caller override)
         // -------------------------------------------------------------
         const balanceLamports: bigint =
             options?.balanceOverrideLamports ??
@@ -707,32 +707,12 @@ export class SolanaStakingClient implements IStakingClient {
         }
 
         // -------------------------------------------------------------
-        // 2) Estimate gas buffer via dummy self-transfer
+        // 2) Estimate gas buffer (using cached single-tx fee)
         // -------------------------------------------------------------
         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 message = tx.compileMessage();
-            const feeInfo = await this.connection.getFeeForMessage(
-                message,
-                commitment,
-            );
-
-            // Fallback to a conservative default if RPC doesn't give a value.
-            const singleTxFeeLamports = BigInt(feeInfo.value ?? 5000);
+            const singleTxFeeLamports = await this.getSingleTxFeeLamports();
 
             const txCount = BigInt(options?.txCount ?? 2);
             const safetyMultiplier = options?.safetyMultiplier ?? 3;
@@ -752,12 +732,11 @@ export class SolanaStakingClient implements IStakingClient {
 
             gasBuffer = buf;
         } catch {
-            // If fee estimation fails, fall back to zero gas buffer
-            // (we will still leave room for protocol fee below).
+            // If fee estimation fails, just fall back to "no gas buffer".
             gasBuffer = BigInt(0);
         }
 
-        // If fees alone eat the whole balance, just keep everything as buffer.
+        // If gas buffer alone eats the whole balance, we just keep everything.
         if (balanceLamports <= gasBuffer) {
             return balanceLamports;
         }
@@ -772,35 +751,43 @@ export class SolanaStakingClient implements IStakingClient {
         }
 
         // -------------------------------------------------------------
-        // 4) Binary search for max principal p such that:
-        //          p + fee(p) <= spendable
-        //    Then buffer = balance - pEffective.
+        // 4) Approximate principal using linear fee model from ONE RPC call
+        //
+        //   fee(a) ≈ k * a
+        //   want: a + k*a <= spendable → a <= spendable / (1 + k)
+        //
+        //   We estimate k from fee(spendable) / spendable.
         // -------------------------------------------------------------
-        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 feeAtSpendable: bigint;
 
-            if (mid + fee <= spendable) {
-                lo = mid; // mid is affordable → try bigger
-            } else {
-                hi = mid; // mid too big → go smaller
-            }
+        try {
+            feeAtSpendable = await this.getDepositFee(spendable);
+        } catch {
+            // If protocol fee lookup fails, fall back to gas-only buffer
+            return gasBuffer;
         }
 
-        // Tiny safety haircut to avoid off-by-one lamport issues.
-        const fudge = BigInt(1_000); // ≈ 0.000001 SOL
+        // If there is effectively no protocol fee, keep only gas buffer.
+        if (feeAtSpendable <= BigInt(0)) {
+            return gasBuffer;
+        }
+
+        const s = spendable;
+        const f = feeAtSpendable;
+
+        // denom = s + f = s * (1 + k)  (since f ≈ k*s)
+        const denom = s + f;
+        if (denom === BigInt(0)) {
+            return gasBuffer;
+        }
+
+        // a ≈ floor( s^2 / (s + f) )
+        let a = (s * s) / denom;
+
+        // Tiny safety haircut to avoid edge off-by-one lamports
+        const fudge = BigInt(10_000); // ≈ 0.00001 SOL
         let effectivePrincipal =
-            lo > fudge ? lo - fudge : lo;
+            a > fudge ? a - fudge : a;
 
         if (effectivePrincipal < BigInt(0)) {
             effectivePrincipal = BigInt(0);
@@ -810,10 +797,46 @@ export class SolanaStakingClient implements IStakingClient {
             ? balanceLamports - effectivePrincipal
             : balanceLamports;
 
-        // Ensure we never *under*-reserve gas
+        // Ensure we never under-reserve gas.
         return buffer < gasBuffer ? gasBuffer : buffer;
     }
 
+    private cachedTxFee?: { value: bigint; fetchedAt: number };
+    private static readonly FEE_CACHE_TTL_MS = 60_000; // 60s
+
+    private async getSingleTxFeeLamports(): Promise<bigint> {
+        const now = Date.now();
+
+        if (this.cachedTxFee && now - this.cachedTxFee.fetchedAt < SolanaStakingClient.FEE_CACHE_TTL_MS) {
+            return this.cachedTxFee.value;
+        }
+
+        const payer = this.solPubKey;
+
+        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 message = tx.compileMessage();
+        const feeInfo = await this.connection.getFeeForMessage(message, commitment);
+
+        const singleTxFeeLamports = BigInt(feeInfo.value ?? 5000);
+
+        this.cachedTxFee = {
+            value: singleTxFeeLamports,
+            fetchedAt: now,
+        };
+
+        return singleTxFeeLamports;
+    }
+
     // ---------------------------------------------------------------------
     // Tx helpers
     // ---------------------------------------------------------------------