@wireio/stake 0.2.1 → 0.2.3

package/src/networks/solana/solana.ts

@@ -4,6 +4,7 @@ import {
     ConnectionConfig,
     PublicKey as SolPubKey,
     Transaction,
+    TransactionInstruction,
     TransactionSignature,
 } from '@solana/web3.js';
 import { AnchorProvider, BN } from '@coral-xyz/anchor';
@@ -11,7 +12,7 @@ import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
 import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 
 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';
@@ -23,6 +24,7 @@ import {
 import { SolanaTransaction } from './types';
 import { LeaderboardClient } from './clients/leaderboard.client';
 import { OutpostClient } from './clients/outpost.client';
+import { TokenClient } from './clients/token.client';
 
 const commitment: Commitment = 'confirmed';
 
@@ -35,6 +37,7 @@ 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 network() { return this.config.network; }
@@ -73,6 +76,7 @@ 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);
     }
 
     // ---------------------------------------------------------------------
@@ -137,11 +141,64 @@ export class SolanaStakingClient implements IStakingClient {
         return result.signature;
     }
 
+
+    /** Buy pretoken (warrants) using specified asset.
+     * @param amount Amount in smallest units (lamports / wei / token units).
+     *               Required for SOL / LIQSOL / ETH / LIQETH.
+     *               Ignored for YIELD (the program uses tracked yield).
+     * @param purchaseAsset Asset used to buy pretoken.
+     * @returns Transaction signature
+     */
+    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: {
+                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 res = await this.sendAndConfirmHttp(signed, prepared);
+        return res.signature;
+    }
+
     /**
      * 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)
+     * wire   = prelaunch WIRE “shares” (UserWarrantRecord.totalWarrantsPurchased, 1e8)
      */
     async getPortfolio(): Promise<Portfolio> {
         const user = this.solPubKey;
@@ -173,12 +230,21 @@ export class SolanaStakingClient implements IStakingClient {
         const trackedAmountStr =
             userRecord?.trackedBalance ? userRecord.trackedBalance.toString() : "0";
 
-        // Snapshot is canonical; receipt may be null if user never staked
+        // Snapshot is canonical; receipt may be null if user never staked/purchased
         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";
 
+        // Prelaunch WIRE "shares" = total warrants purchased by this user (1e8 precision)
+        const wireSharesStr =
+            userWarrantRecord?.totalWarrantsPurchased
+                ? userWarrantRecord.totalWarrantsPurchased.toString()
+                : "0";
+
         return {
             native: {
                 amount: BigInt(nativeLamports),
@@ -196,6 +262,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,8 +278,123 @@ export class SolanaStakingClient implements IStakingClient {
                 reservePoolPDA: reservePoolPDA.toBase58(),
                 vaultPDA: vaultPDA.toBase58(),
                 wireReceipt,
+                userWarrantRecord,
+                // global pretoken context (handy for UI + quoting)
+                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,
+        };
+    }
+
+    /**
+     * Program-level prelaunch WIRE / tranche snapshot for Solana.
+     * Uses the same OutpostWireStateSnapshot primitive as getPortfolio().
+     */
+    async getTrancheSnapshot(): Promise<TrancheSnapshot | null> {
+        const snapshot = await this.outpostClient.getWireStateSnapshot(this.solPubKey);
+        const global = snapshot.globalState;
+        const tranche = snapshot.trancheState;
+
+        if (!global || !tranche) return null;
+        
+        return {
+            chainID: this.network.chainId,
+            totalShares: BigInt(global.totalShares.toString()),
+            currentIndex: BigInt(global.currentIndex.toString()),
+            currentTrancheNumber: BigInt(tranche.currentTrancheNumber.toString()),
+            currentTrancheSupply: BigInt(tranche.currentTrancheSupply.toString()),
+            totalWarrantsSold: BigInt(tranche.totalWarrantsSold.toString()),
+            currentTranchePriceUsd: BigInt(tranche.currentTranchePriceUsd.toString()),
+        };
+    }
+
+    // -------------------------------------------------------------
+    // Prelaunch WIRE quote (pretokens / warrants) – Solana side
+    // -------------------------------------------------------------
+    async getBuyQuote(amount: bigint, purchaseAsset: PurchaseAsset): Promise<PurchaseQuote> {
+        if (amount <= BigInt(0) && purchaseAsset !== PurchaseAsset.YIELD)
+            throw new Error("Buy amount must be greater than zero for non-YIELD purchases.");
+
+        const user = this.solPubKey;
+        const snapshot = await this.outpostClient.getWireStateSnapshot(user);
+        const tranche = snapshot.trancheState;
+
+        if (!tranche) {
+            throw new Error("TrancheState not initialized; cannot quote WIRE purchase.");
+        }
+
+        // WIRE pretoken price in USD (1e8 precision) from liqsol_core.TrancheState
+        const wirePriceUsd = tranche.currentTranchePriceUsd; // BN
+        const wireDecimals = 8;
+
+        let notionalUsd: BN;   // 1e8 USD
+        let wireSharesBn: BN;  // 1e8 WIRE shares
+
+        switch (purchaseAsset) {
+            case PurchaseAsset.SOL: {
+                // SOL price in USD (1e8) – you wire this up in TokenClient using Chainlink / PriceHistory
+                const solPriceUsd = await this.tokenClient.getSolPriceUsd();
+
+                // amount is lamports (1e9). Convert to USD notional:
+                // usdValue = lamports * solPriceUsd / 1e9
+                notionalUsd = new BN(amount)
+                    .mul(solPriceUsd)
+                    .div(new BN(1_000_000_000)); // 10^9
+
+                wireSharesBn = this.calculateExpectedWarrants(notionalUsd, wirePriceUsd);
+                break;
+            }
+
+            case PurchaseAsset.LIQSOL: {
+                // liqSOL price in USD (1e8). In many setups this == SOL price, but you keep it explicit.
+                const liqsolPriceUsd = await this.tokenClient.getSolPriceUsd();
+
+                // liqSOL has 9 decimals as well; treat `amount` as raw token units.
+                notionalUsd = new BN(amount)
+                    .mul(liqsolPriceUsd)
+                    .div(new BN(1_000_000_000)); // 10^9
+
+                wireSharesBn = this.calculateExpectedWarrants(notionalUsd, wirePriceUsd);
+                break;
+            }
+
+            case PurchaseAsset.YIELD: {
+                // For purchase_warrants_from_yield, the on-chain logic effectively consumes
+                // tracked yield (claimBalance / availableBalance) at face value.
+                // You have two options for UI semantics:
+                //   - treat `amount` as a virtual SOL amount and reuse the SOL path, or
+                //   - ignore `amount` and quote based on the user's actual claimBalance.
+                //
+                // Here we keep it simple: `amount` is lamports-equivalent of SOL yield.
+                const solPriceUsd = await this.tokenClient.getSolPriceUsd();
+
+                notionalUsd = new BN(amount)
+                    .mul(solPriceUsd)
+                    .div(new BN(1_000_000_000));
+
+                wireSharesBn = this.calculateExpectedWarrants(notionalUsd, wirePriceUsd);
+                break;
+            }
+
+            case PurchaseAsset.ETH:
+            case PurchaseAsset.LIQETH:
+                throw new Error("getBuyQuote for ETH/LIQETH is not supported on Solana.");
+
+            default:
+                // TS safety – should never hit for your enum
+                throw new Error(`Unsupported purchase asset: ${String(purchaseAsset)}`);
+        }
+
+        return {
+            purchaseAsset,
+            amountIn: amount,
+            wireShares: BigInt(wireSharesBn.toString()),
+            wireDecimals,
+            wirePriceUsd: BigInt(wirePriceUsd.toString()), // 1e8
+            notionalUsd: BigInt(notionalUsd.toString()),   // 1e8
         };
     }
 
@@ -215,12 +402,23 @@ export class SolanaStakingClient implements IStakingClient {
     // SOL-only extras
     // ---------------------------------------------------------------------
 
-    async getUserRecord() {
-        return this.distributionClient.getUserRecord(this.solPubKey);
+    /**
+     * Exact warrant math reused from your old utils, just phrased in terms
+     * of already-computed USD notional:
+     *
+     *   expectedWarrants = (notionalUsd * 1e8) / wirePriceUsd
+     *
+     * where:
+     *   - notionalUsd, wirePriceUsd are 1e8-scaled USD
+     *   - result is 1e8-scaled WIRE "shares"
+     */
+    private calculateExpectedWarrants(notionalUsd: BN, wirePriceUsd: BN): BN {
+        const SCALE = new BN("100000000"); // 1e8
+        return notionalUsd.mul(SCALE).div(wirePriceUsd);
     }
 
-    getProtocolFee() {
-        // TODO
+    async getUserRecord() {
+        return this.distributionClient.getUserRecord(this.solPubKey);
     }
 
     async correctBalance(amount?: bigint): Promise<string> {

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;
+}
+

package/src/networks/solana/utils.ts

@@ -52,6 +52,7 @@ import {
 
 import liqsolCoreIDL from '../../assets/solana/idl/liqsol_core.json';
 import { LiqsolCore } from '../../assets/solana/types/liqsol_core';
+import { TrancheState } from './types';
 
 // -----------------------------------------------------------------------------
 // Read-only liqsol_core Program helper
@@ -68,7 +69,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 +365,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,105 @@
+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(): 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
+};
+
+/**
+ * Program-global prelaunch WIRE / tranche state for a single chain.
+ *
+ * All integer values are raw on-chain integers:
+ *  - `currentTranchePriceUsd`: 1e8 USD
+ *  - supplies / warrants / shares: 1e8 WIRE units (per liqsol_core/ETH analog)
+ *  - index: same scale the program uses (INDEX_SCALE = 1e12 on Solana today)
+ */
+export interface TrancheSnapshot {
+    chainID: ChainID;
+
+    // From GlobalState
+    totalShares: bigint;      // globalState.totalShares
+    currentIndex: bigint;     // globalState.currentIndex
+
+    // From TrancheState
+    currentTrancheNumber: bigint;     // trancheState.currentTrancheNumber
+    currentTrancheSupply: bigint;     // trancheState.currentTrancheSupply
+    totalWarrantsSold: bigint;        // trancheState.totalWarrantsSold
+    currentTranchePriceUsd: bigint;   // trancheState.currentTranchePriceUsd (1e8)
+}
+
+// Enum describing which asset is being used to buy pretoken
+export enum PurchaseAsset {
+    SOL = "SOL",
+    LIQSOL = "LIQSOL",
+    ETH = "ETH",
+    LIQETH = "LIQETH",
+    YIELD = "YIELD",
+}
+
+export interface PurchaseQuote {
+    purchaseAsset: PurchaseAsset;
+    amountIn: bigint;          // smallest unit (lamports / wei / token units)
+    // share info (prelaunch WIRE)
+    wireShares: bigint;        // 1e8 precision
+    wireDecimals: number;      // always 8
+    // pricing info
+    wirePriceUsd: bigint;      // 1e8 precision
+    notionalUsd: bigint;       // 1e8 precision
+}
+

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
-};