@wireio/stake 2.2.2 → 2.3.1

package/src/networks/solana/clients/distribution.client.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
-import { PublicKey } from '@solana/web3.js';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
 
 import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
 import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
@@ -7,6 +7,8 @@ import type { DistributionState, DistributionUserRecord, GlobalConfig, PayRateEn
 import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 import { ceilDiv } from '../utils';
 
+const INDEX_SCALE_BN = new BN('1000000000000');
+
 /**
  * Distribution client – wraps the distribution portion of the liqsol_core
  * program in the *new* shares-only model.
@@ -39,6 +41,15 @@ export class DistributionClient {
         return this.provider.connection;
     }
 
+    private async getTokenBalance(ata: PublicKey): Promise<BN> {
+        try {
+            const bal = await this.connection.getTokenAccountBalance(ata);
+            return new BN(bal.value.amount);
+        } catch {
+            return new BN(0);
+        }
+    }
+
     /**
      * Fetch the global distribution state account.
      *
@@ -162,6 +173,107 @@ export class DistributionClient {
         return { shares: userShares, totalShares, ratio };
     }
 
+    /**
+     * Compute claimable liqSOL for a wallet:
+     * claimable = max(0, entitled - actual)
+     * entitled = floor(shares * syncedIndex / 1e12)
+     *
+     * `syncedIndex` mirrors on-chain `sync_index` behavior by incorporating any
+     * unsynced bucket delta (bucket_balance - last_bucket_balance).
+     */
+    async getClaimableLiqsol(user: PublicKey): Promise<BN> {
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+
+        const userAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            user,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        const [distributionState, userRecord, actualBalance, bucketBalance] = await Promise.all([
+            this.getDistributionState(),
+            this.getUserRecord(user),
+            this.getTokenBalance(userAta),
+            this.getTokenBalance(bucketTokenAccount),
+        ]);
+
+        if (!distributionState || !userRecord) {
+            return new BN(0);
+        }
+
+        let syncedIndex = new BN(distributionState.currentIndex.toString());
+        const totalShares = new BN(distributionState.totalShares.toString());
+        const lastBucketBalance = new BN(distributionState.lastBucketBalance.toString());
+
+        if (totalShares.gt(new BN(0)) && bucketBalance.gt(lastBucketBalance)) {
+            const delta = bucketBalance.sub(lastBucketBalance);
+            const indexDelta = delta.mul(INDEX_SCALE_BN).div(totalShares);
+            if (indexDelta.gt(new BN(0))) {
+                syncedIndex = syncedIndex.add(indexDelta);
+            }
+        }
+
+        const shares = new BN(userRecord.shares.toString());
+        const entitled = shares.mul(syncedIndex).div(INDEX_SCALE_BN);
+
+        if (entitled.lte(actualBalance)) {
+            return new BN(0);
+        }
+        return entitled.sub(actualBalance);
+    }
+
+    /**
+     * Build claim_rewards instruction for a wallet.
+     */
+    async buildClaimRewardsIx(user: PublicKey): Promise<TransactionInstruction> {
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+
+        const userAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            user,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
+        const bucketUserRecord = this.pgs.deriveUserRecordPda(bucketTokenAccount);
+        const extraAccountMetaList = this.pgs.deriveExtraAccountMetaListPda(liqsolMint);
+
+        return this.program.methods
+            .claimRewards()
+            .accounts({
+                user,
+                userAta,
+                userRecord,
+                bucketUserRecord,
+                distributionState,
+                extraAccountMetaList,
+                liqsolCoreProgram: this.pgs.PROGRAM_IDS.LIQSOL_CORE,
+                transferHookProgram: this.pgs.PROGRAM_IDS.TRANSFER_HOOK,
+                liqsolMint,
+                bucketAuthority,
+                bucketTokenAccount,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+            })
+            .instruction();
+    }
+
     /**
      * Compute an average scaled pay rate over the most recent `windowSize`
      * valid entries in the pay-rate history circular buffer.
@@ -243,4 +355,4 @@ export class DistributionClient {
         // Same behavior as the dashboard: use a ceiling-like average
         return ceilDiv(sum, new BN(valid));
     }
-}
+}

package/src/networks/solana/solana.ts

@@ -42,7 +42,7 @@ import {
     TrancheSnapshot,
 } from '../../types';
 
-import { DepositClient } from './clients/deposit.client';
+import { ConvertClient } from './clients/convert.client';
 import { DistributionClient } from './clients/distribution.client';
 import { LeaderboardClient } from './clients/leaderboard.client';
 import { OutpostClient } from './clients/outpost.client';
@@ -56,6 +56,7 @@ import {
 
 import { buildSolanaTrancheSnapshot, ceilDiv } from './utils';
 import { GlobalConfig, PayRateEntry, SolanaTransaction } from './types';
+import { WithdrawReceipt } from '../../types';
 import { SolanaProgramService } from './program';
 import bs58 from 'bs58';
 
@@ -79,7 +80,7 @@ export class SolanaStakingClient implements IStakingClient {
     public connection: Connection;
     public anchor: AnchorProvider;
 
-    public depositClient: DepositClient;
+    public convertClient: ConvertClient;
     public distributionClient: DistributionClient;
     public leaderboardClient: LeaderboardClient;
     public outpostClient: OutpostClient;
@@ -210,7 +211,7 @@ export class SolanaStakingClient implements IStakingClient {
 
         this.program = new SolanaProgramService(this.anchor, config.network.chainId as SolChainID);
 
-        this.depositClient = new DepositClient(this.anchor, this.program);
+        this.convertClient = new ConvertClient(this.anchor, this.program);
         this.distributionClient = new DistributionClient(this.anchor, this.program);
         this.leaderboardClient = new LeaderboardClient(this.anchor, this.program);
         this.outpostClient = new OutpostClient(this.anchor, this.program);
@@ -231,7 +232,7 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error('Deposit amount must be greater than zero.');
 
         try {
-            const ix = await this.depositClient.buildDepositTx(amountLamports, this.squadsVaultPDA)
+            const ix = await this.convertClient.buildDepositTx(amountLamports, this.squadsVaultPDA)
             return !!this.squadsX
                 ? await this.sendSquadsIxs(ix)
                 : await this.buildAndSendIx(ix)
@@ -258,7 +259,7 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error('Withdraw amount must be greater than zero.');
 
         try {
-            const ix = await this.depositClient.buildWithdrawTx(amountLamports, this.squadsVaultPDA)
+            const ix = await this.convertClient.buildWithdrawTx(amountLamports, this.squadsVaultPDA)
             return !!this.squadsX
                 ? await this.sendSquadsIxs(ix)
                 : await this.buildAndSendIx(ix)
@@ -269,6 +270,52 @@ export class SolanaStakingClient implements IStakingClient {
         }
     }
 
+    /**
+     * Enumerate withdrawal receipt NFTs held by the user (queued/ready/claimed).
+     * Mirrors the ETH getPendingWithdraws helper for UI parity.
+     */
+    async getPendingWithdraws(): Promise<WithdrawReceipt[]> {
+        this.ensureUser();
+        const owner = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+        return await this.convertClient.fetchWithdrawReceipts(owner);
+    }
+
+    /**
+     * Claim a withdrawal receipt (burn NFT + receive SOL) via claim_withdraw.
+     */
+    async claimWithdraw(tokenId: bigint): Promise<string> {
+        this.ensureUser();
+        const owner = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+
+        try {
+            const ix = await this.convertClient.buildClaimWithdrawTx(tokenId, owner);
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix);
+        } catch (err) {
+            console.log(`Failed to claim withdraw on Solana: ${err}`);
+            throw err;
+        }
+    }
+
+    /**
+     * Claim accrued liqSOL distribution rewards (liqsol_core::claim_rewards).
+     */
+    async claimLiqsolRewards(): Promise<string> {
+        this.ensureUser();
+        const owner = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+
+        try {
+            const ix = await this.distributionClient.buildClaimRewardsIx(owner);
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix);
+        } catch (err) {
+            console.log(`Failed to claim liqSOL rewards on Solana: ${err}`);
+            throw err;
+        }
+    }
+
     /**
      * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
      */
