@wireio/stake 0.0.6 → 0.1.0

package/src/networks/solana/solana.ts

@@ -1,45 +1,43 @@
 import {
     Connection,
     PublicKey as SolPubKey,
-    Transaction,
-    VersionedTransaction,
     TransactionSignature,
     Commitment,
+    ConnectionConfig,
+    Transaction,
 } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { IStakingClient, SolanaTransaction, StakerConfig } from '../../staker/types';
+import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
 import { ChainID, ExternalNetwork, KeyType, PublicKey } from '@wireio/core';
 import { DepositClient } from './clients/deposit.client';
+import { deriveStakeControllerReservePoolPDA, deriveStakeControllerVaultPDA, getUserLiqsolATA } from './constants';
 import { DistributionClient } from './clients/distribution.client';
-import { ValidatorLeaderboardClient } from './clients/leaderboard.client';
+import { SolanaTransaction } from './types';
+// import { ValidatorLeaderboardClient } from './clients/leaderboard.client';
 
 const commitment: Commitment = 'confirmed';
 
 export class SolanaStakingClient implements IStakingClient {
     public pubKey: PublicKey;
-    public network: ExternalNetwork;
-
     public connection: Connection;
     public anchor: AnchorProvider;
 
     private depositClient: DepositClient;
     private distributionClient: DistributionClient;
-    private leaderboardClient: ValidatorLeaderboardClient;
-
-    balanceNative: number = 0;
-    balanceLiquid: number = 0;
+    // private leaderboardClient: ValidatorLeaderboardClient;
 
     get solPubKey(): SolPubKey {
         return new SolPubKey(this.pubKey.data.array);
     }
 
+    get network() { return this.config.network; }
+
     constructor(private config: StakerConfig) {
         // 1) unwrap & validate wallet adapter
         const adapter = config.provider as BaseSignerWalletAdapter;
-        if (!adapter.publicKey) {
-            throw new Error('Solana wallet adapter not connected');
-        }
+        if (!adapter.publicKey) throw new Error('Solana wallet adapter not connected');
+        if (!config.network.rpcUrls.length) throw new Error('No RPC URLs provided');
 
         // 2) sanity‐check wire ↔ solana pubkey
         const publicKey = adapter.publicKey;
@@ -48,10 +46,14 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error('Passed-in pubKey doesn\'t match adapter.publicKey');
         }
 
-        this.network = config.network;
+        // build connection config
+        let opts: ConnectionConfig = { commitment }
+        if (config.network.rpcUrls.length > 1 && config.network.rpcUrls[1].startsWith('ws')) {
+            opts.wsEndpoint = config.network.rpcUrls[1];
+        }
+
         this.pubKey = wirePub;
-        this.connection = new Connection(config.network.rpcUrls[0], commitment);
-        this.setBalances();
+        this.connection = new Connection(config.network.rpcUrls[0], opts);
 
         const anchorWallet = {
             publicKey,
@@ -63,27 +65,122 @@ export class SolanaStakingClient implements IStakingClient {
             },
         };
 
-        this.anchor = new AnchorProvider(
-            this.connection,
-            anchorWallet,
-            { commitment }
-        );
+        this.anchor = new AnchorProvider(this.connection, anchorWallet, { commitment });
 
         // 4) staking clients
         this.depositClient = new DepositClient(this.anchor);
         this.distributionClient = new DistributionClient(this.anchor);
-        this.leaderboardClient = new ValidatorLeaderboardClient(this.anchor);
+        // this.leaderboardClient = new ValidatorLeaderboardClient(this.anchor);
     }
 
     /**
-     * Update the native and liquid balances.
-     * @returns The updated balances.
+     * 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)
      */
