@wireio/stake 0.5.0 → 0.5.2

package/src/networks/solana/solana.ts

@@ -3,7 +3,9 @@ import {
     ComputeBudgetProgram,
     Connection,
     ConnectionConfig,
+    PerfSample,
     PublicKey as SolPubKey,
+    SystemProgram,
     Transaction,
     TransactionSignature,
 } from '@solana/web3.js';
@@ -39,15 +41,20 @@ import { TokenClient } from './clients/token.client';
 import {
     deriveLiqsolMintPda,
     deriveReservePoolPda,
+    deriveStakeMetricsPda,
     deriveVaultPda,
     INDEX_SCALE,
+    PAY_RATE_SCALE_FACTOR,
 } from './constants';
 
-import { buildSolanaTrancheSnapshot } from './utils';
-import { PayRateEntry, SolanaTransaction } from './types';
+import { buildSolanaTrancheSnapshot, ceilDiv } from './utils';
+import { GlobalConfig, PayRateEntry, SolanaTransaction } from './types';
+import { SolanaProgramService } from './program';
 
 const commitment: Commitment = 'confirmed';
 
+export const SCALE = new BN('1000000000000');
+
 /**
  * Solana implementation of IStakingClient.
  *
@@ -69,6 +76,7 @@ export class SolanaStakingClient implements IStakingClient {
     public leaderboardClient: LeaderboardClient;
     public outpostClient: OutpostClient;
     public tokenClient: TokenClient;
+    public program: SolanaProgramService
 
     get solPubKey(): SolPubKey {
         if (!this.pubKey) throw new Error('pubKey is undefined');
@@ -182,6 +190,7 @@ export class SolanaStakingClient implements IStakingClient {
         this.leaderboardClient = new LeaderboardClient(this.anchor);
         this.outpostClient = new OutpostClient(this.anchor);
         this.tokenClient = new TokenClient(this.anchor);
+        this.program = new SolanaProgramService(this.anchor);
     }
 
     // ---------------------------------------------------------------------
@@ -473,10 +482,112 @@ export class SolanaStakingClient implements IStakingClient {
     // READ-ONLY Public Methods
     // ---------------------------------------------------------------------
 
-    // Estimated total APY for staking yeild
-    getSystemAPY(): Promise<number> {
-        // TODO
-        return Promise.resolve(0);
+    /**
+     * Returns the system APY (percent) for Solana,
+     * using compound interest per epoch and a
+     * cluster-derived epochs-per-year.
+     */
+    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;
+    }
+
+    /**
+     * Reads the liqsol_core stakeMetrics account and returns the
+     * Solana per-epoch system rate as a **decimal** (not BPS),
+     * de-scaled using PAY_RATE_SCALE_FACTOR (1e12).
+     */
+    private async getEpochRateDecimalFromProgram(): Promise<number> {
+        const liqSolCoreProgram = this.program.getProgram('liqsolCore');
+        const stakeMetricsPda = deriveStakeMetricsPda();
+        const stakeMetrics =
+            await liqSolCoreProgram.account.stakeMetrics.fetch(stakeMetricsPda);
+
+        // solSystemPayRate is stored on-chain with PAY_RATE_SCALE_FACTOR (1e12)
+        const raw = BigInt(stakeMetrics.solSystemPayRate.toString());
+
+        // 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;
+    }
+
+    // Simple cache so we don’t hammer RPC
+    private epochsPerYearCache?: { value: number; fetchedAt: number };
+    private static readonly EPOCHS_PER_YEAR_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+    /**
+     * Derive "epochs per year" from the live Solana cluster.
+     *
+     * Uses:
+     *  - getRecentPerformanceSamples() to estimate slots/second
+     *  - getEpochInfo() to read slotsInEpoch
+     */
+    private async getEpochsPerYearFromCluster(): Promise<number> {
+        const now = Date.now();
+
+        if (
+            this.epochsPerYearCache &&
+            now - this.epochsPerYearCache.fetchedAt <
+            SolanaStakingClient.EPOCHS_PER_YEAR_TTL_MS
+        ) {
+            return this.epochsPerYearCache.value;
+        }
+
+        const connection = this.anchor.connection;
+
+        // 1) Estimate slots/second from recent performance samples
+        const samples: PerfSample[] = await connection.getRecentPerformanceSamples(
+            60,
+        );
+        if (!samples.length) {
+            throw new Error('No performance samples available from cluster');
+        }
+
+        const totalSlots = samples.reduce((acc, s) => acc + s.numSlots, 0);
+        const totalSecs = samples.reduce((acc, s) => acc + s.samplePeriodSecs, 0);
+
+        if (totalSecs === 0) {
+            throw new Error(
+                'Cluster returned zero samplePeriodSecs in performance samples',
+            );
+        }
+
+        const slotsPerSecond = totalSlots / totalSecs;
+
+        // 2) Slots per epoch from cluster
+        const epochInfo = await connection.getEpochInfo(); // finalized commitment by default
+        const slotsPerEpoch = epochInfo.slotsInEpoch;
+
+        const secondsPerEpoch = slotsPerEpoch / slotsPerSecond;
+        const secondsPerYear = 365 * 24 * 60 * 60;
+
+        const epochsPerYear = secondsPerYear / secondsPerEpoch;
+
+        this.epochsPerYearCache = {
+            value: epochsPerYear,
+            fetchedAt: now,
+        };
+
+        return epochsPerYear;
     }
 
     // ---------------------------------------------
