@wireio/stake 0.5.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "0.5.2",
+    "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

@@ -490,19 +490,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 +517,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;
     }
 

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,6 +37,7 @@ 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;