@wireio/stake 0.5.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "0.5.1",
+    "version": "0.6.0",
     "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/contract.ts

@@ -66,24 +66,57 @@ export const ADDRESSES: AddressBook = {
     YieldOracle: "0x56A27E1d10d4aEc7402dC26693fb7c0Eb66eF802",
 
     //Outpost contracts
-    OutpostManagerAuthority: "0xAEcd2aa6EeFa4Aa7Cb9368728aA89Ca59Aa9ea59",
-    iodata: "0x2c2ab53F6Bc146bd31B459E832Ce0B9Da78712d8",
-    Base58: "0x9F188Ec124c9ad9bF6D195650d8360Fd052F585A",
-    sysio_merkle: "0x6eDA3C4c34421Cd667800C17fe33E48f5698e004",
-    ReceiptNFT: "0xd083051d9bb8353875abCecAB50C6e4FB5e527a8",
+    OutpostManagerAuthority: "0x57A3723B9f3C6022CAe394C859655E59382Fad18",
+    iodata: "0x88896d4fa70C3a7Fb833C80BB5763a4c53A6aCB5",
+    Base58: "0x0E9E6e8A32477F3B086Aaa26db2b928a816Da711",
+    sysio_merkle: "0xf5858B784B080A08063FAe06dB6d91c5BBAA48C7",
+    ReceiptNFT: "0xF1F5e063bFF6E0c09b0ac8020376E16c0be8eA10",
+    EthUsdPriceConsumer: "0xFdb3Ab290179CA85204aD1Ffb8c1c3c42AEB768F",
+    Pool: "0x15DaeB9562c6Dd21558f14CcdDf5C855499B8693",
+    OutpostManager: "0x1aCCc78FCA9e2Ea4dcE849bf072C2248f36435cC",
+    sysio_write: "0x513e472904EE67A8E27ebaF2411f3ed3851F4514",
+    Pretoken: "0xd7CDc79B90336720ecf02eD5A355cB0F7099F079",
+    BAR: "0x4A01414dEA81b1961aE986Bc4E95B30f73770f99",
+    OPPCommon: "0x3747Cc19A351BCBCE92055c419e7d710C4b399aA",
+    OPP: "0xF577FDc80014ef19DF258243e0551c888Da809E4",
+    Depositor: "0xD9Eb2A2d4e9eD7e2257153041B29DCeCDee8BCFe",
+    OPPInbound: "0x232C01f2528A5013af3703bE4B4ce30A793Ee8BD",
     MockAggregator: "0xFCfc3ddd4CBd9Ad3b3af3A374B8bdA1b66eE6FFF",
-    Pool: "0xee5F11aC9b104c18d2423f266c5E737fC95ebA92",
-    OutpostManager: "0xB1B6ba7FA156652849069aC7ADB281283D235B9f",
-    sysio_write: "0xEfA608136d372349C09a7aA57665C09Fb4a620Ca",
-    EthUsdPriceConsumer: "0x6337A23b61f98b1526faF2848385Abe9cB4cFF21",
-    BAR: "0x9264eAA449da94caF70Fc18522021a94C8DF32Fb",
-    OPPCommon: "0x86A8cA16ce521De3EBdd1C541fAf188795b59FD0",
-    OPP: "0x79e8395Bb5131FB285aCEE5329BB43E66f50F88C",
-    Pretoken: "0x62f98AF2f9C3EF4eF2fA7bc0245BD5a9315E7541",
-    OPPInbound: "0xC85f57Ff069711e0b3472De3963bd2fC2FEfF3e2",
-    Depositor: "0xb0BACAb6f13dd96281300be13a6346461b2f35F3"
+
 };
 