@@ -362,12 +409,13 @@ export class SolanaStakingClient implements IStakingClient {
             //  - nativeLamports: wallet SOL
             //  - actualBalResp: liqSOL balance in user ATA
             //  - snapshot: Outpost + pretokens + global index/shares
-            const [nativeLamports, actualBalResp, snapshot] = await Promise.all([
+            const [nativeLamports, actualBalResp, snapshot, claimableLamports] = await Promise.all([
                 this.connection.getBalance(user, 'confirmed'),
                 this.connection
                     .getTokenAccountBalance(userLiqsolAta, 'confirmed')
                     .catch(() => null),
                 this.outpostClient.fetchWireState(user).catch(() => null),
+                this.distributionClient.getClaimableLiqsol(user).catch(() => new BN(0)),
             ]);
 
             const LIQSOL_DECIMALS = 9;
@@ -443,6 +491,12 @@ export class SolanaStakingClient implements IStakingClient {
                     decimals: LIQSOL_DECIMALS,
                     ata: userLiqsolAta,
                 },
+                claimable: {
+                    amount: BigInt(claimableLamports.toString()),
+                    symbol: 'LiqSOL',
+                    decimals: LIQSOL_DECIMALS,
+                    ata: userLiqsolAta,
+                },
                 staked: {
                     // liqSOL staked in Outpost via `synd`
                     amount: stakedLiqsol,
@@ -1103,4 +1157,4 @@ export class SolanaStakingClient implements IStakingClient {
     }
 
 
-}
+}

package/src/networks/solana/types.ts

@@ -728,4 +728,26 @@ export type ValidatorRecord = {
      * PDA bump seed for validatorRecord.
      */
     bump: number;
+};
+
+/**
+ * IDL: `receiptData`
+ *
+ * Withdrawal receipt data structure tracking pending withdrawals.
+ * Each receipt represents a user's request to withdraw liqSOL,
+ * with the withdrawal contingent on sufficient encumbered funds
+ * being available at the serviceable epoch.
+ */
+export type ReceiptData = {
+    /** Unique receipt identifier (monotonically increasing, u64) */
+    receiptId: bigint;
+
+    /** Amount of liqSOL requested for withdrawal (Token-2022 raw amount, u64) */
+    liqports: bigint;
+
+    /** Epoch at which this receipt becomes claimable (u64) */
+    epoch: bigint;
+
+    /** Flag indicating whether this receipt has been fulfilled/claimed (bool) */
+    fulfilled: boolean;
 };

package/src/networks/solana/utils.ts

@@ -548,4 +548,11 @@ export function ceilDiv(n: BN, d: BN): BN {
         throw new Error('Division by zero in ceilDiv');
     }
     return n.add(d.subn(1)).div(d);
-}
+}
+
+export function normalizeToBigInt(x: any): bigint {
+    if (typeof x === 'bigint') return x;
+    if (x != null && typeof x === 'object' && 'toString' in x) return BigInt(x.toString());
+    if (typeof x === 'number') return BigInt(x);
+    throw new Error(`normalizeToBigInt: unsupported type ${typeof x}`);
+}