-    async setBalances() {
-        this.balanceNative = await this.connection.getBalance(this.solPubKey);
-        this.balanceLiquid = 0; // TODO fetch liq balance
+    async getPortfolio(): Promise<Portfolio> {
+        const user = this.solPubKey;
+
+        // Handy PDAs & ATA
+        const [reservePoolPDA] = deriveStakeControllerReservePoolPDA();
+        const [vaultPDA] = deriveStakeControllerVaultPDA();
+        const userLiqsolAta = getUserLiqsolATA(user);
+
+        // Pull balances in parallel; ATA may not exist yet
+        const [nativeLamports, actualBalResp, userRecord] = await Promise.all([
+            this.connection.getBalance(user),
+            this.connection.getTokenAccountBalance(userLiqsolAta).catch(() => null),
+            this.distributionClient.getUserRecord(user).catch(() => null),
+        ]);
+
+        // Actual (LiqSOL) balance + decimals (fallback to 9 if ATA missing)
+        const actualAmountStr = actualBalResp?.value?.amount ?? '0';
+        const actualDecimals = actualBalResp?.value?.decimals ?? 9;
+
+        // Tracked (from userRecord in Distribution program)
+        const trackedAmountStr = userRecord?.trackedBalance
+            ? (userRecord.trackedBalance as any).toString()
+            : '0';
+        const trackedDecimals = actualDecimals; // same mint as liqSOL
+
+        // Assemble the portfolio
+        const portfolio: Portfolio = {
+            native: {
+                symbol: 'SOL',
+                decimals: 9,
+                amount: BigInt(nativeLamports),
+            },
+            actual: {
+                symbol: 'LiqSOL',
+                decimals: actualDecimals,
+                amount: BigInt(actualAmountStr),
+            },
+            tracked: {
+                symbol: 'LiqSOL',
+                decimals: trackedDecimals,
+                amount: BigInt(trackedAmountStr),
+            },
+            extras: {
+                userLiqsolAta: userLiqsolAta.toBase58(),
+                reservePoolPDA: reservePoolPDA.toBase58(),
+                vaultPDA: vaultPDA.toBase58(),
+            },
+        };
 
-        return { native: this.balanceNative, liquid: this.balanceLiquid };
+        // console.log('>> PORTFOLIO SET', this.network.name, this.portfolio);
+        return portfolio;
+    }
+    /**
+     * Optional: fetch your Distribution program user record
+     * (often contains per-user deposit/claim state).
+     */
+    async getUserRecord(): Promise<any | null> {
+        return this.distributionClient.getUserRecord(this.solPubKey);
+    }
+
+    getProtocolFee() {
+
+    }
+
+    /**
+     * 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
+     */
+    async register(amount?: bigint): Promise<string> {
+        try {
+            console.log('Building CorrectAndRegister transaction with amount:', amount);
+
+            // Build the transaction using the Distribution client (self = this.solPubKey)
+            const build = await this.distributionClient.buildCorrectRegisterTx({ amount });
+            if (!build.canSucceed || !build.transaction)
+                throw new Error(build.reason ?? 'Unable to build Correct&Register transaction');
+
+            console.log('buildCorrectRegisterTx:', build);
+
+            const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(build.transaction);
+            const signed = await this.signTransaction(tx);
+            const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
+
+            // Optionally refresh portfolio after success (non-blocking)
+            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;
+        }
     }
 
     /**
@@ -92,12 +189,35 @@ export class SolanaStakingClient implements IStakingClient {
      * @returns The transaction signature.
      */
     async deposit(lamports: number): Promise<string> {
-        const tx = await this.depositClient.buildDepositTx(
-            this.solPubKey,
-            lamports,
+        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 });
+        return result.signature;
+    }
+
+    private async sendAndConfirmHttp(
+        signed: SolanaTransaction,
+        ctx: { blockhash: string; lastValidBlockHeight: number }
+    ): Promise<TxResult> {
+        // sendRawTransaction is HTTP
+        const signature = await this.connection.sendRawTransaction(signed.serialize(), {
+            skipPreflight: false,
+            preflightCommitment: commitment,
+            maxRetries: 3,
+        });
+
+        // Poll confirmation using blockhash/lastValidBlockHeight
+        const conf = await this.connection.confirmTransaction(
+            { signature, blockhash: ctx.blockhash, lastValidBlockHeight: ctx.lastValidBlockHeight },
+            commitment
         );
-        const signed = await this.signTransaction(tx.transaction);
-        return this.sendTransaction(signed);
+
+        const ok = !conf.value.err;
+        if (!ok) {
+            throw new Error(`Transaction failed: ${JSON.stringify(conf.value.err)}`);
+        }
+        return { signature, slot: conf.context.slot, confirmed: true };
     }
 
     async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
@@ -107,4 +227,18 @@ export class SolanaStakingClient implements IStakingClient {
     async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
         return await this.anchor.sendAndConfirm(signed);
     }