+// Latest 
+// LiqETH contracts
+// LiqEthAuthority: "0x612536e386801b337363Cfa4CC0a7C33Ad588136",
+// BeaconState: "0x48462108c8254568e1d2D4fE3178579d9298ceC4",
+// WithdrawalQueue: "0x49aeFA8B860d908476724e00b48fDa7529f63DbA",
+// LiqEthToken: "0x1e0fb59F0C1Db95fD8f8743B1B3e709CdccF4002",
+// Accounting: "0x679A76d462B9A499F8D23Cb3Fa6CbeB81B5779b9",
+// DepositManager: "0xe63a8f755195D019Db893BF0542A2533895ec927",
+// WithdrawalVault: "0x5C9C8d9Ec8F1Cb64D231b301712405c5E14C175d",
+// StakingModule: "0x5dB271F09f840b49E5E77A3B8fDA30F56A66af20",
+// YieldOracle: "0x323022827e4922a14f30eF8Ad83A393628e0Ac34",
+
+// //Outpost contracts
+// OutpostManagerAuthority: "0x5047Cf5F7bae2d5737B29AAbE910ceE0F3344059",
+// iodata: "0x82A24E7240DaBaAD49A157dB2a203Edb6486d81f",
+// Base58: "0x97aE9B0A8D1678fC73EF7B67539236A85284E2FF",
+// sysio_merkle: "0x3A30901fC4dD25E75dcF9c790b620183aF0Bc3D5",
+// ReceiptNFT: "0xee4f7075B8ac06bb709075D5963C8e012Ef74cc1",
+// EthUsdPriceConsumer: "0x202719423E364aB0C8b4005ee25A20c4A5AB28DC",
+// Pool: "0x8fB1a92c4107Ac1072f51Fac3617A5494Eb71573",
+// OutpostManager: "0x88760aD68a557Aa4FeCde82dA9B024948e7B6074",
+// sysio_write: "0x7485Bb3AA184D33dC54149bBE0BEd548791a6D8f",
+// Pretoken: "0x474B3944e8b9C82264434f394d2367f046869Adc",
+// BAR: "0x779Bb699A0ad10EB8A13d177e594B1268f72C602",
+// OPPCommon: "0x14280b40a8a1F037dDBf9bddf8b78Bc4f11276BA",
+// OPP: "0xBae03C8bb8f557dc48AE9D6F9032d503819B11a7",
+// Depositor: "0x66f41027F9642384c73ce9C8944340a1Af497982",
+// OPPInbound: "0x2AA0833Fc72314faD52a2dA932973abB8491E96F",
+// MockAggregator: "0xFCfc3ddd4CBd9Ad3b3af3A374B8bdA1b66eE6FFF",
+
+
+
 export type Contracts<T extends string = ContractName> = Record<T, ContractConfig>;
 
 export type ContractConfig = {

package/src/networks/ethereum/ethereum.ts

@@ -349,7 +349,7 @@ export class EthereumStakingClient implements IStakingClient {
 
 
             // Fetch all required contract data
-            const [totalSharesBn, indexBn, trancheNumberBn, trancheSupplyBn, tranchePriceWadBn, totalSupplyBn, supplyGrowthBps, priceGrowthCents, minPriceUsd, maxPriceUsd] = await Promise.all([
+            const [totalSharesBn, indexBn, trancheNumberBn, trancheSupplyBn, tranchePriceUsdBn, totalSupplyBn, supplyGrowthBps, priceGrowthCents, minPriceUsd, maxPriceUsd] = await Promise.all([
                 this.contract.Depositor.totalShares(blockTag),
                 this.contract.Depositor.index(blockTag),
                 this.contract.Pretoken.trancheNumber(blockTag),
@@ -362,7 +362,6 @@ export class EthereumStakingClient implements IStakingClient {
                 this.contract.EthUsdPriceConsumer.MAX_PRICE(),
             ]);
 
-
             const totalTrancheSupply = BigInt(totalSupplyBn.toString()) / BigInt(1e10);
             const currentTrancheSupply = BigInt(trancheSupplyBn.toString()) / BigInt(1e10);
 
@@ -380,7 +379,7 @@ export class EthereumStakingClient implements IStakingClient {
                 indexBn,
                 trancheNumberBn,
                 currentTrancheSupply,
-                tranchePriceWadBn,
+                tranchePriceUsdBn,
                 totalTrancheSupply,
                 initialTrancheSupply,
                 supplyGrowthBps,
@@ -395,8 +394,6 @@ export class EthereumStakingClient implements IStakingClient {
             });
         }
         catch (err: any) {
-            console.log(err);
-
             throw new Error(`Error fetching Ethereum tranche snapshot: ${err?.message || err}`);
         }
     }

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;
-    priceGrowthCents: 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,
-        supplyGrowthBps,
         priceGrowthCents,
+        supplyGrowthBps,
         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, priceGrowthCents));
+        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, priceGrowthCents));
+        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;
-    priceGrowthCents;
+    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,
         priceGrowthCents,
-        minPriceUsd, 
+        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,
-        priceGrowthCents,
         windowBefore: ladderWindowBefore,
         windowAfter: ladderWindowAfter,
     });
 