package/src/types.ts

@@ -26,6 +26,9 @@ export enum SupportedSolChainID {
     Devnet = SolChainID.Devnet,
 }
 
+export type ChainSymbol = 'ETH' | 'SOL';
+export type WithdrawStatus = 'queued' | 'ready' | 'claimed';
+
 export interface IStakingClient {
     pubKey?: PublicKey;
     network: ExternalNetwork;
@@ -36,6 +39,15 @@ export interface IStakingClient {
     stake(amount: bigint): Promise<string>;
     unstake(amount: bigint): Promise<string>;
     buy(amount: bigint): Promise<string>;
+    
+    /** Claim a withdrawal receipt (burn NFT + receive ETH/SOL) via claim_withdraw. */
+    claimWithdraw(tokenId: bigint): Promise<string>
+
+    /** Solana only: claim accrued liqSOL distribution rewards. */
+    claimLiqsolRewards?(): Promise<string>
+    
+    /** Enumerate withdrawal receipt NFTs held by the user (queued/ready/claimed). */
+    getPendingWithdraws(): Promise<WithdrawReceipt[]>
 
     /** Fetch the complete user portfolio */
     getPortfolio(): Promise<Portfolio | null>;
@@ -71,7 +83,8 @@ export interface IStakingClient {
         balanceOverrideLamports?: bigint; // for tests/custom callers
     }): Promise<bigint>
 
-    validatorDeposit(): Promise<string>
+    // Removed : ValidatorDeposit not required for Solana
+    // validatorDeposit(): Promise<string>
 }
 
 /**
@@ -95,6 +108,12 @@ export interface Portfolio {
     /** Liquid staking token balance (LiqETH, LiqSOL, etc.). */
     liq: BalanceView;
 
+    /**
+     * Solana-only liqSOL rewards currently claimable from the distribution bucket.
+     * Not populated on Ethereum.
+     */
+    claimable?: BalanceView;
+
     /**
      * Outpost-staked balance:
      *  - On Solana: liqSOL staked via `synd` (stakedLiqsol, in lamports).
@@ -300,9 +319,35 @@ export interface OPPAssertion {
     raw: any;
 }
 
-
-
 export enum ReceiptNFTKind {
     STAKE = 0,
     PRETOKEN_PURCHASE = 1,
-}
+}
+
+/**
+ * Unified cross-chain withdraw receipt (ETH + SOL).
+ *
+ * tokenId   – NFT id (ERC721 on ETH, PDA-seeded mint on SOL)
+ * receipt   – chain-specific data normalized for UI
+ */
+export interface WithdrawReceipt {
+    tokenId: bigint;
+    receipt: {
+        /** Display balance (wei or lamports) with symbol/decimals. */
+        amount: BalanceView;
+        /** Claimable time in ms since epoch (readyAt on ETH; ETA from epoch on SOL). */
+        readyAt: number;
+        /** Chain discriminator. */
+        chain: ChainSymbol;
+        /** Solana-only: epoch when claimable. */
+        epoch?: bigint;
+        /** queued | ready | claimed */
+        status?: WithdrawStatus;
+        /** NFT mint (SOL) or ERC721 contract address (ETH queue address). */
+        mint?: string;
+        /** Owner token account (SOL) for the NFT. */
+        ownerAta?: string;
+        /** Optional explicit contract address for ETH queue NFT. */
+        contractAddress?: string;
+    };
+}