-}
+
+    async prepareTx(tx: Transaction): Promise<{ tx: Transaction; blockhash: string; lastValidBlockHeight: number }> {
+        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

@@ -0,0 +1,57 @@
+import { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+
+export type SolanaTransaction = Transaction | VersionedTransaction
+
+/** Raw mismatch row (per user with a userRecord) */
+export type MismatchCandidate = {
+    /** Wallet that owns the ATA (decoded from token account) */
+    owner: PublicKey;
+    /** user_record PDA */
+    userRecordPda: PublicKey;
+    /** user’s ATA for liqSOL */
+    userAta: PublicKey;
+    /** protocol tracked balance (u64) */
+    tracked: bigint;
+    /** actual on-chain token balance (u64) */
+    actual: bigint;
+    /** tracked - actual (positive means “freeable”) */
+    delta: bigint;
+};
+
+/** Output when choosing candidates to free liquidity */
+export type CorrectionPlan = {
+    /** selected candidates sorted by delta desc */
+    selected: MismatchCandidate[];
+    /** total delta we’ll free by correcting selected */
+    willFree: bigint;
+    /** how much still missing after selection (0 if we can meet the target) */
+    deficit: bigint;
+};
+
+/** What the builder returns to your caller/UI */
+export type CorrectAndRegisterBuild = {
+    /** The ready-to-send transaction (if buildable) */
+    transaction?: Transaction;
+    /** True if the tx can succeed with current state */
+    canSucceed: boolean;
+    /** Explanation if not buildable */
+    reason?: string;
+
+    /** Current liqSOL mint; useful for UI */
+    liqsolMint: PublicKey;
+    /** Amount you need to register (actual - tracked if positive) */
+    needToRegister: bigint;
+    /** Distribution “availableBalance” before this action */
+    availableBefore: bigint;
+
+    /** Candidates we scanned (already sorted by delta desc) */
+    candidates: MismatchCandidate[];
+    /** Subset we’d correct (maybe empty) */
+    plan: CorrectionPlan;
+
+    /** Convenience for caller */
+    accounts: {
+        selfUserRecordPda: PublicKey;
+        selfUserAta: PublicKey;
+    };
+};

package/src/scripts/fetch-artifacts.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+set -e
+
+# Define variables
+IDL_ZIP_URL="https://bucket.gitgo.app/solana/idl.zip"
+TYPES_ZIP_URL="https://bucket.gitgo.app/solana/types.zip"
+DEST_DIR="$(dirname "$0")/../assets/solana"
+TMP_DIR="$(mktemp -d)"
+
+# Download the zip files
+curl -L "$IDL_ZIP_URL" -o "$TMP_DIR/idl.zip"
+curl -L "$TYPES_ZIP_URL" -o "$TMP_DIR/types.zip"
+
+# Create destination directory if it doesn't exist
+mkdir -p "$DEST_DIR"
+
+# Unzip into the destination directory
+unzip -o "$TMP_DIR/idl.zip" -d "$DEST_DIR"
+unzip -o "$TMP_DIR/types.zip" -d "$DEST_DIR"
+
+# Clean up
+rm -rf "$TMP_DIR"
+
+echo "IDL and types files fetched and extracted to $DEST_DIR"

package/src/staker/staker.ts

@@ -1,14 +1,34 @@
 // src/staker/staker.ts
 
-import { ChainID, Curve, EvmChainID, SolChainID } from '@wireio/core';
-import { IStakingClient, StakeBalance, StakerConfig } from './types';
+import { ChainID, SolChainID } from '@wireio/core';
+import { IStakingClient, StakerConfig } from './types';
 import { SolanaStakingClient } from '../networks/solana/solana';
-import { EthereumStakingClient } from '../networks/ethereum/ethereum';
 
 export class Staker {
+    public selectedChainID?: ChainID;
     private clients: Map<ChainID, IStakingClient> = new Map();
 
-    constructor(config: StakerConfig | StakerConfig[]) {
+    /**
+     * Get the staking client for the currently selected chain.
+     * @returns The staking client instance.
+     */
+    get client(): IStakingClient | undefined {
+        return this.selectedChainID && this.isConfigured(this.selectedChainID)
+            ? this.clients.get(this.selectedChainID) : undefined;
+    }
+
+    /** Is there a client configured for this chain? */
+    isConfigured(chainId: ChainID): boolean {
+        return this.clients.has(chainId);
+    }
+
+    /** List of configured chains */
+    listConfigured(): ChainID[] {
+        return [...this.clients.keys()];
+    }
+
+    constructor(config: StakerConfig | StakerConfig[], selectedChainID?: ChainID) {
+        if (!config) throw new Error('StakerConfig is required');
         if (!Array.isArray(config)) config = [config];
 
         config.forEach((cfg) => {
@@ -21,36 +41,20 @@ export class Staker {
                 //     this.clients.set(EvmChainID.Sepolia, new EthereumStakingClient(cfg));
                 //     break;
                 default:
-                    throw new Error(`Unsupported network curve: ${cfg.network.name}`);
+                    // console.log(`No staking client available for chain ${cfg.network.chainId}`);
+                    // throw new Error(`Unsupported network curve: ${cfg.network.name}`);
             }
         });
-    }
-
-    /** Return the raw client (if any) for a chain */
-    getClient(chainId: ChainID): IStakingClient | undefined {
-        return this.clients.get(chainId);
-    }
 
-    /** Convenience: ensure a client exists or throw a friendly error */
-    private ensureClient(chainId: ChainID): IStakingClient {
-        const c = this.clients.get(chainId);
-        if (!c) throw new Error(`Staker not initialized for chain ${chainId}`);
-        return c;
+        this.selectedChainID = selectedChainID;
     }
 
     /**
-     * Deposit funds into the staking pool.
-     * @param chainId The chain ID to deposit into.
-     * @param amount The amount to deposit (in smallest unit i.e. Lamport or Wei).
-     * @returns The transaction signature.
+     * Select a chain. Returns true if a client exists for it, false otherwise.
+     * (We still record the selectedChainID so the UI can reflect the chosen chain.)
      */
-    deposit(chainId: ChainID, amount: number): Promise<string> {
-        return this.ensureClient(chainId).deposit(amount);
+    setChain(chainID: ChainID): boolean {
+        this.selectedChainID = chainID;
+        return this.clients.has(chainID);
     }
-
-    getBalance(chainId: ChainID): Promise<StakeBalance> {
-        return this.ensureClient(chainId).setBalances();
-    }
-
-    // …withdraw, claimRewards, etc…
 }

package/src/staker/types.ts

@@ -1,41 +1,44 @@
 // types.ts
 
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { Transaction, VersionedTransaction } from '@solana/web3.js';
-import { ChainID, Curve, ExternalNetwork, ProviderType, PublicKey } from '@wireio/core';
+import { PublicKey as SolPubKey } from '@solana/web3.js';
+import { ExternalNetwork, PublicKey } from '@wireio/core';
 import { ethers } from 'ethers';
 
-export type SolanaTransaction = Transaction | VersionedTransaction
-export interface IStakingClient{
+export interface IStakingClient {
     pubKey: PublicKey;
     network: ExternalNetwork;
 
-    balanceNative: number;
-    balanceLiquid: number;
-
     /** Amount is in the chain's smallest unit (lamports/wei, etc.) */
     deposit(amount: number): Promise<string>;
 
-    /** Update the native and liquid balances. */
-    setBalances(): Promise<StakeBalance>;
-
-    // /** Return native balance in the chain’s smallest unit (lamports for Sol) */
-    // getBalanceNative(): Promise<number>;
+    /** Register any untracked LIQ staked tokens */
+    register(): Promise<string>;
 
-    // /** Return liquid balance in the chain’s smallest unit (lamports for Sol) */
-    // getBalanceLiquid(): Promise<number>;
+    /** Fetch the portfolio for the LIQ stake user */
+    getPortfolio(): Promise<Portfolio>;
 }
 
-/**
- * Union config for our unified Staker
- */
 export type StakerConfig = {
     network: ExternalNetwork;
     provider: BaseSignerWalletAdapter | ethers.providers.Web3Provider;
     pubKey: PublicKey;
 }
 
-export interface StakeBalance {
-    native: number;
-    liquid: number;
-}
+export interface Portfolio {
+    /** Native SOL balance on chain */
+    native: BalanceView;
+    /** Actual liquid SOL balance from ATA */
+    actual: BalanceView;
+    /** Tracked liquid SOL balance from distribution program */
+    tracked: BalanceView;
+    /** Extra PDAs and account addresses */
+    extras?: Record<string, any>;
+}
+
+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
+};