@wireio/stake 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "0.2.3",
+    "version": "0.2.4",
     "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/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());
     }
 }