@wireio/stake 0.2.2 → 0.2.4

package/src/networks/solana/utils.ts

@@ -1,5 +1,3 @@
-// src/networks/solana/utils.ts
-
 import { Program, BN, AnchorProvider } from '@coral-xyz/anchor';
 
 import {
@@ -52,6 +50,213 @@ import {
 
 import liqsolCoreIDL from '../../assets/solana/idl/liqsol_core.json';
 import { LiqsolCore } from '../../assets/solana/types/liqsol_core';
+import { GlobalState, TrancheState } from './types';
+import { TrancheLadderItem, TrancheSnapshot } from '../../types';
+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 BPS = BigInt(10_000);
+
+/** BN | bigint -> bigint helper (keeps code readable) */
+export function toBigint(x: any): bigint {
+    if (typeof x === 'bigint') return x;
+    if (typeof x === 'number') return BigInt(x);
+    // Anchor BN
+    return BigInt(x.toString());
+}
+
+/**
+ * Convert token amount -> shares using the same rule as on-chain tests:
+ * shares = ceil(amount * INDEX_SCALE / currentIndex)
+ */
+export function tokensToShares(amount: bigint, currentIndex: bigint): bigint {
+    if (amount === BigInt(0)) return BigInt(0);
+    const num = amount * INDEX_SCALE;
+    const q = num / currentIndex;
+    const r = num % currentIndex;
+    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.
+ *
+ * Rules (from liqsol_core tests):
+ *  - past tranches are fully sold
+ *  - current tranche has (initial - currentSupply) sold
+ *  - future tranches start with 0 sold
+ *  - supply/price grow by supplyGrowthBps/priceGrowthBps per tranche
+ */
+export function buildSolanaTrancheLadder(options: {
+    currentTranche: number;
+    initialTrancheSupply: bigint;
+    currentTrancheSupply: bigint;
+    totalWarrantsSold: bigint; // informational only
+    currentPriceUsd: bigint;
+    supplyGrowthBps: number;
+    priceGrowthBps: number;
+    windowBefore?: number;
+    windowAfter?: number;
+}): TrancheLadderItem[] {
+    const {
+        currentTranche,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore = 5,
+        windowAfter = 5,
+    } = options;
+
+    const startId = Math.max(0, currentTranche - windowBefore);
+    const endId = currentTranche + windowAfter;
+
+    const capacity = new Map<number, bigint>();
+    const price = new Map<number, bigint>();
+
+    // Seed current
+    capacity.set(currentTranche, initialTrancheSupply);
+    price.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, priceGrowthBps));
+    }
+
+    // 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, priceGrowthBps));
+    }
+
+    const ladder: TrancheLadderItem[] = [];
+    for (let id = startId; id <= endId; id++) {
+        const cap = capacity.get(id)!;
+        let sold: bigint;
+        if (id < currentTranche) {
+            sold = cap;
+        } else if (id === currentTranche) {
+            sold = cap - currentTrancheSupply;
+        } else {
+            sold = BigInt(0);
+        }
+
+        ladder.push({
+            id,
+            capacity: cap,
+            sold,
+            remaining: cap - sold,
+            priceUsd: price.get(id)!,
+        });
+    }
+
+    return ladder;
+}
+
+/**
+ * Turn raw liqsol_core accounts into a chain-agnostic TrancheSnapshot for SOL.
+ * All math stays here; TokenClient just wires accounts + connection.
+ */
+export function buildSolanaTrancheSnapshot(options: {
+    chainID: ChainID;
+    globalState: GlobalState;
+    trancheState: TrancheState;
+    solPriceUsd?: bigint;
+    nativePriceTimestamp?: number;
+    ladderWindowBefore?: number;
+    ladderWindowAfter?: number;
+}): TrancheSnapshot {
+    const {
+        chainID,
+        globalState,
+        trancheState,
+        solPriceUsd,
+        nativePriceTimestamp,
+        ladderWindowBefore,
+        ladderWindowAfter,
+    } = options;
+
+    const currentIndex = toBigint(globalState.currentIndex);
+    const totalShares = toBigint(globalState.totalShares);
+
+    const currentTranche = trancheState.currentTrancheNumber.toNumber();
+    const currentTrancheSupply = toBigint(trancheState.currentTrancheSupply);
+    const initialTrancheSupply = toBigint(trancheState.initialTrancheSupply);
+    const totalWarrantsSold = toBigint(trancheState.totalWarrantsSold);
+    const currentPriceUsd = toBigint(trancheState.currentTranchePriceUsd);
+
+    const supplyGrowthBps = trancheState.supplyGrowthBps;
+    const priceGrowthBps = trancheState.priceGrowthBps;
+
+    const minPriceUsd = trancheState.minPriceUsd
+        ? toBigint(trancheState.minPriceUsd)
+        : undefined;
+    const maxPriceUsd = trancheState.maxPriceUsd
+        ? toBigint(trancheState.maxPriceUsd)
+        : undefined;
+
+    const ladder = buildSolanaTrancheLadder({
+        currentTranche,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        totalWarrantsSold,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore: ladderWindowBefore,
+        windowAfter: ladderWindowAfter,
+    });
+
+    return {
+        chainID,
+        currentIndex,
+        totalShares,
+        currentTranche,
+        currentPriceUsd,
+        minPriceUsd,
+        maxPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        currentTrancheSupply,
+        initialTrancheSupply,
+        totalWarrantsSold,
+        nativePriceUsd: solPriceUsd,
+        nativePriceTimestamp,
+        ladder,
+    };
+}
+
 
 // -----------------------------------------------------------------------------
 // Read-only liqsol_core Program helper
