@wireio/stake 0.2.2 → 0.2.4

package/src/networks/solana/solana.ts

@@ -2,30 +2,65 @@ import {
     Commitment,
     Connection,
     ConnectionConfig,
+    LAMPORTS_PER_SOL,
     PublicKey as SolPubKey,
     Transaction,
+    TransactionInstruction,
     TransactionSignature,
 } from '@solana/web3.js';
-import { AnchorProvider, BN } from '@coral-xyz/anchor';
+import { AnchorProvider } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    getAssociatedTokenAddressSync,
+    TOKEN_2022_PROGRAM_ID,
+} from '@solana/spl-token';
+
+import {
+    ChainID,
+    ExternalNetwork,
+    KeyType,
+    PublicKey,
+    SolChainID,
+} from '@wireio/core';
 
-import { ChainID, ExternalNetwork, KeyType, PublicKey } from '@wireio/core';
-import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
+import {
+    IStakingClient,
+    Portfolio,
+    PurchaseAsset,
+    PurchaseQuote,
+    StakerConfig,
+    TrancheSnapshot,
+} from '../../types';
 
 import { DepositClient } from './clients/deposit.client';
 import { DistributionClient } from './clients/distribution.client';
+import { LeaderboardClient } from './clients/leaderboard.client';
+import { OutpostClient } from './clients/outpost.client';
+import { TokenClient } from './clients/token.client';
+
 import {
     deriveLiqsolMintPda,
     deriveReservePoolPda,
     deriveVaultPda,
 } from './constants';
+
+import { buildSolanaTrancheSnapshot } from './utils';
 import { SolanaTransaction } from './types';
-import { LeaderboardClient } from './clients/leaderboard.client';
-import { OutpostClient } from './clients/outpost.client';
 
 const commitment: Commitment = 'confirmed';
 
