@wireio/stake 0.2.3 → 0.2.5

package/src/networks/ethereum/utils.ts

@@ -0,0 +1,314 @@
+
+import { ethers } from "ethers";
+import { TrancheLadderItem, TrancheSnapshot } from "../../types";
+import { ChainID } from "@wireio/core";
+
+
+const BPS = BigInt(10_000);
+
+export interface CustomContractError {
+    name?: string;
+    signature?: string;
+    args?: any[];
+    data?: any;
+    method?: string;
+    code?: any;
+    raw: string;
+}
+
+
+
+export function formatContractErrors(err: any): CustomContractError {
+    // Extract custom error details if present
+    if (err.errorName && err.errorArgs) {
+        const errorObj: CustomContractError = {
+            name: err.errorName,
+            signature: err.errorSignature,
+            args: err.errorArgs.map((arg: any) =>
+                arg && arg._isBigNumber ? ethers.BigNumber.from(arg).toString() : arg
+            ),
+            data: err.data,
+            method: err.method,
+            code: err.code,
+            raw: err,
+        };
+        console.error("Custom contract error:", errorObj);
+        return errorObj;
+    } else {
+        console.error("Contract Error:", err);
+        return {
+            raw: typeof err === 'string' ? err : (err?.message || String(err))
+        };
+    }
+}
+
+
+
+/**
+ * Finalize an OPP epoch. Optionally accept a gasLimit override (ethers BigNumberish).
+ * If gasLimit is not provided, the method will attempt estimateGas.finalizeEpoch()
+ * and pad it (1.2x). If estimateGas fails, a conservative fallback is used.
+ */
+export async function sendOPPFinalize(opp: ethers.Contract, gasLimit?: ethers.BigNumberish) {
+    const overrides: any = {};
+    try {
+        if (gasLimit === undefined) {
+            try {
+                const estimated = await opp.estimateGas.finalizeEpoch();
+                const padded = ethers.BigNumber.from(estimated).mul(12).div(10); // 1.2x
+                overrides.gasLimit = padded;
+                console.log('sendFinalize: estimated gas', estimated.toString(), 'padded to', overrides.gasLimit.toString());
+            } catch (estErr) {
+                // estimateGas can throw UNPREDICTABLE_GAS_LIMIT; fall back to a safe default
+                console.warn('sendFinalize: estimateGas.finalizeEpoch() failed, falling back to hardcoded gasLimit', estErr);
+                overrides.gasLimit = ethers.BigNumber.from(8000000);
+            }
+        } else {
+            overrides.gasLimit = ethers.BigNumber.from(gasLimit);
+            console.log('sendFinalize: using provided gasLimit override', overrides.gasLimit.toString());
+        }
+
+        const tx = await opp.finalizeEpoch(overrides); // submit tx with overrides
+        console.log('sendFinalize tx hash:', tx.hash, 'overrides:', overrides);
+
+        const receipt = await tx.wait(); // wait for mined
+        console.log('sendFinalize tx mined, block:', receipt.blockNumber);
+        return receipt;
+    } catch (err: any) {
+        // Verbose error logging to help debugging reverts / provider issues
+        console.error('sendFinalize() failed:', err?.message || err);
+
+        // Try to extract common raw payload locations used by ethers errors
+        const raw = err?.error?.data || err?.data || err?.body || err?.receipt || err?.transaction || err;
+        console.error('sendFinalize raw payload:', raw);
+
+        // Try parsing with contractService if available
+        try {
+            const parsed = formatContractErrors(raw);
+            console.error('sendFinalize parsed error:', parsed.name, parsed.args);
+        } catch (parseErr) {
+            // Fallback: decode Error(string) ABI encoded revert (0x08c379a0)
+            try {
+                const hex = (typeof raw === 'string') ? raw : (raw && raw.data) ? raw.data : null;
+                if (hex && typeof hex === 'string' && hex.startsWith('0x08c379a0')) {
+                    const reason = ethers.utils.defaultAbiCoder.decode(['string'], '0x' + hex.slice(10))[0];
+                    console.error('sendFinalize revert reason:', reason);
+                } else {
+                    console.error('sendFinalize: unable to decode revert payload (not standard Error(string))');
+                }
+            } catch (fallbackErr) {
+                console.error('sendFinalize: fallback decode failed:', fallbackErr);
+            }
+        }
+
+        // If there is a receipt, print it for extra context
+        if (err?.receipt) console.error('sendFinalize receipt:', err.receipt);
+        if (err?.transaction) console.error('sendFinalize transaction object:', err.transaction);
+
+        // Re-throw so callers can handle it as well
+        throw err;
+    }
+}
+
+
+
+/**
+ * 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);
+}
+
+
+/**
+ * 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 = 1; i < trancheNumber; i++) {
+        supply = (supply * (BPS + BigInt(supplyGrowthBps)) + BPS / BigInt(2)) / BPS;
+    }
+    return supply;
+}
+
+
+/**
+ * Build a local tranche ladder around the current tranche
+ * using only on-chain config + current state.
+ *
+ */
+export function buildEthereumTrancheLadder(options: {
+    currentTranche: number;
+    totalTrancheSupply: bigint,
+    initialTrancheSupply: bigint;
+    currentTrancheSupply: bigint;
+    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(1, currentTranche - windowBefore);
+    const endId = currentTranche + windowAfter;
+
+    console.error('loading eth tranche ladder - ', currentTranche, currentTrancheSupply);
+    console.log('startId', startId)
+    
+    
+    //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>();
+
+    // Seed current
+    capacity.set(currentTranche, currentTrancheSize);
+    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 async function buildEthereumTrancheSnapshot(options: {
+    chainID: ChainID;
+    totalSharesBn;
+    indexBn;
+    trancheNumberBn;
+    currentTrancheSupply;
+    tranchePriceWadBn;
+    totalTrancheSupply;
+    initialTrancheSupply;
+    supplyGrowthBps;
+    priceGrowthBps;
+    minPriceUsd;
+    maxPriceUsd;
+
+    ethPriceUsd?: bigint;
+    nativePriceTimestamp?: number;
+    ladderWindowBefore?: number;
+    ladderWindowAfter?: number;
+}): Promise<TrancheSnapshot> {
+    const {
+        chainID,
+        ethPriceUsd,
+        nativePriceTimestamp,
+        ladderWindowBefore,
+        ladderWindowAfter,
+
+        totalSharesBn, 
+        indexBn, 
+        trancheNumberBn, 
+        currentTrancheSupply, 
+        tranchePriceWadBn, 
+        totalTrancheSupply,
+        initialTrancheSupply,
+        supplyGrowthBps,
+        priceGrowthBps,
+        minPriceUsd, 
+        maxPriceUsd,
+    } = options;
+
+
+    // 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
+
+
+    const ladder = buildEthereumTrancheLadder({
+        currentTranche,
+        totalTrancheSupply,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore: ladderWindowBefore,
+        windowAfter: ladderWindowAfter,
+    });
+
+
+    return {
+        chainID,
+        currentIndex,
+        totalShares,
+        currentTranche,
+        currentPriceUsd,
+        minPriceUsd,
+        maxPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        currentTrancheSupply,
+        initialTrancheSupply,
+        totalWarrantsSold: totalTrancheSupply,
+        nativePriceUsd: ethPriceUsd,
+        nativePriceTimestamp,
+        ladder,
+    };
+}

package/src/networks/solana/clients/token.client.ts

@@ -1,54 +1,54 @@
 import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
-import type { TransactionInstruction } from '@solana/web3.js';
+import type { TransactionInstruction, Connection } from '@solana/web3.js';
 import { PublicKey, SystemProgram } from '@solana/web3.js';
 import {
     TOKEN_2022_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID,
 } from '@solana/spl-token';
 
-import { buildOutpostAccounts, type OutpostAccounts } from '../utils';
+import { buildOutpostAccounts, type OutpostAccounts, buildSolanaTrancheSnapshot } from '../utils';
 import { SolanaProgramService } from '../program';
 import { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
-import { GlobalState, PriceHistory, TrancheState, UserWarrantRecord, WalletLike, WireReceipt } from '../types';
+import {
+    GlobalState,
+    PriceHistory,
+    TrancheState,
+    UserWarrantRecord,
+    WalletLike,
+    WireReceipt,
+} from '../types';
 import { derivePriceHistoryPda } from '../constants';
+import type { } from '../types';
+import { ChainID, SolChainID } from '@wireio/core';
+import { PurchaseAsset, PurchaseQuote, TrancheSnapshot } from '../../../types';
 
-/**
- * Client for interacting with the Pretoken (Outpost) program on Solana.
- *
- * Provides account fetching and instruction building for pretoken operations.
- * Does NOT send or confirm transactions; keeps SDK composable.
- * 
- * TODO: Update to $WIRE Token implementation Post-Launch
- */
 export class TokenClient {
     private readonly program: Program<LiqsolCore>;
 
-    get wallet(): WalletLike { return this.provider.wallet; }
+    get wallet(): WalletLike {
+        return this.provider.wallet;
+    }
 
     constructor(private readonly provider: AnchorProvider) {
         const svc = new SolanaProgramService(provider);
         this.program = svc.getProgram('liqsolCore');
     }
 
-    /**
-     * Single source of truth for outpost/pretoken accounts.
-     * Uses your existing PDA + ATA derivations in buildOutpostAccounts().
-     */
+    // ---------------------------------------------------------------------------
+    // Account helpers
+    // ---------------------------------------------------------------------------
+
     async getAccounts(user: PublicKey): Promise<OutpostAccounts> {
         return buildOutpostAccounts(this.provider.connection, user);
     }
 
-    /**
-     * Lightweight, UI-friendly snapshot fetchers.
-     * (No decoding assumptions beyond what Anchor already provides.)
-     */
     async fetchGlobalState(): Promise<GlobalState> {
-        const { globalState } = await this.getAccounts(this.provider.wallet.publicKey);
+        const { globalState } = await this.getAccounts(this.wallet.publicKey);
         return this.program.account.globalState.fetch(globalState);
     }
 
     async fetchTrancheState(): Promise<TrancheState> {
-        const { trancheState } = await this.getAccounts(this.provider.wallet.publicKey);
+        const { trancheState } = await this.getAccounts(this.wallet.publicKey);
         return this.program.account.trancheState.fetch(trancheState);
     }
 
@@ -63,28 +63,26 @@ export class TokenClient {
     }
 
     // ---------------------------------------------------------------------------
-    // Instruction builders (no send, no confirmation: SDK stays composable)
+    // Tranche snapshot / quoting
     // ---------------------------------------------------------------------------
 
-    /**
-     * purchase_with_sol(amount u64)
-     *
-     * amountLamports is bigint to match your SDK convention.
-     */
-    async buildPurchaseWithSolIx(amountLamports: bigint, user = this.wallet.publicKey): Promise<TransactionInstruction> {
+    // ---------------------------------------------------------------------------
+    // Instruction builders (no send / confirm)
+    // ---------------------------------------------------------------------------
+
+    async buildPurchaseWithSolIx(
+        amountLamports: bigint,
+        user = this.wallet.publicKey,
+    ): Promise<TransactionInstruction> {
         const a = await this.getAccounts(user);
 
         return this.program.methods
             .purchaseWithSol(new BN(amountLamports.toString()))
             .accounts({
-                // signer
                 user: a.user,
-
-                // core state
                 liqsolMint: a.liqsolMint,
                 globalState: a.globalState,
 
-                // liqSOL pool + distribution plumbing
                 poolAuthority: a.poolAuthority,
                 liqsolPoolAta: a.liqsolPoolAta,
                 liqsolPoolUserRecord: a.poolUserRecord,
@@ -94,67 +92,53 @@ export class TokenClient {
                 bucketTokenAccount: a.bucketTokenAccount,
                 solBucket: a.solBucket,
 
-                // IMPORTANT: IDL name (not wireReceipt)
+                // IDL name is warrantDepositRecord (wireReceipt PDA)
                 warrantDepositRecord: a.wireReceipt,
 
-                // pretoken state
                 trancheState: a.trancheState,
                 userWarrantRecord: a.userWarrantRecord,
 
-                // Chainlink (IDL names are chainlinkFeed / chainlinkProgram in old utils)
                 chainlinkFeed: a.chainLinkFeed,
                 chainlinkProgram: a.chainLinkProgram,
 
-                // programs
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
             })
             .instruction();
     }
 
-    /**
-     * purchase_with_liqsol(amount u64)
-     *
-     * amount is liqSOL *raw base units* (Token-2022 amount).
-     */
-    async buildPurchaseWithLiqsolIx(amountLamports: bigint, user = this.wallet.publicKey): Promise<TransactionInstruction> {
+    async buildPurchaseWithLiqsolIx(
+        amountLamports: bigint,
+        user = this.wallet.publicKey,
+    ): Promise<TransactionInstruction> {
         const a = await this.getAccounts(user);
 
         return this.program.methods
             .purchaseWithLiqsol(new BN(amountLamports.toString()))
             .accounts({
-                // signer
                 user: a.user,
-
-                // core state
                 liqsolMint: a.liqsolMint,
                 globalState: a.globalState,
 
-                // token movement
-                buyerAta: a.userAta, // Token-2022 ATA for user
+                buyerAta: a.userAta,
                 poolAuthority: a.poolAuthority,
                 liqsolPoolAta: a.liqsolPoolAta,
 
-                // IMPORTANT: IDL name (not wireReceipt)
                 warrantDepositRecord: a.wireReceipt,
 
-                // distribution plumbing (per old utils)
-                liqsolPoolUserRecord: a.poolUserRecord, // pool user_record PDA
+                liqsolPoolUserRecord: a.poolUserRecord,
                 distributionState: a.distributionState,
                 payRateHistory: a.payRateHistory,
                 bucketAuthority: a.bucketAuthority,
                 bucketTokenAccount: a.bucketTokenAccount,
                 solBucket: a.solBucket,
 
-                // pretoken state
                 trancheState: a.trancheState,
                 userWarrantRecord: a.userWarrantRecord,
 
-                // Chainlink
                 chainlinkFeed: a.chainLinkFeed,
                 chainlinkProgram: a.chainLinkProgram,
 
-                // programs
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
                 systemProgram: SystemProgram.programId,
@@ -162,21 +146,15 @@ export class TokenClient {
             .instruction();
     }
 
-    /**
-     * purchase_warrants_from_yield()
-     *
-     * No amount arg; it consumes tracked yield according to on-chain rules.
-     */
-    async buildPurchaseFromYieldIx(user = this.wallet.publicKey): Promise<TransactionInstruction> {
+    async buildPurchaseFromYieldIx(
+        user = this.wallet.publicKey,
+    ): Promise<TransactionInstruction> {
         const a = await this.getAccounts(user);
 
         return this.program.methods
             .purchaseWarrantsFromYield()
             .accounts({
-                // signer
                 user: a.user,
-
-                // core state
                 globalState: a.globalState,
                 liqsolMint: a.liqsolMint,
                 poolAuthority: a.poolAuthority,
@@ -184,68 +162,64 @@ export class TokenClient {
                 solBucket: a.solBucket,
 
                 liqsolPoolUserRecord: a.poolUserRecord,
-
                 distributionState: a.distributionState,
                 payRateHistory: a.payRateHistory,
                 bucketAuthority: a.bucketAuthority,
                 bucketTokenAccount: a.bucketTokenAccount,
 
-                // programs
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-
-                // pretoken state + chainlink (per old utils)
                 trancheState: a.trancheState,
                 userWarrantRecord: a.userWarrantRecord,
                 chainlinkFeed: a.chainLinkFeed,
                 chainlinkProgram: a.chainLinkProgram,
+
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                systemProgram: SystemProgram.programId,
             })
             .instruction();
     }
 
+    // ---------------------------------------------------------------------------
+    // Price helpers (SOL/USD via priceHistory account)
+    // ---------------------------------------------------------------------------
 
-    // HELPERS
+    async getSolPriceUsdSafe(): Promise<{ price?: bigint; timestamp?: number }> {
+        try {
+            const price = await this.getSolPriceUsd();
+            // current priceHistory account has no timestamp; keep optional
+            return { price, timestamp: undefined };
+        } catch {
+            return { price: undefined, timestamp: undefined };
+        }
+    }
 
     /**
-     * Fetch the SOL price in 1e8 USD units from liqsol_core.priceHistory.
-     *
-     * This uses the same ring-buffer semantics as the on-chain program:
-     * the latest price is the entry just before `nextIndex`.
+     * Fetch latest SOL/USD price (1e8 scale) from liqsol_core.priceHistory.
+     * Uses the ring-buffer semantics from earlier SDK code.
      */
-    async getSolPriceUsd(): Promise<BN> {
+    async getSolPriceUsd(): Promise<bigint> {
         const priceHistoryPda = derivePriceHistoryPda();
+        const history = (await this.program.account.priceHistory.fetch(
+            priceHistoryPda,
+        )) as PriceHistory;
 
-        const history : PriceHistory = await this.program.account.priceHistory.fetch(
-            priceHistoryPda
-        );
-
-        console.log('PRICE HISTORY', history);
+        const { prices, nextIndex, count, windowSize } = history;
 
-        const { windowSize, prices, nextIndex, count } = history;
-
-        if (!prices || prices.length === 0 || count === 0) {
-            throw new Error("Price history is empty – no SOL price available");
+        if (!prices || prices.length === 0 || !count) {
+            throw new Error('Price history is empty – no SOL price available');
         }
 
-        // Use the actual buffer length as capacity (should match windowSize)
         const capacity = prices.length || windowSize;
-        if (capacity === 0) {
-            throw new Error("Price history capacity is zero – check account layout");
+        if (!capacity) {
+            throw new Error('Price history capacity is zero – check account layout');
         }
 
-        // Last written slot in the ring buffer
-        const lastIndex =
-            nextIndex === 0
-                ? capacity - 1
-                : nextIndex - 1;
-
-        const priceUsd = prices[lastIndex];
+        const lastIndex = nextIndex === 0 ? capacity - 1 : nextIndex - 1;
+        const latest = prices[lastIndex];
 
-        if (!BN.isBN(priceUsd)) {
-            throw new Error("Latest price entry is not a BN – check IDL/decoder");
+        if (!BN.isBN(latest)) {
+            throw new Error('Latest price entry is not a BN – check IDL/decoder');
         }
 
-        // priceUsd is already 1e8-scaled USD (same scale used in warrant pricing)
-        return priceUsd;
+        return BigInt(latest.toString());
     }
 }