@@ -68,7 +273,7 @@ export function getLiqsolCoreProgram(
 
     // Dummy wallet – we're only doing read-only account fetches here.
     const tmpKeypair = Keypair.generate();
-    const wallet : any = { publicKey: tmpKeypair.publicKey, signAllTransactions: async () => [], signTransaction: async () => tmpKeypair };
+    const wallet: any = { publicKey: tmpKeypair.publicKey, signAllTransactions: async () => [], signTransaction: async () => tmpKeypair };
 
     const provider = new AnchorProvider(connection, wallet, {
         commitment: 'confirmed',
@@ -364,8 +569,21 @@ export async function buildOutpostAccounts(
     );
 
     // Chainlink program feeds
-    const chainLinkFeed = CHAINLINK_FEED;
-    const chainLinkProgram = CHAINLINK_PROGRAM
+    let chainLinkFeed = CHAINLINK_FEED;
+    let chainLinkProgram = CHAINLINK_PROGRAM
+
+    try {
+        const program = getLiqsolCoreProgram(connection);
+        const ts: TrancheState = await program.account.trancheState.fetch(trancheState);
+        if (ts.chainlinkFeed && ts.chainlinkProgram) {
+            chainLinkFeed = ts.chainlinkFeed as PublicKey;
+            chainLinkProgram = ts.chainlinkProgram as PublicKey;
+        }
+    } catch {
+        // If trancheState isn't initialized yet, we fall back to the constants.
+        // In that case, pretoken instructions will still fail, which is the correct
+        // behavior until admin initializes TrancheState on-chain.
+    }
 
     void connection; // reserved for future extra validation
 

package/src/{staker/staker.ts → staker.ts}

@@ -2,8 +2,8 @@
 
 import { ChainID, EvmChainID, SolChainID } from '@wireio/core';
 import { IStakingClient, StakerConfig } from './types';
-import { SolanaStakingClient } from '../networks/solana/solana';
-import { EthereumStakingClient } from '../networks/ethereum/ethereum';
+import { SolanaStakingClient } from './networks/solana/solana';
+import { EthereumStakingClient } from './networks/ethereum/ethereum';
 
 export class Staker {
     public selectedChainID?: ChainID;

package/src/types.ts

@@ -0,0 +1,143 @@
+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 type StakerConfig = {
+    network: ExternalNetwork;
+    provider: BaseSignerWalletAdapter | ethers.providers.Web3Provider;
+    pubKey: PublicKey;
+}
+
+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, asset: PurchaseAsset): Promise<string>;
+
+    /** Fetch the complete user portfolio */
+    getPortfolio(): Promise<Portfolio>;
+
+    /**
+     * Program-level prelaunch WIRE/tranche snapshot for this chain.
+     *
+     * Returns:
+     *  - `TrancheSnapshot` when the chain supports pretoken/tranches
+     *  - `null` if this chain has no WIRE/pretoken integration
+     */
+    getTrancheSnapshot(options?: {
+        chainID?: ChainID;
+        windowBefore?: number;
+        windowAfter?: number;
+    }): Promise<TrancheSnapshot | null>;
+
+    /**  */
+    getBuyQuote(amount: bigint, asset: PurchaseAsset): Promise<PurchaseQuote>;
+}
+
+export interface Portfolio {
+    /** Native balance on chain: ETH, SOL */
+    native: BalanceView;
+    /** Actual Liquid  balance of LiqETH, LiqSOL*/
+    liq: BalanceView;
+    /** Outpost Staked balance */
+    staked: BalanceView
+    /** Prelaunch WIRE “shares” (warrants/pretokens) */
+    wire: 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
+};
+
+export interface TrancheLadderItem {
+    /** On-chain tranche id, 0-based (0,1,2,...) */
+    id: number;
+    /** Total capacity for this tranche (pretokens, 1e8 scale) */
+    capacity: bigint;
+    /** Sold amount in this tranche (1e8 scale) */
+    sold: bigint;
+    /** Remaining = capacity - sold (1e8 scale) */
+    remaining: bigint;
+    /** Price for this tranche in USD (1e8 scale) */
+    priceUsd: bigint;
+}
+
+/**
+ * Unified pretoken/tranche snapshot for any chain.
+ * ETH / other chains just fill the same shape from their own contracts.
+ */
+export interface TrancheSnapshot {
+    chainID: ChainID;
+
+    /** Global share index (1e12 on Sol today; other chains can use their own scale) */
+    currentIndex: bigint;
+    /** Total accounting shares (wire pretoken “shares”) */
+    totalShares: bigint;
+
+    /** Current tranche id as stored on chain (0-based) */
+    currentTranche: number;
+
+    /** Current tranche price in USD (1e8 scale) */
+    currentPriceUsd: bigint;
+    /** Optional min/max bounds for price validation (1e8 scale) */
+    minPriceUsd?: bigint;
+    maxPriceUsd?: bigint;
+
+    /** Tranche curve config (per-chain) */
+    supplyGrowthBps: number; // e.g. 100 = +1% per tranche
+    priceGrowthBps: number;  // e.g. 200 = +2% per tranche
+
+    /** Current tranche supply state (1e8 scale) */
+    currentTrancheSupply: bigint;   // remaining in current tranche
+    initialTrancheSupply: bigint;   // capacity for current tranche
+    totalWarrantsSold: bigint;      // global cumulative sold (all tranches), 1e8
+
+    /** Native token → USD price if available (SOL/USD, ETH/USD, etc, 1e8 scale) */
+    nativePriceUsd?: bigint;
+    /** Optional timestamp (sec) for the last recorded native price */
+    nativePriceTimestamp?: number;
+
+    /**
+     * Local window of tranche “rows” centered around current.
+     * Used directly by the frontend for ladder graphs.
+     */
+    ladder: TrancheLadderItem[];
+}
+
+/** Purchase asset selection used by staking client(s) */
+export enum PurchaseAsset {
+    SOL = 'SOL',
+    LIQSOL = 'LIQSOL',
+    ETH = 'ETH',
+    LIQETH = 'LIQETH',
+    YIELD = 'YIELD',
+}
+
+export interface PurchaseQuote {
+    purchaseAsset: PurchaseAsset;
+    amountIn: bigint;       // lamports / wei / token units
+
+    /** Expected pretoken “shares” (pretokens) and decimals */
+    wireShares: bigint;     // 1e8 scale
+    wireDecimals: number;   // always 8 for now
+
+    /** Current price + notional in USD (1e8 scale) */
+    wirePriceUsd: bigint;
+    notionalUsd: bigint;
+}

package/src/staker/types.ts

@@ -1,51 +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>;
-
-    // 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>;
-}
-
-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
-};