+/**
+ * Solana implementation of IStakingClient.
+ *
+ * Responsibilities:
+ *  - Wire together liqSOL deposit/withdraw
+ *  - Outpost stake/unstake
+ *  - Prelaunch WIRE (pretokens) buy flows
+ *  - Unified portfolio + tranche snapshot + buy quotes
+ *
+ * This class composes lower-level clients; it does not know about UI.
+ */
 export class SolanaStakingClient implements IStakingClient {
     public pubKey: PublicKey;
     public connection: Connection;
@@ -35,9 +70,15 @@ export class SolanaStakingClient implements IStakingClient {
     private distributionClient: DistributionClient;
     private leaderboardClient: LeaderboardClient;
     private outpostClient: OutpostClient;
+    private tokenClient: TokenClient;
+
+    get solPubKey(): SolPubKey {
+        return new SolPubKey(this.pubKey.data.array);
+    }
 
-    get solPubKey(): SolPubKey { return new SolPubKey(this.pubKey.data.array); }
-    get network() { return this.config.network; }
+    get network(): ExternalNetwork {
+        return this.config.network;
+    }
 
     constructor(private config: StakerConfig) {
         const adapter = config.provider as BaseSignerWalletAdapter;
@@ -51,7 +92,10 @@ export class SolanaStakingClient implements IStakingClient {
         }
 
         const opts: ConnectionConfig = { commitment };
-        if (config.network.rpcUrls.length > 1 && config.network.rpcUrls[1].startsWith('ws')) {
+        if (
+            config.network.rpcUrls.length > 1 &&
+            config.network.rpcUrls[1].startsWith('ws')
+        ) {
             opts.wsEndpoint = config.network.rpcUrls[1];
         }
 
@@ -60,7 +104,9 @@ export class SolanaStakingClient implements IStakingClient {
             async signTransaction<T extends SolanaTransaction>(tx: T): Promise<T> {
                 return adapter.signTransaction(tx);
             },
-            async signAllTransactions<T extends SolanaTransaction>(txs: T[]): Promise<T[]> {
+            async signAllTransactions<T extends SolanaTransaction>(
+                txs: T[],
+            ): Promise<T[]> {
                 return Promise.all(txs.map((tx) => adapter.signTransaction(tx)));
             },
         };
@@ -73,75 +119,155 @@ export class SolanaStakingClient implements IStakingClient {
         this.distributionClient = new DistributionClient(this.anchor);
         this.leaderboardClient = new LeaderboardClient(this.anchor);
         this.outpostClient = new OutpostClient(this.anchor);
+        this.tokenClient = new TokenClient(this.anchor);
+        this.tokenClient = new TokenClient(this.anchor);
     }
 
     // ---------------------------------------------------------------------
-    // Public IStakingClient Interface Methods
+    // IStakingClient core methods
     // ---------------------------------------------------------------------
 
     /**
-     * Deposit SOL into liqSOL protocol (liqsol_core deposit flow).
-     * @param amountLamports Amount of SOL to deposit (smallest unit)
-     * @return Transaction signature
+     * Deposit native SOL into liqSOL (liqsol_core::deposit).
+     * Handles tx build, sign, send, and confirmation.
      */
     async deposit(amountLamports: bigint): Promise<string> {
-        if (amountLamports <= BigInt(0)) throw new Error('Deposit amount must be greater than zero.');
-        // const amount = new BN(amountLamports.toString());
+        if (amountLamports <= BigInt(0)) {
+            throw new Error('Deposit amount must be greater than zero.');
+        }
+
         const tx = await this.depositClient.buildDepositTx(amountLamports);
-        const { tx: prepared, blockhash, lastValidBlockHeight } = await this.prepareTx(tx);
+        const { tx: prepared, blockhash, lastValidBlockHeight } = await this.prepareTx(
+            tx,
+        );
         const signed = await this.signTransaction(prepared);
-        const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
-        return result.signature;
+        return await this.sendAndConfirmHttp(signed, {
+            blockhash,
+            lastValidBlockHeight,
+        });
     }
 
     /**
      * Withdraw SOL from liqSOL protocol.
-     * (Wire up once you have DepositClient.buildWithdrawTx or equivalent.)
+     * NOTE: placeholder until a withdraw flow is implemented in DepositClient.
      */
-    async withdraw(amountLamports: bigint): Promise<string> {
+    async withdraw(_amountLamports: bigint): Promise<string> {
         throw new Error('Withdraw method not yet implemented.');
     }
 
     /**
      * Stake liqSOL into Outpost (liqSOL -> pool).
-     * Matches deposit flow: build -> prepare -> sign -> send/confirm.
-     * @param amountLamports Amount of liqSOL to stake (smallest unit)
+     * Ensures user ATA exists, then stakes via outpostClient.
      */
     async stake(amountLamports: bigint): Promise<string> {
-        if (amountLamports <= BigInt(0)) throw new Error('Stake amount must be greater than zero.');
-        // const amount = new BN(amountLamports.toString());
-        const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(this.solPubKey);
+        if (amountLamports <= BigInt(0)) {
+            throw new Error('Stake amount must be greater than zero.');
+        }
+
+        const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(
+            this.solPubKey,
+        );
         const stakeIx = await this.outpostClient.buildStakeLiqsolIx(amountLamports);
         const tx = new Transaction().add(...preIxs, stakeIx);
+
         const prepared = await this.prepareTx(tx);
         const signed = await this.signTransaction(prepared.tx);
-        const result = await this.sendAndConfirmHttp(signed, prepared);
-        return result.signature;
+        return await this.sendAndConfirmHttp(signed, prepared);
     }
 
     /**
      * Unstake liqSOL from Outpost (pool -> liqSOL).
-     * Matches deposit flow: build -> prepare -> sign -> send/confirm.
-     * @param amountLamports Amount of liqSOL principal to unstake (smallest unit)
+     * Mirrors stake() but calls withdrawStake.
      */
     async unstake(amountLamports: bigint): Promise<string> {
-        if (amountLamports <= BigInt(0)) throw new Error('Unstake amount must be greater than zero.');
+        if (amountLamports <= BigInt(0)) {
+            throw new Error('Unstake amount must be greater than zero.');
+        }
+
         const user = this.solPubKey;
-        // const amount = new BN(amountLamports.toString());
         const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
-        const withdrawIx = await this.outpostClient.buildWithdrawStakeIx(amountLamports);
+        const withdrawIx =
+            await this.outpostClient.buildWithdrawStakeIx(amountLamports);
         const tx = new Transaction().add(...preIxs, withdrawIx);
+
+        const prepared = await this.prepareTx(tx);
+        const signed = await this.signTransaction(prepared.tx);
+        return await this.sendAndConfirmHttp(signed, prepared);
+    }
+
+    /**
+     * Buy prelaunch WIRE “pretokens” using a supported asset.
+     *
+     * - SOL: uses purchase_with_sol
+     * - LIQSOL: uses purchase_with_liqsol
+     * - YIELD: uses purchase_warrants_from_yield
+     *
+     * ETH / LIQETH are not valid on Solana.
+     */
+    async buy(amountLamports: bigint, purchaseAsset: PurchaseAsset): Promise<string> {
+        const user = this.solPubKey;
+        let ix: TransactionInstruction;
+        let preIxs: TransactionInstruction[] = [];
+
+        switch (purchaseAsset) {
+            case PurchaseAsset.SOL: {
+                if (!amountLamports || amountLamports <= BigInt(0)) {
+                    throw new Error('SOL pretoken purchase requires a positive amount.');
+                }
+                ix = await this.tokenClient.buildPurchaseWithSolIx(
+                    amountLamports,
+                    user,
+                );
+                break;
+            }
+
+            case PurchaseAsset.LIQSOL: {
+                if (!amountLamports || amountLamports <= BigInt(0)) {
+                    throw new Error(
+                        'liqSOL pretoken purchase requires a positive amount.',
+                    );
+                }
+                preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
+                ix = await this.tokenClient.buildPurchaseWithLiqsolIx(
+                    amountLamports,
+                    user,
+                );
+                break;
+            }
+
+            case PurchaseAsset.YIELD: {
+                // Amount is ignored by the on-chain program; it consumes tracked yield.
+                ix = await this.tokenClient.buildPurchaseFromYieldIx(user);
+                break;
+            }
+
+            case PurchaseAsset.ETH:
+            case PurchaseAsset.LIQETH: {
+                throw new Error(
+                    'ETH / LIQETH pretoken purchases are not supported on Solana.',
+                );
+            }
+
+            default:
+                throw new Error(`Unsupported pretoken purchase asset: ${String(
+                    purchaseAsset,
+                )}`);
+        }
+
+        const tx = new Transaction().add(...preIxs, ix);
         const prepared = await this.prepareTx(tx);
         const signed = await this.signTransaction(prepared.tx);
-        const result = await this.sendAndConfirmHttp(signed, prepared);
-        return result.signature;
+        return await this.sendAndConfirmHttp(signed, prepared);
     }
 
     /**
-     * native = SOL in wallet
-     * liq    = liqSOL token balance (from Token-2022 ATA)
-     * staked = Outpost staked liqSOL principal (from wireReceipt.stakedLiqsol)
-     * tracked = liqSOL tracked balance (from Distribution.userRecord)
+     * Aggregate view of the user’s balances on Solana:
+     *  - native: SOL wallet balance
+     *  - liq: liqSOL token balance (Token-2022 ATA)
+     *  - staked: Outpost-staked liqSOL principal
+     *  - tracked: distribution program trackedBalance (liqSOL)
+     *  - wire: total prelaunch WIRE shares (warrants/pretokens, 1e8)
+     *  - extras: useful internal addresses and raw state for debugging/UX
      */
     async getPortfolio(): Promise<Portfolio> {
         const user = this.solPubKey;
@@ -158,26 +284,36 @@ export class SolanaStakingClient implements IStakingClient {
             ASSOCIATED_TOKEN_PROGRAM_ID,
         );
 
-        // IMPORTANT: use the SAME read primitive the outpost tests rely on
-        const [nativeLamports, actualBalResp, userRecord, snapshot] = await Promise.all([
-            this.connection.getBalance(user, "confirmed"),
-            this.connection.getTokenAccountBalance(userLiqsolAta, "confirmed").catch(() => null),
+        const [
+            nativeLamports,
+            actualBalResp,
+            userRecord,
+            snapshot,
+        ] = await Promise.all([
+            this.connection.getBalance(user, 'confirmed'),
+            this.connection
+                .getTokenAccountBalance(userLiqsolAta, 'confirmed')
+                .catch(() => null),
             this.distributionClient.getUserRecord(user).catch(() => null),
             this.outpostClient.getWireStateSnapshot(user).catch(() => null),
         ]);
 
         const LIQSOL_DECIMALS = 9;
 
-        const actualAmountStr = actualBalResp?.value?.amount ?? "0";
-
+        const actualAmountStr = actualBalResp?.value?.amount ?? '0';
         const trackedAmountStr =
-            userRecord?.trackedBalance ? userRecord.trackedBalance.toString() : "0";
+            userRecord?.trackedBalance?.toString() ?? '0';
 
-        // Snapshot is canonical; receipt may be null if user never staked
         const wireReceipt = snapshot?.wireReceipt ?? null;
+        const userWarrantRecord = snapshot?.userWarrantRecord ?? null;
+        const trancheState = snapshot?.trancheState ?? null;
+        const globalState = snapshot?.globalState ?? null;
 
         const stakedAmountStr =
-            wireReceipt?.stakedLiqsol ? wireReceipt.stakedLiqsol.toString() : "0";
+            wireReceipt?.stakedLiqsol?.toString() ?? '0';
+
+        const wireSharesStr =
+            userWarrantRecord?.totalWarrantsPurchased?.toString() ?? '0';
 
         return {
             native: {
@@ -196,6 +332,12 @@ export class SolanaStakingClient implements IStakingClient {
                 symbol: "LiqSOL",
                 decimals: LIQSOL_DECIMALS,
             },
+            wire: {
+                // Prelaunch pretokens / WIRE shares (1e8)
+                amount: BigInt(wireSharesStr),
+                symbol: "$WIRE",
+                decimals: 8,
+            },
             tracked: {
                 amount: BigInt(trackedAmountStr),
                 symbol: "LiqSOL",
@@ -206,51 +348,201 @@ export class SolanaStakingClient implements IStakingClient {
                 reservePoolPDA: reservePoolPDA.toBase58(),
                 vaultPDA: vaultPDA.toBase58(),
                 wireReceipt,
+                userWarrantRecord,
+                globalIndex: globalState?.currentIndex?.toString(),
+                totalShares: globalState?.totalShares?.toString(),
+                currentTrancheNumber: trancheState?.currentTrancheNumber?.toString(),
+                currentTranchePriceUsd: trancheState?.currentTranchePriceUsd?.toString(), // 1e8 USD
             },
-            chainID: this.network.chainId as ChainID,
+            chainID: this.network.chainId,
         };
     }
 
-    // ---------------------------------------------------------------------
-    // SOL-only extras
-    // ---------------------------------------------------------------------
+    /**
+     * Unified, chain-agnostic tranche snapshot for Solana.
+     *
+     * Uses:
+     *  - liqsol_core.globalState (currentIndex, totalShares, etc.)
+     *  - liqsol_core.trancheState (price, supply, total sold, etc.)
+     *  - Chainlink/PriceHistory for SOL/USD (via TokenClient.getSolPriceUsdSafe)
+     *
+     * windowBefore/windowAfter control how many ladder rows we precompute
+     * around the current tranche for UI, but you can pass nothing if you
+     * only need current tranche info.
+     */
+    async getTrancheSnapshot(options?: {
+        chainID?: ChainID;
+        windowBefore?: number;
+        windowAfter?: number;
+    }): Promise<TrancheSnapshot> {
+        const {
+            chainID = SolChainID.WireTestnet,
+            windowBefore,
+            windowAfter,
+        } = options ?? {};
+
+        // Canonical program state
+        const [globalState, trancheState] = await Promise.all([
+            this.tokenClient.fetchGlobalState(),
+            this.tokenClient.fetchTrancheState(),
+        ]);
 
-    async getUserRecord() {
-        return this.distributionClient.getUserRecord(this.solPubKey);
+        // Latest SOL/USD price (1e8) + timestamp from PriceHistory
+        const { price: solPriceUsd, timestamp } =
+            await this.tokenClient.getSolPriceUsdSafe();
+
+        return buildSolanaTrancheSnapshot({
+            chainID,
+            globalState,
+            trancheState,
+            solPriceUsd,
+            nativePriceTimestamp: timestamp,
+            ladderWindowBefore: windowBefore,
+            ladderWindowAfter: windowAfter,
+        });
     }
 
-    getProtocolFee() {
-        // TODO
+    /**
+     * Approximate prelaunch WIRE quote for a given amount & asset.
+     *
+     * Uses TrancheSnapshot + SOL/USD price for:
+     *  - SOL: amount is lamports
+     *  - LIQSOL: amount is liqSOL base units (decimals = 9)
+     *  - YIELD: amount is treated as SOL lamports-equivalent of yield
+     *
+     * NOTE: On-chain rounding may differ slightly (this is UI-only).
+     */
+    async getBuyQuote(
+        amount: bigint,
+        asset: PurchaseAsset,
+        opts?: { chainID?: ChainID },
+    ): Promise<PurchaseQuote> {
+        // For non-YIELD purchases we require a positive amount.
+        if (asset !== PurchaseAsset.YIELD && amount <= BigInt(0)) {
+            throw new Error('amount must be > 0 for non-YIELD purchases');
+        }
+
+        const snapshot = await this.getTrancheSnapshot({
+            chainID: opts?.chainID,
+        });
+
+        const wirePriceUsd = snapshot.currentPriceUsd; // 1e8
+        const solPriceUsd = snapshot.nativePriceUsd;   // 1e8
+
+        if (!wirePriceUsd || wirePriceUsd <= BigInt(0)) {
+            throw new Error('Invalid WIRE price in tranche snapshot');
+        }
+        if (!solPriceUsd || solPriceUsd <= BigInt(0)) {
+            throw new Error('No SOL/USD price available');
+        }
+
+        const ONE_E9 = BigInt(LAMPORTS_PER_SOL);    // 1e9
+        const ONE_E8 = BigInt(100_000_000);         // 1e8
+
+        let notionalUsd: bigint;
+
+        switch (asset) {
+            case PurchaseAsset.SOL: {
+                // lamports * solPriceUsd / 1e9  → 1e8 USD
+                notionalUsd = (amount * solPriceUsd) / ONE_E9;
+                break;
+            }
+
+            case PurchaseAsset.LIQSOL: {
+                // liqSOL also uses 9 decimals; use same conversion.
+                notionalUsd = (amount * solPriceUsd) / ONE_E9;
+                break;
+            }
+
+            case PurchaseAsset.YIELD: {
+                // Treat amount as lamports-equivalent of SOL yield (UI convention).
+                notionalUsd = (amount * solPriceUsd) / ONE_E9;
+                break;
+            }
+
+            case PurchaseAsset.ETH:
+            case PurchaseAsset.LIQETH:
+                throw new Error('getBuyQuote for ETH/LIQETH is not supported on Solana');
+
+            default:
+                throw new Error(`Unsupported purchase asset: ${String(asset)}`);
+        }
+
+        // WIRE shares (1e8) = (notionalUsd * 1e8) / wirePriceUsd
+        // Add a small bias to avoid truncating to 0 on tiny buys.
+        const numerator = notionalUsd * ONE_E8;
+        const wireShares =
+            numerator === BigInt(0)
+                ? BigInt(0)
+                : (numerator + wirePriceUsd - BigInt(1)) / wirePriceUsd;
+
+        return {
+            purchaseAsset: asset,
+            amountIn: amount,
+            wireShares,
+            wireDecimals: 8,
+            wirePriceUsd,
+            notionalUsd,
+        };
+    }
+
+    /**
+     * Convenience helper to fetch the distribution userRecord for the current user.
+     * Used by balance-correction flows and debugging.
+     */
+    async getUserRecord() {
+        return this.distributionClient.getUserRecord(this.solPubKey);
     }
 
+    /**
+     * Run the "correct & register" flow on Solana:
+     *  - builds the minimal transaction (maybe multi-user) to reconcile liqSOL
+     *  - signs and sends the transaction if it can succeed
+     */
     async correctBalance(amount?: bigint): Promise<string> {
         const build = await this.distributionClient.buildCorrectRegisterTx({ amount });
         if (!build.canSucceed || !build.transaction) {
             throw new Error(build.reason ?? 'Unable to build Correct&Register transaction');
         }
 
-        const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(build.transaction);
+        const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(
+            build.transaction,
+        );
         const signed = await this.signTransaction(tx);
-        const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
-        return result.signature;
+        const signature = await this.sendAndConfirmHttp(signed, {
+            blockhash,
+            lastValidBlockHeight,
+        });
+        return signature;
     }
 
     // ---------------------------------------------------------------------
     // Tx helpers
     // ---------------------------------------------------------------------
 
+    /**
+     * Send a signed transaction over HTTP RPC and wait for confirmation.
+     * Throws if the transaction fails.
+     */
     private async sendAndConfirmHttp(
         signed: SolanaTransaction,
         ctx: { blockhash: string; lastValidBlockHeight: number },
-    ): Promise<TxResult> {
-        const signature = await this.connection.sendRawTransaction(signed.serialize(), {
-            skipPreflight: false,
-            preflightCommitment: commitment,
-            maxRetries: 3,
-        });
+    ): Promise<string> {
+        const signature = await this.connection.sendRawTransaction(
+            signed.serialize(),
+            {
+                skipPreflight: false,
+                preflightCommitment: commitment,
+                maxRetries: 3,
+            },
+        );
 
         const conf = await this.connection.confirmTransaction(
-            { signature, blockhash: ctx.blockhash, lastValidBlockHeight: ctx.lastValidBlockHeight },
+            {
+                signature,
+                blockhash: ctx.blockhash,
+                lastValidBlockHeight: ctx.lastValidBlockHeight,
+            },
             commitment,
         );
 
@@ -258,29 +550,35 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error(`Transaction failed: ${JSON.stringify(conf.value.err)}`);
         }
 
-        return { signature, slot: conf.context.slot, confirmed: true };
+        return signature;
     }
 
+    /**
+     * Sign a single Solana transaction using the connected wallet adapter.
+     */
     async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
         return this.anchor.wallet.signTransaction(tx);
     }
 
+    /**
+     * Generic "fire and forget" send helper if the caller already
+     * prepared and signed the transaction.
+     */
     async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
         return this.anchor.sendAndConfirm(signed);
     }
 
+    /**
+     * Attach recent blockhash + fee payer to a transaction.
+     * Required before signing and sending.
+     */
     async prepareTx(
         tx: Transaction,
     ): Promise<{ tx: Transaction; blockhash: string; lastValidBlockHeight: number }> {
-        const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash('confirmed');
+        const { blockhash, lastValidBlockHeight } =
+            await this.connection.getLatestBlockhash('confirmed');
         tx.recentBlockhash = blockhash;
         tx.feePayer = this.solPubKey;
         return { tx, blockhash, lastValidBlockHeight };
     }
-}
-
-export interface TxResult {
-    signature: string;
-    slot: number;
-    confirmed: boolean;
 }

package/src/networks/solana/types.ts

@@ -131,4 +131,14 @@ export type WireReceipt = {
     purchasedWithSol: BN;
     purchasedSolShares: BN;
     bump: number;
-}
+}
+
+
+export type PriceHistory = {
+    windowSize: number;
+    prices: BN[];
+    count: number;
+    nextIndex: number;
+    bump: number;
+}
+