@wireio/stake 0.1.0 → 0.1.2

package/src/networks/solana/solana.ts

@@ -1,20 +1,27 @@
 import {
-    Connection,
-    PublicKey as SolPubKey,
-    TransactionSignature,
     Commitment,
+    Connection,
     ConnectionConfig,
+    PublicKey as SolPubKey,
     Transaction,
+    TransactionSignature,
 } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
+import { 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 { DepositClient } from './clients/deposit.client';
-import { deriveStakeControllerReservePoolPDA, deriveStakeControllerVaultPDA, getUserLiqsolATA } from './constants';
 import { DistributionClient } from './clients/distribution.client';
-import { SolanaTransaction } from './types';
-// import { ValidatorLeaderboardClient } from './clients/leaderboard.client';
+import {
+    deriveLiqsolMintPda,
+    deriveReservePoolPda,
+    deriveVaultPda,
+} from './constants';
+import { SolanaTransaction, UserRecord } from './types';
+import { LeaderboardClient } from './clients/leaderboard.client';
 
 const commitment: Commitment = 'confirmed';
 
@@ -25,29 +32,27 @@ export class SolanaStakingClient implements IStakingClient {
 
     private depositClient: DepositClient;
     private distributionClient: DistributionClient;
-    // private leaderboardClient: ValidatorLeaderboardClient;
-
-    get solPubKey(): SolPubKey {
-        return new SolPubKey(this.pubKey.data.array);
-    }
+    private leaderboardClient: LeaderboardClient;
 
+    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 (!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');
+        }
 
-        // 2) sanity‐check wire ↔ solana pubkey
         const publicKey = adapter.publicKey;
         const wirePub = new PublicKey(KeyType.ED, publicKey.toBytes());
         if (!wirePub.equals(config.pubKey)) {
-            throw new Error('Passed-in pubKey doesn\'t match adapter.publicKey');
+            throw new Error("Passed-in pubKey doesn't match adapter.publicKey");
         }
 
-        // build connection config
-        let opts: ConnectionConfig = { commitment }
+        const opts: ConnectionConfig = { commitment };
         if (config.network.rpcUrls.length > 1 && config.network.rpcUrls[1].startsWith('ws')) {
             opts.wsEndpoint = config.network.rpcUrls[1];
         }
@@ -67,10 +72,9 @@ export class SolanaStakingClient implements IStakingClient {
 
         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 LeaderboardClient(this.anchor);
     }
 
     /**
@@ -80,67 +84,96 @@ export class SolanaStakingClient implements IStakingClient {
      * tracked = liqSOL tracked balance (from Distribution.userRecord)
      */
     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(),
-            },
-        };
-
-        // console.log('>> PORTFOLIO SET', this.network.name, this.portfolio);
-        return 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;
+        }
     }
+
     /**
      * Optional: fetch your Distribution program user record
      * (often contains per-user deposit/claim state).
+     * @returns UserRecord or null
      */
-    async getUserRecord(): Promise<any | null> {
+    async getUserRecord() {
         return this.distributionClient.getUserRecord(this.solPubKey);
     }
 
     getProtocolFee() {
+        // TODO: wire to pay-rate math once we finalize protocol fee API
+    }
 
+    /**
+     * Deposit funds into the staking pool.
+     * @param lamports The amount to deposit (in lamports).
+     * @returns The transaction signature.
+     */
+    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 });
+        return result.signature;
     }
 
     /**
@@ -151,29 +184,24 @@ export class SolanaStakingClient implements IStakingClient {
      * @param amount  Optional: register a smaller amount than your full untracked balance.
      * @returns signature string
      */
-    async register(amount?: bigint): Promise<string> {
+    async correctBalance(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)
+            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(),
-                }))
+                corrected: build.plan.selected.map((c) => ({
+                    owner: c.owner?.toBase58(),
+                    delta: c.delta?.toString(),
+                })),
             });
 
             return result.signature;
@@ -183,34 +211,19 @@ export class SolanaStakingClient implements IStakingClient {
         }
     }
 
-    /**
-     * Deposit funds into the staking pool.
-     * @param lamports The amount to deposit (in lamports).
-     * @returns The transaction signature.
-     */
-    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 });
-        return result.signature;
-    }
-
     private async sendAndConfirmHttp(
         signed: SolanaTransaction,
-        ctx: { blockhash: string; lastValidBlockHeight: number }
+        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
+            commitment,
         );
 
         const ok = !conf.value.err;
@@ -221,14 +234,16 @@ export class SolanaStakingClient implements IStakingClient {
     }
 
     async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
-        return await this.anchor.wallet.signTransaction(tx);
+        return this.anchor.wallet.signTransaction(tx);
     }
 
     async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
-        return await this.anchor.sendAndConfirm(signed);
+        return this.anchor.sendAndConfirm(signed);
     }
 
-    async prepareTx(tx: Transaction): Promise<{ tx: Transaction; blockhash: string; lastValidBlockHeight: number }> {
+    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;
@@ -241,4 +256,4 @@ export interface TxResult {
     signature: string;
     slot: number;
     confirmed: boolean;
-};
+}

package/src/networks/solana/types.ts

@@ -1,57 +1,47 @@
-import { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { PublicKey, StakeActivationData, TokenAmount, 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 */
+export type UserRecord = {
     userAta: PublicKey;
-    /** protocol tracked balance (u64) */
-    tracked: bigint;
-    /** actual on-chain token balance (u64) */
-    actual: bigint;
-    /** tracked - actual (positive means “freeable”) */
-    delta: bigint;
+    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 = {
+    extensions: Array<{ extension: string }>;
+    isNative: boolean;
+    mint: string;
+    owner: string;
+    state: string;
+    tokenAmount: TokenAmount
 };
+export interface MismatchCandidate {
+    owner: PublicKey;
+    actual: bigint;
+    tracked: bigint;
+    delta: bigint; // tracked - actual
+}
 
-/** 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) */
+export interface CorrectRegisterPlan {
     deficit: bigint;
-};
+    willFree: bigint;
+    selected: MismatchCandidate[];
+}
 
-/** 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 */
+export interface CorrectRegisterBuildResult {
+    needToRegister: boolean;
     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;
-    };
-};
+    transaction?: Transaction;
+    plan: CorrectRegisterPlan;
+}