@wireio/stake 2.2.2 → 2.3.0

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,34 @@ 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;
+        }
+    }
+
     /**
      * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
      */
@@ -1103,4 +1132,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,12 @@ 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>
+    
+    /** 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 +80,8 @@ export interface IStakingClient {
         balanceOverrideLamports?: bigint; // for tests/custom callers
     }): Promise<bigint>
 
-    validatorDeposit(): Promise<string>
+    // Removed : ValidatorDeposit not required for Solana
+    // validatorDeposit(): Promise<string>
 }
 
 /**
@@ -300,9 +310,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;
+    };
 }

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

@@ -1,291 +0,0 @@
-import { AnchorProvider, BN, Program, Wallet } from '@coral-xyz/anchor';
-import {
-    SystemProgram,
-    Transaction,
-    TransactionInstruction,
-    StakeProgram,
-    SYSVAR_INSTRUCTIONS_PUBKEY,
-    SYSVAR_CLOCK_PUBKEY,
-    SYSVAR_RENT_PUBKEY,
-    SYSVAR_STAKE_HISTORY_PUBKEY,
-    Connection,
-    PublicKey,
-    TransactionMessage,
-    LAMPORTS_PER_SOL,
-    Signer,
-} from '@solana/web3.js';
-
-import {
-    TOKEN_2022_PROGRAM_ID,
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    getAssociatedTokenAddressSync,
-} from '@solana/spl-token';
-import * as multisig from "@sqds/multisig";
-
-import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
-
-import { GlobalAccount, WalletLike } from '../types';
-
-export class DepositClient {
-    private program: Program<LiqsolCoreClientIdl>;
-
-    get connection() {
-        return this.provider.connection;
-    }
-
-    get wallet(): WalletLike {
-        return this.provider.wallet;
-    }
-
-    constructor(
-        private readonly provider: AnchorProvider,
-        private readonly pgs: SolanaProgramService
-    ) {
-        this.program = pgs.getProgram('liqsolCore');
-    }
-
-    /**
-     * Build a deposit transaction:
-     *   SOL -> liqSOL via liqsol_core::deposit.
-     */
-    async buildDepositTx(
-        amount: bigint,
-        user = this.wallet.publicKey,
-    ): Promise<TransactionInstruction> {
-        if (!user) {
-            throw new Error(
-                'DepositClient.buildDepositTx: wallet not connected',
-            );
-        }
-        if (!amount || amount <= BigInt(0)) {
-            throw new Error(
-                'DepositClient.buildDepositTx: amount must be greater than zero.',
-            );
-        }
-
-        // -------------------------------------------------------------
-        // PDAs
-        // -------------------------------------------------------------
-        const depositAuthority = this.pgs.deriveDepositAuthorityPda();
-        const liqsolMint = this.pgs.deriveLiqsolMintPda();
-        const liqsolMintAuthority = this.pgs.deriveLiqsolMintAuthorityPda();
-        const reservePool = this.pgs.deriveReservePoolPda();
-        const vault = this.pgs.deriveVaultPda();
-        const controllerState = this.pgs.deriveStakeControllerStatePda();
-        const payoutState = this.pgs.derivePayoutStatePda();
-        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
-        const payRateHistory = this.pgs.derivePayRateHistoryPda();
-        const globalConfig = this.pgs.deriveGlobalConfigPda();
-
-        // -------------------------------------------------------------
-        // Token-2022 ATAs
-        // -------------------------------------------------------------
-        const userAta = getAssociatedTokenAddressSync(
-            liqsolMint,
-            user,
-            true,
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        // -------------------------------------------------------------
-        // Distribution state + user_record (KEYED BY TOKEN ACCOUNT)
-        // -------------------------------------------------------------
-        const distributionState = this.pgs.deriveDistributionStatePda();
-        const userRecord = this.pgs.deriveUserRecordPda(userAta);
-
-        const bucketTokenAccount = getAssociatedTokenAddressSync(
-            liqsolMint,
-            bucketAuthority,
-            true,
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        // -------------------------------------------------------------
-        // Ephemeral stake
-        // -------------------------------------------------------------
-        const seed = Math.floor(Math.random() * 2 ** 32);
-        const ephemeralStake = await this.pgs.deriveEphemeralStakeAddress(user, seed);
-
-        // -------------------------------------------------------------
-        // BUILD IX (MUST MATCH IDL)
-        // -------------------------------------------------------------
-        return await this.program.methods
-            .deposit(new BN(amount.toString()), seed)
-            .accounts({
-                user,
-                depositAuthority,
-                systemProgram: SystemProgram.programId,
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                liqsolProgram: this.pgs.PROGRAM_IDS.LIQSOL_TOKEN,
-                stakeProgram: StakeProgram.programId,
-                liqsolMint,
-                userAta,
-                liqsolMintAuthority,
-                reservePool,
-                vault,
-                ephemeralStake,
-                controllerState,
-                payoutState,
-                bucketAuthority,
-                bucketTokenAccount,
-                userRecord,
-                distributionState,
-                payRateHistory,
-                instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
-                clock: SYSVAR_CLOCK_PUBKEY,
-                stakeHistory: SYSVAR_STAKE_HISTORY_PUBKEY,
-                rent: SYSVAR_RENT_PUBKEY,
-                globalConfig
-            })
-            .instruction();
-    }
-
-    /**
-     * Build a withdraw-request transaction:
-     *   liqSOL -> SOL via liqsol_core::requestWithdraw.
-     *
-     * This:
-     *  - burns liqSOL from the user
-     *  - increments totalEncumberedFunds in global state
-     *  - mints an NFT receipt (liqReceiptData + NFT ATA for owner)
-     */
-    async buildWithdrawTx(
-        amount: bigint,
-        user = this.wallet.publicKey,
-    ): Promise<TransactionInstruction> {
-        if (!user) {
-            throw new Error(
-                'DepositClient.buildWithdrawTx: wallet not connected',
-            );
-        }
-        if (!amount || amount <= BigInt(0)) {
-            throw new Error(
-                'DepositClient.buildWithdrawTx: amount must be greater than zero.',
-            );
-        }
-
-        // -------------------------------------------------------------
-        // Core program + liqSOL mint / user ATA
-        // -------------------------------------------------------------
-        const liqsolMint = this.pgs.deriveLiqsolMintPda();
-
-        const userAta = getAssociatedTokenAddressSync(
-            liqsolMint,
-            user,
-            true,
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        // Distribution / balance-tracking
-        // user_record is keyed by the user’s liqSOL ATA (same convention
-        // as deposit/purchase).
-        const userRecord = this.pgs.deriveUserRecordPda(userAta);
-        const distributionState = this.pgs.deriveDistributionStatePda();
-
-        // Reserve + stake controller PDAs
-        const global = this.pgs.deriveWithdrawGlobalPda();          // withdraw operator state
-        const reservePool = this.pgs.deriveReservePoolPda();
-        const stakeAllocationState = this.pgs.deriveStakeAllocationStatePda();
-        const stakeMetrics = this.pgs.deriveStakeMetricsPda();
-        const maintenanceLedger = this.pgs.deriveMaintenanceLedgerPda();
-        const globalConfig = this.pgs.deriveGlobalConfigPda();      // liqSOL config / roles
-
-        // -------------------------------------------------------------
-        // Need nextReceiptId from withdraw global state
-        // -------------------------------------------------------------
-        const globalAcct: GlobalAccount = await this.program.account.global.fetch(global);
-
-        const rawId = globalAcct.nextReceiptId;
-        let receiptId: bigint;
-
-        if (typeof rawId === 'bigint') {
-            // New-style IDL / accounts returning bigint directly
-            receiptId = rawId;
-        } else if (rawId != null && typeof rawId === 'object' && 'toString' in rawId) {
-            // Anchor BN / bn.js or similar – normalize through string
-            receiptId = BigInt(rawId.toString());
-        } else if (typeof rawId === 'number') {
-            // Just in case someone typed it as a JS number in tests
-            receiptId = BigInt(rawId);
-        } else {
-            throw new Error(
-                `DepositClient.buildWithdrawTx: unexpected nextReceiptId type (${typeof rawId})`,
-            );
-        }
-
-        // -------------------------------------------------------------
-        // NFT receipt PDAs (mint, metadata, data, ATA)
-        // -------------------------------------------------------------
-        const mintAuthority = this.pgs.deriveWithdrawMintAuthorityPda();
-        const metadata = this.pgs.deriveWithdrawMintMetadataPda();
-
-        const nftMint = this.pgs.deriveWithdrawNftMintPda(receiptId);
-        const receiptData = this.pgs.deriveLiqReceiptDataPda(nftMint);
-
-        const owner = user;
-        const nftAta = getAssociatedTokenAddressSync(
-            nftMint,
-            owner,
-            true,
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        // Bucket token account (same bucket used by deposit/distribution)
-        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
-        const bucketTokenAccount = getAssociatedTokenAddressSync(
-            liqsolMint,
-            bucketAuthority,
-            true,
-            TOKEN_2022_PROGRAM_ID,
-        );
-
-        // -------------------------------------------------------------
-        // BUILD IX (MUST MATCH requestWithdraw IDL)
-        // -------------------------------------------------------------
-        return await this.program.methods
-            .requestWithdraw(new BN(amount.toString()))
-            .accounts({
-                user,
-                owner,
-                global,
-                liqsolMint,
-                userAta,
-                userRecord,
-                reservePool,
-                stakeAllocationState,
-                stakeMetrics,
-                maintenanceLedger,
-                clock: SYSVAR_CLOCK_PUBKEY,
-                mintAuthority,
-                receiptData,
-                metadata,
-                nftMint,
-                nftAta,
-                distributionState,
-                bucketTokenAccount,
-                tokenProgram: TOKEN_2022_PROGRAM_ID,
-                tokenInterface: TOKEN_2022_PROGRAM_ID,
-                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                systemProgram: SystemProgram.programId,
-                rent: SYSVAR_RENT_PUBKEY,
-                globalConfig,
-            })
-            .instruction();
-
-    }
-}
-
-// A “wallet-adapter-like” shape (AnchorProvider.wallet matches this)
-type WalletLikeSigner = {
-    publicKey: PublicKey;
-    signTransaction: (tx: Transaction) => Promise<Transaction>;
-};
-
-function isKeypairSigner(x: any): x is { publicKey: PublicKey; secretKey: Uint8Array } {
-    return !!x && x.publicKey instanceof PublicKey && x.secretKey instanceof Uint8Array;
-}
-
-function isWalletLikeSigner(x: any): x is WalletLikeSigner {
-    return !!x && x.publicKey instanceof PublicKey && typeof x.signTransaction === "function";
-}