@wireio/stake 0.1.3 → 0.2.0

package/src/networks/solana/solana.ts

@@ -6,9 +6,9 @@ import {
     Transaction,
     TransactionSignature,
 } from '@solana/web3.js';
-import { AnchorProvider } from '@coral-xyz/anchor';
+import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { 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 } from '@wireio/core';
 import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
@@ -20,8 +20,9 @@ import {
     deriveReservePoolPda,
     deriveVaultPda,
 } from './constants';
-import { SolanaTransaction, UserRecord } from './types';
+import { SolanaTransaction } from './types';
 import { LeaderboardClient } from './clients/leaderboard.client';
+import { OutpostClient } from './clients/outpost.client';
 
 const commitment: Commitment = 'confirmed';
 
@@ -33,18 +34,15 @@ export class SolanaStakingClient implements IStakingClient {
     private depositClient: DepositClient;
     private distributionClient: DistributionClient;
     private leaderboardClient: LeaderboardClient;
+    private outpostClient: OutpostClient;
 
     get solPubKey(): SolPubKey { return new SolPubKey(this.pubKey.data.array); }
     get network() { return this.config.network; }
 
     constructor(private config: StakerConfig) {
         const adapter = config.provider as BaseSignerWalletAdapter;
-        if (!adapter.publicKey) {
-            throw new Error('Solana wallet adapter not connected');
-        }
-        if (!config.network.rpcUrls.length) {
-            throw new Error('No RPC URLs provided');
-        }
+        if (!adapter?.publicKey) throw new Error('Solana wallet adapter not connected');
+        if (!config.network.rpcUrls.length) throw new Error('No RPC URLs provided');
 
         const publicKey = adapter.publicKey;
         const wirePub = new PublicKey(KeyType.ED, publicKey.toBytes());
@@ -57,9 +55,6 @@ export class SolanaStakingClient implements IStakingClient {
             opts.wsEndpoint = config.network.rpcUrls[1];
         }
 
-        this.pubKey = wirePub;
-        this.connection = new Connection(config.network.rpcUrls[0], opts);
-
         const anchorWallet = {
             publicKey,
             async signTransaction<T extends SolanaTransaction>(tx: T): Promise<T> {
@@ -70,147 +65,180 @@ export class SolanaStakingClient implements IStakingClient {
             },
         };
 
+        this.pubKey = wirePub;
+        this.connection = new Connection(config.network.rpcUrls[0], opts);
         this.anchor = new AnchorProvider(this.connection, anchorWallet, { commitment });
 
         this.depositClient = new DepositClient(this.anchor);
         this.distributionClient = new DistributionClient(this.anchor);
         this.leaderboardClient = new LeaderboardClient(this.anchor);
+        this.outpostClient = new OutpostClient(this.anchor);
     }
 
+    // ---------------------------------------------------------------------
+    // Public IStakingClient Interface Methods
+    // ---------------------------------------------------------------------
+
     /**
-     * Resolve the user's liqSOL ATA and balances + key protocol balances.
-     * native = SOL in wallet
-     * actual  = liqSOL token balance (from ATA)
-     * tracked = liqSOL tracked balance (from Distribution.userRecord)
+     * Deposit SOL into liqSOL protocol (liqsol_core deposit flow).
+     * @param amountLamports Amount of SOL to deposit (smallest unit)
+     * @return Transaction signature
      */
-    async getPortfolio(): Promise<Portfolio> {
-        try {
-            const user = this.solPubKey;
-            const reservePoolPDA = deriveReservePoolPda();
-            const vaultPDA = deriveVaultPda();
-            const liqsolMint = deriveLiqsolMintPda();
-            const userLiqsolAta = getAssociatedTokenAddressSync(
-                liqsolMint,
-                user,
-                false,
-                TOKEN_2022_PROGRAM_ID,
-            );
-
-            // Fetch balances and user record in parallel
-            const [nativeLamports, actualBalResp, userRecord] = await Promise.all([
-                this.connection.getBalance(user),
-                this.connection.getTokenAccountBalance(userLiqsolAta).catch(() => null),
-                this.distributionClient.getUserRecord(user).catch(() => null),
-            ]);
-
-            const actualAmountStr = actualBalResp?.value?.amount ?? '0';
-            const actualDecimals = actualBalResp?.value?.decimals ?? 9;
-
-            const trackedAmountStr = userRecord?.trackedBalance ? userRecord.trackedBalance.toString() : '0';
-            const trackedDecimals = actualDecimals;
-
-            const nativeSymbol = 'SOL';
-            const liqSymbol = 'LiqSOL';
-
-            const portfolio: Portfolio = {
-                native: {
-                    amount: BigInt(nativeLamports),
-                    symbol: nativeSymbol,
-                    decimals: 9,
-                },
-                liq: {
-                    amount: BigInt(actualAmountStr),
-                    symbol: liqSymbol,
-                    decimals: actualDecimals,
-                },
-                staked: { // TODO: fetch staked balance from outpost
-                    amount: BigInt(0),
-                    symbol: liqSymbol,
-                    decimals: actualDecimals,
-                },
-                tracked: { // SOL ONLY
-                    amount: BigInt(trackedAmountStr),
-                    symbol: liqSymbol,
-                    decimals: trackedDecimals,
-                },
-                extras: {
-                    userLiqsolAta: userLiqsolAta.toBase58(),
-                    reservePoolPDA: reservePoolPDA.toBase58(),
-                    vaultPDA: vaultPDA.toBase58(),
-                },
-                chainID: this.network.chainId
-            };
-
-            // console.log('SOL PORTFOLIO', portfolio);
-            return portfolio;
-        }
-        catch (error) {
-            console.log('Error in getPortfolio:', error);
-            throw error;
-        }
+    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());
+        const tx = await this.depositClient.buildDepositTx(amountLamports);
+        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;
     }
 
     /**
-     * Optional: fetch your Distribution program user record
-     * (often contains per-user deposit/claim state).
-     * @returns UserRecord or null
+     * Withdraw SOL from liqSOL protocol.
+     * (Wire up once you have DepositClient.buildWithdrawTx or equivalent.)
      */
-    async getUserRecord() {
-        return this.distributionClient.getUserRecord(this.solPubKey);
+    async withdraw(amountLamports: bigint): Promise<string> {
+        throw new Error('Withdraw method not yet implemented.');
     }
 
-    getProtocolFee() {
-        // TODO: wire to pay-rate math once we finalize protocol fee API
+    /**
+     * Stake liqSOL into Outpost (liqSOL -> pool).
+     * Matches deposit flow: build -> prepare -> sign -> send/confirm.
+     * @param amountLamports Amount of liqSOL to stake (smallest unit)
+     */
+    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);
+        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;
     }
 
     /**
-     * Deposit funds into the staking pool.
-     * @param lamports The amount to deposit (in lamports).
-     * @returns The transaction signature.
+     * Unstake liqSOL from Outpost (pool -> liqSOL).
+     * Matches deposit flow: build -> prepare -> sign -> send/confirm.
+     * @param amountLamports Amount of liqSOL principal to unstake (smallest unit)
      */
-    async deposit(lamports: number): Promise<string> {
-        const { transaction } = await this.depositClient.buildDepositTx(this.solPubKey, lamports);
-        const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(transaction);
-        const signed = await this.signTransaction(tx);
-        const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
+    async unstake(amountLamports: bigint): Promise<string> {
+        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 tx = new Transaction().add(...preIxs, withdrawIx);
+        const prepared = await this.prepareTx(tx);
+        const signed = await this.signTransaction(prepared.tx);
+        const result = await this.sendAndConfirmHttp(signed, prepared);
         return result.signature;
     }
 
     /**
-     * Build, sign, and submit a single transaction that:
-     *  - Corrects other users (if needed) to free available balance, then
-     *  - Registers the caller’s untracked liqSOL.
-     *
-     * @param amount  Optional: register a smaller amount than your full untracked balance.
-     * @returns signature string
+     * 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)
      */
+    async getPortfolio(): Promise<Portfolio> {
+        const user = this.solPubKey;
+
+        const reservePoolPDA = deriveReservePoolPda();
+        const vaultPDA = deriveVaultPda();
+        const liqsolMint = deriveLiqsolMintPda();
+
+        const userLiqsolAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            user,
+            false,
+            TOKEN_2022_PROGRAM_ID,
+            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),
+            this.distributionClient.getUserRecord(user).catch(() => null),
+            this.outpostClient.getWireStateSnapshot(user).catch(() => null),
+        ]);
+
+        const LIQSOL_DECIMALS = 9;
+
+        const actualAmountStr = actualBalResp?.value?.amount ?? "0";
+
+        const trackedAmountStr =
+            userRecord?.trackedBalance ? userRecord.trackedBalance.toString() : "0";
+
+        // Snapshot is canonical; receipt may be null if user never staked
+        const wireReceipt = snapshot?.wireReceipt ?? null;
+
+        const stakedAmountStr =
+            wireReceipt?.stakedLiqsol ? wireReceipt.stakedLiqsol.toString() : "0";
+
+        return {
+            native: {
+                amount: BigInt(nativeLamports),
+                symbol: "SOL",
+                decimals: 9,
+            },
+            liq: {
+                amount: BigInt(actualAmountStr),
+                symbol: "LiqSOL",
+                decimals: LIQSOL_DECIMALS,
+                ata: userLiqsolAta,
+            },
+            staked: {
+                amount: BigInt(stakedAmountStr),
+                symbol: "LiqSOL",
+                decimals: LIQSOL_DECIMALS,
+            },
+            tracked: {
+                amount: BigInt(trackedAmountStr),
+                symbol: "LiqSOL",
+                decimals: LIQSOL_DECIMALS,
+            },
+            extras: {
+                userLiqsolAta: userLiqsolAta.toBase58(),
+                reservePoolPDA: reservePoolPDA.toBase58(),
+                vaultPDA: vaultPDA.toBase58(),
+                wireReceipt,
+            },
+            chainID: this.network.chainId as ChainID,
+        };
+    }
+
+    // ---------------------------------------------------------------------
+    // SOL-only extras
+    // ---------------------------------------------------------------------
+
+    async getUserRecord() {
+        return this.distributionClient.getUserRecord(this.solPubKey);
+    }
+
+    getProtocolFee() {
+        // TODO
+    }
+
     async correctBalance(amount?: bigint): Promise<string> {
-        try {
-            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 signed = await this.signTransaction(tx);
-            const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
-
-            console.log('Registered:', {
-                needToRegister: build.needToRegister,
-                freed: build.plan.willFree,
-                corrected: build.plan.selected.map((c) => ({
-                    owner: c.owner?.toBase58(),
-                    delta: c.delta?.toString(),
-                })),
-            });
-
-            return result.signature;
-        } catch (error) {
-            console.error('Error in register:', error);
-            throw error;
+        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 signed = await this.signTransaction(tx);
+        const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
+        return result.signature;
     }
 
+    // ---------------------------------------------------------------------
+    // Tx helpers
+    // ---------------------------------------------------------------------
+
     private async sendAndConfirmHttp(
         signed: SolanaTransaction,
         ctx: { blockhash: string; lastValidBlockHeight: number },
@@ -226,10 +254,10 @@ export class SolanaStakingClient implements IStakingClient {
             commitment,
         );
 
-        const ok = !conf.value.err;
-        if (!ok) {
+        if (conf.value.err) {
             throw new Error(`Transaction failed: ${JSON.stringify(conf.value.err)}`);
         }
+
         return { signature, slot: conf.context.slot, confirmed: true };
     }
 
@@ -247,7 +275,6 @@ export class SolanaStakingClient implements IStakingClient {
         const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash('confirmed');
         tx.recentBlockhash = blockhash;
         tx.feePayer = this.solPubKey;
-
         return { tx, blockhash, lastValidBlockHeight };
     }
 }

package/src/networks/solana/types.ts

@@ -1,20 +1,20 @@
-import { PublicKey, StakeActivationData, TokenAmount, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { PublicKey, TokenAmount, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { BN } from '@coral-xyz/anchor';
 
 export type SolanaTransaction = Transaction | VersionedTransaction
 
+export type WalletLike = {
+    publicKey: PublicKey;
+    signTransaction: (tx: Transaction) => Promise<Transaction>;
+    signAllTransactions?: (txs: Transaction[]) => Promise<Transaction[]>;
+};
+
 export type UserRecord = {
     userAta: PublicKey;
     trackedBalance: bigint;       // What we think they have (for reward calculations)
     claimBalance: bigint;         // Accumulated unclaimed rewards
     lastClaimTimestamp: bigint;  // When they last claimed (unix timestamp)
     bump: number;
-} 
-
-export type DistributionState = {
-    liqsolMint: PublicKey;
-    availableBalance: bigint;
-    totalTrackedBalance: bigint; 
-    bump: number;
 }
 
 export type ParsedAccountInfo = {
@@ -44,4 +44,91 @@ export interface CorrectRegisterBuildResult {
     reason?: string;
     transaction?: Transaction;
     plan: CorrectRegisterPlan;
+}
+
+/**
+ * Wallet interface compatible with AnchorProvider.
+ * (Phantom, Solflare, Backpack, etc.)
+ */
+export type OutpostWireStateSnapshot = {
+    globalState: GlobalState;
+    distributionState: DistributionState;
+
+    wireReceipt: WireReceipt | null;
+    trancheState: TrancheState | null;
+    userWarrantRecord: UserWarrantRecord | null;
+
+    // balances
+    liqsolPoolBalance: BN;     // token amount in pool ATA
+    solBucketLamports: number; // lamports in sol bucket PDA
+    userLiqsolBalance: BN;     // token amount in user ATA
+};
+
+export type DistributionState = {
+    liqsolMint: PublicKey;
+    availableBalance: bigint;
+    totalTrackedBalance: bigint;
+    bump: number;
+}
+
+export type SharesPreview = {
+    amountLamports: BN;
+    currentIndex: BN;
+    indexScale: BN;
+    expectedShares: BN;
+};
+
+export type GlobalState = {
+    admin: PublicKey;
+    dDay: boolean;
+    refundActive: boolean;
+    deployedAt: BN;
+    refundDelaySeconds: BN;
+    paused: boolean;
+    totalStakedLiqsol: BN;
+    totalPurchasedLiqsol: BN;
+    totalPurchasedSol: BN;
+    totalShares: BN;
+    currentIndex: BN;
+    lastPoolLiqsolBalance: BN;
+    lastPoolSolBalance: BN;
+    yieldAccumulatedSolEq: BN;
+    bump: number;
+}
+
+export type UserWarrantRecord = {
+    user: PublicKey;
+    totalSolDeposited: BN;
+    totalWarrantsPurchased: BN;
+    lastTrancheNumber: BN;
+    lastTranchePriceUsd: BN;
+    bump: number;
+}
+
+export type TrancheState = {
+    admin: PublicKey;
+    currentTrancheNumber: BN;
+    currentTrancheSupply: BN;
+    currentTranchePriceUsd: BN;
+    totalWarrantsSold: BN;
+    initialTrancheSupply: BN;
+    supplyGrowthBps: number;
+    priceGrowthBps: number;
+    minPriceUsd: BN;
+    maxPriceUsd: BN;
+    maxStalenessSeconds: BN;
+    chainlinkProgram: PublicKey;
+    chainlinkFeed: PublicKey;
+    bump: number;
+}
+
+export type WireReceipt = {
+    user: PublicKey;
+    stakedLiqsol: BN;
+    stakedShares: BN;
+    purchasedLiqsol: BN;
+    purchasedShares: BN;
+    purchasedWithSol: BN;
+    purchasedSolShares: BN;
+    bump: number;
 }