@@ -501,87 +612,17 @@ export class SolanaStakingClient implements IStakingClient {
             return BigInt(0);
         }
 
-        const [history, globalConfig] = await Promise.all([
-            this.distributionClient.getPayRateHistory(),
+        const [avgPayRate, globalConfig]: [BN, GlobalConfig] = await Promise.all([
+            this.distributionClient.getAverageScaledPayRate(windowSize),
             this.distributionClient.getGlobalConfig(),
         ]);
 
-        if (!history || !globalConfig) {
-            return BigInt(0);
-        }
-
-        const entries = history.entries ?? [];
-        if (!entries.length) {
-            return BigInt(0);
-        }
-
-        const maxEntries =
-            typeof history.maxEntries === 'number'
-                ? history.maxEntries
-                : entries.length;
-
-        const totalEntriesAdded = new BN(
-            history.totalEntriesAdded.toString(),
-        );
-
-        const COUNT = Math.max(1, Math.min(windowSize, maxEntries, entries.length));
-
-        // ---------------------------------------------
-        // Walk the circular buffer from "most recent"
-        // back through COUNT entries, using the same
-        // logic as your coworker script.
-        // ---------------------------------------------
-
-        let avgPayRate = new BN(0);
-
-        if (COUNT > 0) {
-            let idx: number;
-
-            if (totalEntriesAdded.isZero()) {
-                // "Not wrapped yet" case
-                idx = 0;
-            } else if (history.currentIndex === 0) {
-                idx = maxEntries - 1;
-            } else {
-                idx = history.currentIndex - 1;
-            }
-
-            let sum = new BN(0);
-            let valid = 0;
-            const zero = new BN(0);
-
-            for (let i = 0; i < COUNT; i++) {
-                const entry: PayRateEntry | undefined = entries[idx];
-                if (entry) {
-                    const rate = new BN(entry.scaledRate.toString());
-                    if (rate.gt(zero)) {
-                        sum = sum.add(rate);
-                        valid += 1;
-                    }
-                }
-
-                // Same wrap logic as the coworker’s script:
-                if (totalEntriesAdded.isZero()) {
-                    // simple forward iteration if never wrapped
-                    idx = (idx + 1) % maxEntries;
-                } else {
-                    // walk backwards through the ring buffer
-                    idx = idx === 0 ? maxEntries - 1 : idx - 1;
-                }
-            }
-
-            if (valid > 0) {
-                avgPayRate = this.ceilDiv(sum, new BN(valid));
-            }
-        }
-
-        // If no valid pay-rate entries, no fee
-        if (avgPayRate.isZero()) {
+        if (!globalConfig || avgPayRate.isZero()) {
             return BigInt(0);
         }
 
         // depositFeeMultiplier may be BN or number depending on your type
-        const rawMultiplier: any = (globalConfig as any).depositFeeMultiplier;
+        const rawMultiplier = globalConfig.depositFeeMultiplier;
         const multiplier = new BN(
             rawMultiplier?.toString?.() ?? rawMultiplier ?? 0,
         );
@@ -592,9 +633,8 @@ export class SolanaStakingClient implements IStakingClient {
         const amountBn = new BN(amountLamports.toString());
 
         // 10^12 scale (matches scaledRate / index scale)
-        const SCALE = new BN('1000000000000');
 
-        const feeBn = this.ceilDiv(
+        const feeBn = ceilDiv(
             avgPayRate.mul(multiplier).mul(amountBn),
             SCALE,
         );
@@ -642,6 +682,75 @@ export class SolanaStakingClient implements IStakingClient {
         });
     }
 
+    /**
+     * 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();
+
+        const payer = this.solPubKey;
+
+        // 1) Build a small dummy transaction (self-transfer of 0 lamports).
+        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;
+
+        // 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);
+
+        // Fallback to a conservative default if RPC doesn't give a value.
+        const singleTxFeeLamports = BigInt(feeInfo.value ?? 5000);
+
+        // 3) How many txs do we want to cover?
+        //    Default: 2 (deposit + one extra operation).
+        const txCount = BigInt(options?.txCount ?? 2);
+
+        // 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
+
+        let bufferLamports =
+            (singleTxFeeLamports *
+                txCount *
+                safetyScaled) /
+            BigInt(100);
+
+        // 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;
+
+        if (bufferLamports < minBufferLamports) {
+            bufferLamports = minBufferLamports;
+        }
+
+        return bufferLamports;
+    }
+
     // ---------------------------------------------------------------------
     // Tx helpers
     // ---------------------------------------------------------------------
@@ -740,11 +849,4 @@ export class SolanaStakingClient implements IStakingClient {
         }
     }
 
-    private ceilDiv(n: BN, d: BN): BN {
-        if (d.isZero()) {
-            throw new Error('Division by zero in ceilDiv');
-        }
-        return n.add(d.subn(1)).div(d);
-    }
-
 }

package/src/networks/solana/types.ts

@@ -177,7 +177,7 @@ export interface SharesPreview {
  * - NFT withdrawal receipts
  * - Encumbered funds for pending withdrawals
  */
-export type Global = {
+export type GlobalAccount = {
     /** PDA bump */
     bump: number;
 
@@ -210,9 +210,6 @@ export type Global = {
  * - `wireState` lifecycle (preLaunch/postLaunch/refund)
  */
 export type GlobalState = {
-    /** Admin authority for pretokens/outpost config */
-    admin: PublicKey;
-
     /** Deployment timestamp (Unix, seconds) */
     deployedAt: BN;
 
@@ -495,9 +492,6 @@ export type UserPretokenRecord = {
  * All price/supply fields use 8-decimal precision (SCALE = 1e8).
  */
 export type TrancheState = {
-    /** Admin authority for tranche parameters */
-    admin: PublicKey;
-
     /** Current tranche number */
     currentTrancheNumber: BN;
 
@@ -516,8 +510,8 @@ export type TrancheState = {
     /** Supply growth in basis points per tranche */
     supplyGrowthBps: number;
 
-    /** Price growth in basis points per tranche */
-    priceGrowthBps: number;
+    /** Price growth in cents per tranche (0.01 USD units) */
+    priceGrowthCents: number;
 
     /** Minimum valid SOL/USD price for Chainlink validation (8-decimal i128) */
     minPriceUsd: BN;

package/src/networks/solana/utils.ts

@@ -114,7 +114,7 @@ export function buildSolanaTrancheLadder(options: {
     currentTrancheSupply: bigint;
     currentPriceUsd: bigint;
     supplyGrowthBps: number;
-    priceGrowthBps: number;
+    priceGrowthCents: number;
     windowBefore?: number;
     windowAfter?: number;
 }): TrancheLadderItem[] {
@@ -124,7 +124,7 @@ export function buildSolanaTrancheLadder(options: {
         currentTrancheSupply,
         currentPriceUsd,
         supplyGrowthBps,
-        priceGrowthBps,
+        priceGrowthCents,
         windowBefore = 5,
         windowAfter = 5,
     } = options;
@@ -144,7 +144,7 @@ export function buildSolanaTrancheLadder(options: {
         const prevCap = capacity.get(id - 1)!;
         const prevPrice = price.get(id - 1)!;
         capacity.set(id, growOnce(prevCap, supplyGrowthBps));
-        price.set(id, growOnce(prevPrice, priceGrowthBps));
+        price.set(id, growOnce(prevPrice, priceGrowthCents));
     }
 
     // Backward (past tranches)
@@ -152,7 +152,7 @@ export function buildSolanaTrancheLadder(options: {
         const nextCap = capacity.get(id + 1)!;
         const nextPrice = price.get(id + 1)!;
         capacity.set(id, shrinkOnce(nextCap, supplyGrowthBps));
-        price.set(id, shrinkOnce(nextPrice, priceGrowthBps));
+        price.set(id, shrinkOnce(nextPrice, priceGrowthCents));
     }
 
     const ladder: TrancheLadderItem[] = [];
@@ -210,7 +210,7 @@ export function buildSolanaTrancheSnapshot(options: {
     const totalPretokensSold = toBigint(trancheState.totalPretokensSold);
     const currentPriceUsd = toBigint(trancheState.currentTranchePriceUsd);
     const supplyGrowthBps = trancheState.supplyGrowthBps;
-    const priceGrowthBps = trancheState.priceGrowthBps;
+    const priceGrowthCents = trancheState.priceGrowthCents;
 
     const ladder = buildSolanaTrancheLadder({
         currentTranche,
@@ -218,7 +218,7 @@ export function buildSolanaTrancheSnapshot(options: {
         currentTrancheSupply,
         currentPriceUsd,
         supplyGrowthBps,
-        priceGrowthBps,
+        priceGrowthCents,
         windowBefore: ladderWindowBefore,
         windowAfter: ladderWindowAfter,
     });
@@ -230,7 +230,7 @@ export function buildSolanaTrancheSnapshot(options: {
         currentTranche,
         currentPriceUsd,
         supplyGrowthBps,
-        priceGrowthBps,
+        priceGrowthCents,
         totalPretokensSold,
         currentTrancheSupply,
         initialTrancheSupply,
@@ -798,4 +798,11 @@ export async function waitUntilSafeToExecuteFunction(
 export interface ScheduleConfig {
     early?: number; // fraction of epoch, default 0.10
     late?: number;  // fraction of epoch, default 0.90
+}
+
+export function ceilDiv(n: BN, d: BN): BN {
+    if (d.isZero()) {
+        throw new Error('Division by zero in ceilDiv');
+    }
+    return n.add(d.subn(1)).div(d);
 }

package/src/staker.ts

@@ -36,7 +36,7 @@ export class Staker {
 
         config.forEach((cfg) => {
             switch (cfg.network.chainId) {
-                case SolChainID.WireTestnet:
+                case SolChainID.Devnet:
                     this.clients.set(cfg.network.chainId, new SolanaStakingClient(cfg));
                     break;
 

package/src/types.ts

@@ -21,7 +21,7 @@ export interface IStakingClient {
     buy(amount: bigint): Promise<string>;
 
     /** Fetch the complete user portfolio */
-    getPortfolio(): Promise<Portfolio>;
+    getPortfolio(): Promise<Portfolio | null>;
 
     // Estimated total APY for staking yeild
     getSystemAPY(): Promise<number>;
@@ -45,12 +45,17 @@ export interface IStakingClient {
         windowBefore?: number;
         windowAfter?: number;
     }): Promise<TrancheSnapshot | null>;
-    
-    // Estimated total APY for staking yeild
-    getSystemAPY(): Promise<number>;
 
-    // Protocol fee charged for deposit from Native to LIQ
-    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;
+    }): Promise<bigint>
 }
 
 /**
@@ -211,10 +216,9 @@ export interface TrancheSnapshot {
     /** Current tranche price in USD (1e8 scale) */
     currentPriceUsd: bigint;
 
-    /** Tranche curve config (per-chain) */
-    // TODO make a constant?
-    supplyGrowthBps: number; // e.g. 100 = +1% per tranche
-    priceIncrementUsd: number;  // e.g. 200 = +2% per tranche
+    supplyGrowthBps: number; // 2.5% growth per tranche
+
+    priceGrowthCents: number;  // $0.02 USD growth per tranche
 
     totalPretokensSold: bigint;  // total pretokens sold across all tranches (1e8 scale)
 

package/src/staker/types.ts

@@ -1,62 +0,0 @@
-import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { PublicKey as SolPubKey } from '@solana/web3.js';
-import { ChainID, ExternalNetwork, PublicKey } from '@wireio/core';
-import { ethers } from 'ethers';
-
-export interface IStakingClient {
-    pubKey: PublicKey;
-    network: ExternalNetwork;
-
-    /** Amount is in the chain's smallest unit (lamports/wei, etc.) */
-    deposit(amount: bigint): Promise<string>;
-    withdraw(amount: bigint): Promise<string>;
-    stake(amount: bigint): Promise<string>;
-    unstake(amount: bigint): Promise<string>;
-
-    buy?(amount: bigint, purchaseAsset: PurchaseAsset): Promise<string>;
-
-    // REMOVED from shared client, SOLANA ONLY
-    /** Register any untracked LIQ staked tokens */
-    // register(): Promise<string>;
-
-    /** Fetch the portfolio for the LIQ stake user */
-    getPortfolio(): Promise<Portfolio>;
-}
-
-// Enum describing which asset is being used to buy pretoken
-export enum PurchaseAsset {
-    SOL = "SOL",
-    LIQSOL = "LIQSOL",
-    ETH = "ETH",
-    LIQETH = "LIQETH",
-    YIELD = "YIELD",
-}
-
-export type StakerConfig = {
-    network: ExternalNetwork;
-    provider: BaseSignerWalletAdapter | ethers.providers.Web3Provider;
-    pubKey: PublicKey;
-}
-
-export interface Portfolio {
-    /** Native balance on chain: ETH, SOL */
-    native: BalanceView;
-    /** Actual Liquid  balance of LiqETH, LiqSOL*/
-    liq: BalanceView;
-    /** Outpost Staked balance */
-    staked: BalanceView
-    /** SOL ONLY!
-     * Tracked liqSOL balance from distribution program */
-    tracked?: BalanceView;
-    /** Extra PDAs and account addresses */
-    extras?: Record<string, any>;
-    /** Chain ID of the network for which this portfolio is from */
-    chainID: ChainID; 
-}
-
-export type BalanceView = {
-    amount: bigint; // raw on-chain integer value
-    decimals: number; // number of decimal places
-    symbol?: string; // optional token symbol identifier
-    ata?: SolPubKey; // associated token account address
-};