-
     return {
         chainID,
         currentIndex,
         totalShares,
         currentTranche,
-        currentPriceUsd,
+        currentPriceUsd,                // 1e8
         supplyGrowthBps,
-        priceGrowthCents,
-        currentTrancheSupply,
-        initialTrancheSupply,
-        totalPretokensSold: totalTrancheSupply,
+        priceGrowthCents: priceGrowthCentsNumber, // <-- number as required
+        totalPretokensSold: totalTrancheSupplyBig,
+        currentTrancheSupply: currentTrancheSupplyBig,
+        initialTrancheSupply: initialTrancheSupplyBig,
         nativePriceUsd: ethPriceUsd,
         nativePriceTimestamp,
         ladder,
     };
-}
+}

package/src/networks/solana/solana.ts

@@ -3,6 +3,7 @@ import {
     ComputeBudgetProgram,
     Connection,
     ConnectionConfig,
+    PerfSample,
     PublicKey as SolPubKey,
     SystemProgram,
     Transaction,
@@ -40,8 +41,10 @@ import { TokenClient } from './clients/token.client';
 import {
     deriveLiqsolMintPda,
     deriveReservePoolPda,
+    deriveStakeMetricsPda,
     deriveVaultPda,
     INDEX_SCALE,
+    PAY_RATE_SCALE_FACTOR,
 } from './constants';
 
 import { buildSolanaTrancheSnapshot, ceilDiv } from './utils';
@@ -73,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');
@@ -186,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);
     }
 
     // ---------------------------------------------------------------------
@@ -477,25 +482,102 @@ export class SolanaStakingClient implements IStakingClient {
     // READ-ONLY Public Methods
     // ---------------------------------------------------------------------
 
-    // Estimated total APY for staking yield (percent, e.g. 7.23)
+    /**
+     * Returns the system APY (percent) for Solana,
+     * using compound interest per epoch and a
+     * cluster-derived epochs-per-year.
+     */
     async getSystemAPY(): Promise<number> {
-        // Reuse same window as the dashboard (5 most recent valid entries)
-        const avgPayRate = await this.distributionClient.getAverageScaledPayRate(5);
+        // 1) Per-epoch rate (decimal) from on-chain stakeMetrics
+        const ratePerEpoch = await this.getEpochRateDecimalFromProgram();
+        // 2) Live epochs-per-year estimate from cluster
+        const epochsPerYear = await this.getEpochsPerYearFromCluster();
+        // 3) Compound: (1 + r)^N - 1
+        const apyDecimal = Math.pow(1 + ratePerEpoch, epochsPerYear) - 1;
+        // 4) Convert to percent
+        const apyPercent = apyDecimal * 100;
+
+        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);
+
+        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 (avgPayRate.isZero()) {
-            return 0;
+        if (
+            this.epochsPerYearCache &&
+            now - this.epochsPerYearCache.fetchedAt <
+            SolanaStakingClient.EPOCHS_PER_YEAR_TTL_MS
+        ) {
+            return this.epochsPerYearCache.value;
         }
 
-        // 10^12, same scale used on-chain and in the dashboard
-        const SCALE = new BN('1000000000000');
-        const EPOCHS_PER_YEAR = 365; // matches DEFAULT_PAY_RATE semantics
+        const connection = this.anchor.connection;
 
-        // Safe: pay rate is well below 1e12, so .toNumber() won't overflow
-        const ratePerPeriod = avgPayRate.toNumber() / SCALE.toNumber(); // e.g. 0.0001917…
-        const apyDecimal = ratePerPeriod * EPOCHS_PER_YEAR;             // e.g. ~0.07
-        const apyPercent = apyDecimal * 100;                            // e.g. 7
+        // 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');
+        }
 
-        return apyPercent;
+        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;
     }
 
     // ---------------------------------------------
@@ -520,7 +602,7 @@ export class SolanaStakingClient implements IStakingClient {
             return BigInt(0);
         }
 
-        const [avgPayRate, globalConfig] : [BN, GlobalConfig] = await Promise.all([
+        const [avgPayRate, globalConfig]: [BN, GlobalConfig] = await Promise.all([
             this.distributionClient.getAverageScaledPayRate(windowSize),
             this.distributionClient.getGlobalConfig(),
         ]);
@@ -756,4 +838,5 @@ export class SolanaStakingClient implements IStakingClient {
             );
         }
     }
+
 }