@wireio/stake 1.0.1 → 1.0.69

package/src/networks/solana/solana.ts

@@ -1,23 +1,32 @@
 import {
+    AddressLookupTableAccount,
     Commitment,
     ComputeBudgetProgram,
     Connection,
     ConnectionConfig,
     PerfSample,
+    SendTransactionError,
     PublicKey as SolPubKey,
     SystemProgram,
     Transaction,
+    TransactionInstruction,
+    TransactionMessage,
     TransactionSignature,
+    VersionedTransaction,
 } from '@solana/web3.js';
 import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
 import {
     ASSOCIATED_TOKEN_PROGRAM_ID,
+    createAssociatedTokenAccountInstruction,
     getAssociatedTokenAddressSync,
     TOKEN_2022_PROGRAM_ID,
 } from '@solana/spl-token';
 
+import * as multisig from "@sqds/multisig";
+
 import {
+    Base58,
     ChainID,
     ExternalNetwork,
     KeyType,
@@ -28,28 +37,29 @@ import {
 import {
     IStakingClient,
     Portfolio,
+    SquadsXConfig,
     StakerConfig,
     TrancheSnapshot,
 } from '../../types';
 
-import { DepositClient } from './clients/deposit.client';
+import { ConvertClient } from './clients/convert.client';
 import { DistributionClient } from './clients/distribution.client';
+import { SolanaInstaswapClient } from './clients/instaswap.client';
 import { LeaderboardClient } from './clients/leaderboard.client';
 import { OutpostClient } from './clients/outpost.client';
 import { TokenClient } from './clients/token.client';
 
 import {
-    deriveLiqsolMintPda,
-    deriveReservePoolPda,
-    deriveStakeMetricsPda,
-    deriveVaultPda,
+    DEFAULT_AVERAGE_PAY_RATE,
     INDEX_SCALE,
     PAY_RATE_SCALE_FACTOR,
 } from './constants';
 
 import { buildSolanaTrancheSnapshot, ceilDiv } from './utils';
 import { GlobalConfig, PayRateEntry, SolanaTransaction } from './types';
+import { WithdrawReceipt } from '../../types';
 import { SolanaProgramService } from './program';
+import bs58 from 'bs58';
 
 const commitment: Commitment = 'confirmed';
 
@@ -71,13 +81,17 @@ export class SolanaStakingClient implements IStakingClient {
     public connection: Connection;
     public anchor: AnchorProvider;
 
-    public depositClient: DepositClient;
+    public convertClient: ConvertClient;
     public distributionClient: DistributionClient;
+    public instaswapClient: SolanaInstaswapClient;
     public leaderboardClient: LeaderboardClient;
     public outpostClient: OutpostClient;
     public tokenClient: TokenClient;
     public program: SolanaProgramService
 
+    private smartAccount?: SolPubKey; // PDA (off-curve)
+    private signer?: SolPubKey;       // on-curve signer
+
     get solPubKey(): SolPubKey {
         if (!this.pubKey) throw new Error('pubKey is undefined');
         return new SolPubKey(this.pubKey.data.array);
@@ -87,6 +101,18 @@ export class SolanaStakingClient implements IStakingClient {
         return this.config.network;
     }
 
+    get feePayer(): SolPubKey {
+        if (this.signer) return this.signer;
+        // fallback for normal wallets
+        if (this.anchor.wallet.publicKey) return this.anchor.wallet.publicKey;
+        throw new Error('No signing authority available');
+    }
+
+    get squadsX(): SquadsXConfig | null {
+        const config = this.config.extras?.squadsX;
+        return config ?? null;
+    }
+
     constructor(private config: StakerConfig) {
         const adapter = config.provider as BaseSignerWalletAdapter | undefined;
 
@@ -185,12 +211,18 @@ export class SolanaStakingClient implements IStakingClient {
             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);
-        this.tokenClient = new TokenClient(this.anchor);
-        this.program = new SolanaProgramService(this.anchor);
+        this.program = new SolanaProgramService(this.anchor, config.network.chainId as SolChainID);
+
+        this.convertClient = new ConvertClient(this.anchor, this.program);
+        this.distributionClient = new DistributionClient(this.anchor, this.program);
+        this.instaswapClient = new SolanaInstaswapClient(
+            this.anchor,
+            this.program,
+            this.buildAndSendIx.bind(this),
+        );
+        this.leaderboardClient = new LeaderboardClient(this.anchor, this.program);
+        this.outpostClient = new OutpostClient(this.anchor, this.program);
+        this.tokenClient = new TokenClient(this.anchor, this.program);
     }
 
     // ---------------------------------------------------------------------
@@ -203,25 +235,35 @@ export class SolanaStakingClient implements IStakingClient {
      */
     async deposit(amountLamports: bigint): Promise<string> {
         this.ensureUser();
-        if (amountLamports <= BigInt(0)) {
+        if (amountLamports <= BigInt(0))
             throw new Error('Deposit amount must be greater than zero.');
-        }
 
         try {
-            // Build compute budget increase instruction
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const submit = async (ix: TransactionInstruction | TransactionInstruction[]) => (
+                !!this.squadsX
+                    ? await this.sendSquadsIxs(ix)
+                    : await this.buildAndSendIx(ix)
+            );
 
-            // Build the Outpost synd instruction
-            const ix = await this.depositClient.buildDepositTx(amountLamports);
+            try {
+                const ix = await this.convertClient.buildDepositTx(amountLamports, user);
+                return await submit(ix);
+            } catch (err) {
+                if (!this.isLegacyUserRecordMigrationRequired(err)) {
+                    throw err;
+                }
 
-            // Wrap in a transaction and send
-            const tx = new Transaction().add(cuIx, ix);
-            const prepared = await this.prepareTx(tx);
-            const signed = await this.signTransaction(prepared.tx);
+                const registerIx = await this.convertClient.buildRegisterUserIx(user);
+                await submit(registerIx);
+
+                const retryIx = await this.convertClient.buildDepositTx(amountLamports, user);
+                return await submit(retryIx);
+            }
 
-            return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to deposit Solana: ${err}`);
+            console.log(`Failed to deposit Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -237,55 +279,89 @@ export class SolanaStakingClient implements IStakingClient {
      */
     async withdraw(amountLamports: bigint): Promise<string> {
         this.ensureUser();
-        if (amountLamports <= BigInt(0)) {
+        if (amountLamports <= BigInt(0))
             throw new Error('Withdraw amount must be greater than zero.');
-        }
 
         try {
-            // Build compute budget increase instruction
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-
-            // Build the Outpost synd instruction
-            const ix = await this.depositClient.buildWithdrawTx(amountLamports);
-
-            // Wrap in a transaction and send
-            const tx = new Transaction().add(cuIx, ix);
-            const prepared = await this.prepareTx(tx);
-            const signed = await this.signTransaction(prepared.tx);
+            const ix = await this.convertClient.buildWithdrawTx(amountLamports, this.squadsVaultPDA)
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
 
-            return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to withdraw Solana: ${err}`);
+            console.log(`Failed to withdraw Solana: ${err}`);
+            throw err;
         }
     }
 
     /**
-     * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
+     * Enumerate withdrawal receipt NFTs held by the user (queued/ready/claimed).
+     * Mirrors the ETH getPendingWithdraws helper for UI parity.
      */
-    async stake(amountLamports: bigint): Promise<string> {
+    async getPendingWithdraws(address?: string): Promise<WithdrawReceipt[]> {
         this.ensureUser();
+        const owner = address ? new SolPubKey(address) :
+            this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+        return await this.convertClient.fetchWithdrawReceipts(owner);
+    }
 
-        if (!amountLamports || amountLamports <= BigInt(0)) {
-            throw new Error('Stake amount must be greater than zero.');
-        }
+    /**
+     * 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 user = this.solPubKey;
+            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;
+        }
+    }
 
-            // Build compute budget increase instruction
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
+    /**
+     * Claim accrued liqSOL distribution rewards (liqsol_core::claim_rewards).
+     */
+    async claimLiqsolRewards(): Promise<string> {
+        this.ensureUser();
+        const owner = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
 
-            // Build the Outpost synd instruction
-            const ix = await this.outpostClient.buildStakeIx(amountLamports, user);
+        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;
+        }
+    }
 
-            // Wrap in a transaction and send
-            const tx = new Transaction().add(cuIx, ix);
-            const prepared = await this.prepareTx(tx);
-            const signed = await this.signTransaction(prepared.tx);
+    /**
+     * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
+     */
+    async stake(amountLamports: bigint, wireAccount?: string): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Stake amount must be greater than zero.');
+
+        try {
+            const ix = await this.outpostClient.buildStakeIx(
+                amountLamports,
+                this.squadsVaultPDA,
+                wireAccount,
+            )
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
 
-            return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
-            throw new Error(`Failed to stake Solana: ${err}`);
+            console.log(`Failed to stake Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -294,29 +370,18 @@ export class SolanaStakingClient implements IStakingClient {
      */
     async unstake(amountLamports: bigint): Promise<string> {
         this.ensureUser();
-
-        if (!amountLamports || amountLamports <= BigInt(0)) {
+        if (!amountLamports || amountLamports <= BigInt(0))
             throw new Error('Unstake amount must be greater than zero.');
-        }
 
         try {
-            const user = this.solPubKey;
-
-            // Build compute budget increase instruction
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-
-            // Build the Outpost desynd instruction
-            const ix = await this.outpostClient.buildUnstakeIx(amountLamports, user);
-
-            // Wrap in a transaction and send
-            const tx = new Transaction().add(cuIx, ix);
-            const prepared = await this.prepareTx(tx);
-            const signed = await this.signTransaction(prepared.tx);
-
-            return this.sendAndConfirmHttp(signed, prepared);
+            const ix = await this.outpostClient.buildUnstakeIx(amountLamports, this.squadsVaultPDA)
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
         }
         catch (err) {
-            throw new Error(`Failed to unstake Solana: ${err}`);
+            console.log(`Failed to unstake Solana: ${err}`);
+            throw err;
         }
     }
 
@@ -328,23 +393,82 @@ export class SolanaStakingClient implements IStakingClient {
      */
     async buy(amountLamports: bigint): Promise<string> {
         this.ensureUser();
-        if (!amountLamports || amountLamports <= BigInt(0)) {
+        if (!amountLamports || amountLamports <= BigInt(0))
             throw new Error('liqSOL pretoken purchase requires a positive amount.');
+
+        try {
+            const ix = await this.tokenClient.buildPurchaseIx(amountLamports, this.squadsVaultPDA)
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
+        }
+        catch (err) {
+            console.log(`Failed to buy liqSOL pretokens: ${err}`);
+            throw err;
         }
+    }
+
+    /** Deposit SOL to liqSOL, then syndicate that liqSOL in one transaction. Requires enough SOL for the deposit fee. */
+    async depositAndStake(amountLamports: bigint, wireAccount?: string): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
 
         try {
-            const user = this.solPubKey;
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-            const ix = await this.tokenClient.buildPurchaseIx(amountLamports, user);
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const depositIx = await this.convertClient.buildDepositTx(amountLamports, user);
+            const stakeIx = await this.outpostClient.buildStakeIx(
+                amountLamports,
+                user,
+                wireAccount,
+            );
 
-            const tx = new Transaction().add(cuIx, ix);
-            const prepared = await this.prepareTx(tx);
-            const signed = await this.signTransaction(prepared.tx);
+            return !!this.squadsX
+                ? await this.sendSquadsIxs([depositIx, stakeIx])
+                : await this.buildAndSendIx([depositIx, stakeIx]);
+        } catch (err) {
+            console.log(`Failed to deposit and stake: ${err}`);
+            throw err;
+        }
+    }
 
-            return this.sendAndConfirmHttp(signed, prepared);
+    /** Deposit SOL to liqSOL, then buy pretokens with that liqSOL in one transaction. Requires enough SOL for the deposit fee. */
+    async depositAndBuy(amountLamports: bigint): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+        try {
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const depositIx = await this.convertClient.buildDepositTx(amountLamports, user);
+            const purchaseIx = await this.tokenClient.buildPurchaseIx(amountLamports, user);
+
+            return !!this.squadsX
+                ? await this.sendSquadsIxs([depositIx, purchaseIx])
+                : await this.buildAndSendIx([depositIx, purchaseIx]);
+        } catch (err) {
+            console.log(`Failed to deposit and buy: ${err}`);
+            throw err;
         }
-        catch (err) {
-            throw new Error(`Failed to buy liqSOL pretokens: ${err}`);
+    }
+
+    /** Desyndicate liqSOL, then request withdraw in one transaction. */
+    async unstakeAndWithdraw(amountLamports: bigint): Promise<string> {
+        this.ensureUser();
+        if (!amountLamports || amountLamports <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+        try {
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const unstakeIx = await this.outpostClient.buildUnstakeIx(amountLamports, user);
+            const withdrawIx = await this.convertClient.buildWithdrawTx(amountLamports, user);
+
+            return !!this.squadsX
+                ? await this.sendSquadsIxs([unstakeIx, withdrawIx])
+                : await this.buildAndSendIx([unstakeIx, withdrawIx]);
+        } catch (err) {
+            console.log(`Failed to unstake and withdraw: ${err}`);
+            throw err;
         }
     }
 
@@ -357,20 +481,20 @@ export class SolanaStakingClient implements IStakingClient {
      *  - yield: on-chain index/shares plus an estimated accrued liqSOL yield
      *  - extras: useful internal addresses and raw state for debugging/UX
      */
-    async getPortfolio(): Promise<Portfolio> {
-        if (!this.pubKey) throw new Error('User pubKey is undefined');
-
+    async getPortfolio(address?: string): Promise<Portfolio> {
+        // if (!this.pubKey) throw new Error('User pubKey is undefined');
         try {
-            const user = this.solPubKey;
+            const user = address ? new SolPubKey(address) : 
+                !!this.squadsX ? this.squadsVaultPDA! : this.solPubKey;
 
-            const reservePoolPDA = deriveReservePoolPda();
-            const vaultPDA = deriveVaultPda();
-            const liqsolMint = deriveLiqsolMintPda();
+            const reservePoolPDA = this.program.deriveReservePoolPda();
+            const vaultPDA = this.program.deriveVaultPda();
+            const liqsolMint = this.program.deriveLiqsolMintPda();
 
             const userLiqsolAta = getAssociatedTokenAddressSync(
                 liqsolMint,
                 user,
-                false,
+                true,
                 TOKEN_2022_PROGRAM_ID,
                 ASSOCIATED_TOKEN_PROGRAM_ID,
             );
@@ -379,12 +503,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;
@@ -460,6 +585,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,
@@ -497,7 +628,8 @@ export class SolanaStakingClient implements IStakingClient {
             };
         }
         catch (err) {
-            throw new Error(`Failed to get Solana portfolio: ${err}`);
+            console.log(`Failed to get Solana portfolio: ${err}`);
+            throw err;
         }
     }
 
@@ -510,6 +642,260 @@ export class SolanaStakingClient implements IStakingClient {
         return this.distributionClient.getUserRecord(this.solPubKey);
     }
 
+    // ---------------------------------------------------------------------
+    // SquadsX Helpers
+    // ---------------------------------------------------------------------
+
+    get squadsMultisigPDA(): SolPubKey | undefined {
+        if (!this.squadsX) return undefined;
+        return new SolPubKey(this.squadsX.multisigPDA);
+    }
+
+    get squadsVaultPDA(): SolPubKey | undefined {
+        if (!this.squadsX || !this.squadsMultisigPDA) return undefined;
+        const multisigPda = this.squadsMultisigPDA;
+        const index = this.squadsX.vaultIndex ?? 0;
+        const pda = multisig.getVaultPda({ multisigPda, index });
+        return pda[0];
+    }
+
+    /** Create a Squads vault transaction/proposal for one or more instructions. */
+    private async sendSquadsIxs(ix: TransactionInstruction | TransactionInstruction[]): Promise<string> {
+        if (!this.squadsX) throw new Error('Attempting to wrap Squads instruction without SquadsX config');
+
+        const ixs = Array.isArray(ix) ? ix : [ix];
+        const multisigPda = this.squadsMultisigPDA!;
+        const vaultPda = this.squadsVaultPDA!;
+        const vaultIndex = this.squadsX?.vaultIndex ?? 0;
+        const creator = this.solPubKey;
+
+        const ms = await multisig.accounts.Multisig.fromAccountAddress(this.connection, multisigPda);
+        const current = BigInt(ms.transactionIndex?.toString() ?? 0);
+        const transactionIndex = current + BigInt(1);
+
+        const altAddress = this.program.PROGRAM_IDS.ALT;
+        const altAccount = await this.connection.getAddressLookupTable(altAddress);
+        if (!altAccount.value) throw new Error("ALT not found on-chain or not yet active.");
+
+        const lookupTable: AddressLookupTableAccount = altAccount.value;
+        const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 600_000 });
+        const computePriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 2000 });
+
+        const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+        const transactionMessage = new TransactionMessage({
+            payerKey: vaultPda,
+            recentBlockhash: blockhash,
+            instructions: [computeLimitIx, computePriceIx, ...ixs],
+        });
+
+        const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+            multisigPda,
+            transactionIndex,
+            creator,
+            vaultIndex,
+            transactionMessage,
+            ephemeralSigners: 0,
+            addressLookupTableAccounts: [lookupTable],
+        });
+
+        const vaultTransactionCreate = await this.buildAndSendIx(createVaultTxIx)
+        console.log('SQUADSX: vaultTransactionCreate', vaultTransactionCreate);
+
+        const createProposalIx = await multisig.instructions.proposalCreate({
+            multisigPda,
+            transactionIndex,
+            creator,
+        });
+
+        const proposalCreate = await this.buildAndSendIx(createProposalIx)
+        console.log('SQUADSX: proposalCreate', proposalCreate);
+
+        return proposalCreate;
+    }
+
+    // async finish(multisigPda: string, transactionIndex: number): Promise<void> {
+    //     const vaultExecute = await multisig.instructions.vaultTransactionExecute({
+    //         connection: this.connection,
+    //         multisigPda: new SolPubKey(multisigPda),
+    //         transactionIndex: BigInt(transactionIndex),
+    //         member: this.solPubKey
+    //     });
+
+    //     const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
+    //     const tx1 = new Transaction().add(cuIx, vaultExecute.instruction);
+    //     const prepared1 = await this.prepareTx(tx1);
+    //     const signed1 = await this.signTransaction(prepared1.tx);
+    //     const sent1 = await this.sendAndConfirmHttp(signed1, prepared1);
+    //     console.log('SENT FINISH', sent1);
+    // }
+
+    // ---------------------------------------------------------------------
+    // Tx helpers
+    // ---------------------------------------------------------------------
+
+    async buildAndSendIx(ix: TransactionInstruction | TransactionInstruction[]): Promise<string> {
+        const ixs = Array.isArray(ix) ? ix : [ix];
+        const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 600_000 });
+        const computePriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 2000 });
+        const { blockhash, lastValidBlockHeight } =
+            await this.connection.getLatestBlockhash('confirmed');
+
+        const altAddress = this.program.PROGRAM_IDS.ALT;
+        const altAccount = await this.connection.getAddressLookupTable(altAddress);
+        const lookupTable = altAccount.value;
+
+        const instructions = [computeLimitIx, computePriceIx, ...ixs];
+
+        const tx = lookupTable
+            ? new VersionedTransaction(
+                new TransactionMessage({
+                    payerKey: this.feePayer,
+                    recentBlockhash: blockhash,
+                    instructions,
+                }).compileToV0Message([lookupTable]),
+            )
+            : new Transaction().add(...instructions);
+
+        const prepared =
+            tx instanceof Transaction
+                ? await this.prepareTx(tx)
+                : { tx, blockhash, lastValidBlockHeight };
+
+        const signed = await this.signTransaction(prepared.tx);
+
+        return this.sendAndConfirmHttp(signed, prepared);
+    }
+
+
+    /**
+     * Send a signed transaction over HTTP RPC.
+     *
+     * - Returns immediately on successful sendRawTransaction.
+     * - If sendRawTransaction throws a SendTransactionError with
+     *   "already been processed", we treat it as success and
+     *   just return a derived signature.
+     * - No confirmTransaction / polling / blockheight handling.
+     */
+    private async sendAndConfirmHttp(
+        signed: SolanaTransaction,
+        _ctx: { blockhash: string; lastValidBlockHeight: number },
+    ): Promise<string> {
+        this.ensureUser();
+
+        const rawTx = signed.serialize();
+
+        try {
+            // Normal happy path: RPC accepts the tx and returns a signature
+            const signature = await this.connection.sendRawTransaction(rawTx, {
+                skipPreflight: false,
+                preflightCommitment: commitment,
+                maxRetries: 3,
+            });
+            return signature;
+        } catch (e: any) {
+            const msg = e?.message ?? '';
+            const isSendTxError =
+                e instanceof SendTransactionError || e?.name === 'SendTransactionError';
+
+            // Benign duplicate case: tx is already in the ledger / cache
+            if (isSendTxError && msg.includes('already been processed')) {
+                console.warn(
+                    'sendRawTransaction reports "already been processed"; ' +
+                    'treating as success without further confirmation.',
+                );
+
+                // Try to derive a signature from the signed Transaction.
+                // If SolanaTransaction is a legacy Transaction, this works.
+                const legacy = signed as unknown as Transaction;
+                const first = legacy.signatures?.[0]?.signature;
+
+                if (first) {
+                    return bs58.encode(first);
+                }
+
+                // Fallback: return a dummy string
+                return 'already-processed';
+            }
+
+            // Any other send error is a real failure
+            throw e;
+        }
+    }
+
+    /**
+     * Sign a single Solana transaction using the connected wallet adapter.
+     */
+    async signTransaction(
+        tx: SolanaTransaction,
+    ): Promise<SolanaTransaction> {
+        this.ensureUser();
+        return this.anchor.wallet.signTransaction(tx);
+    }
+
+    /**
+     * Generic "fire and forget" send helper if the caller already
+     * prepared and signed the transaction.
+     */
+    async sendTransaction(
+        signed: SolanaTransaction,
+    ): Promise<TransactionSignature> {
+        this.ensureUser();
+        return this.anchor.sendAndConfirm(signed);
+    }
+
+    /**
+     * Attach recent blockhash + fee payer to a transaction.
+     * Required before signing and sending.
+     */
+    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.feePayer;
+        return { tx, blockhash, lastValidBlockHeight };
+    }
+
+    /**
+     * Guard for all write operations (deposit/withdraw/stake/unstake/buy).
+     * Ensures we have a Wire pubKey and an Anchor wallet pubKey, and that they match.
+     */
+    ensureUser() {
+        if (!this.pubKey) throw new Error('User pubKey is undefined');
+
+        const wallet = this.anchor?.wallet as any;
+        const pk = wallet?.publicKey as SolPubKey | undefined;
+
+        if (!pk) throw new Error('Wallet not connected');
+        if (typeof wallet.signTransaction !== 'function') {
+            throw new Error('Wallet does not support signTransaction');
+        }
+
+        // if (!this.pubKey || !this.anchor.wallet.publicKey) {
+        //     throw new Error('User Authorization required: pubKey is undefined');
+        // }
+        // if (
+        //     this.solPubKey.toBase58() !==
+        //     this.anchor.wallet.publicKey.toBase58()
+        // ) {
+        //     throw new Error(
+        //         'Write access requires connected wallet to match pubKey',
+        //     );
+        // }
+    }
+
+    private isLegacyUserRecordMigrationRequired(error: unknown): boolean {
+        const message = error instanceof Error ? error.message : String(error ?? '');
+        const normalized = message.toLowerCase();
+        return normalized.includes('legacyuserrecordmigrationrequired')
+            || normalized.includes('legacy user record must be migrated')
+            || normalized.includes('custom program error: 0x1784');
+    }
 
     // ---------------------------------------------------------------------
     // READ-ONLY Public Methods
@@ -525,18 +911,8 @@ export class SolanaStakingClient implements IStakingClient {
      *
      * This is READ-ONLY and works even with no connected wallet.
      */
-    async getTrancheSnapshot(options?: {
-        chainID?: ChainID;
-        windowBefore?: number;
-        windowAfter?: number;
-    }): Promise<TrancheSnapshot> {
+    async getTrancheSnapshot(chainID: ChainID): Promise<TrancheSnapshot> {
         try {
-            const {
-                chainID = SolChainID.WireTestnet,
-                windowBefore,
-                windowAfter,
-            } = options ?? {};
-
             const [globalState, trancheState] = await Promise.all([
                 this.tokenClient.fetchGlobalState(),
                 this.tokenClient.fetchTrancheState(),
@@ -551,12 +927,11 @@ export class SolanaStakingClient implements IStakingClient {
                 trancheState,
                 solPriceUsd,
                 nativePriceTimestamp: timestamp,
-                ladderWindowBefore: windowBefore,
-                ladderWindowAfter: windowAfter,
             });
         }
         catch (err) {
-            throw new Error(`Failed to build Solana tranche snapshot: ${err}`);
+            console.log(`Failed to build Solana tranche snapshot: ${err}`);
+            throw err;
         }
     }
 
@@ -578,7 +953,8 @@ export class SolanaStakingClient implements IStakingClient {
 
             return apyPercent;
         } catch (err) {
-            throw new Error(`Failed to compute Solana system APY: ${err}`);
+            console.log(`Failed to compute Solana system APY: ${err}`);
+            throw err;
         }
     }
 
@@ -588,24 +964,48 @@ export class SolanaStakingClient implements IStakingClient {
      * de-scaled using PAY_RATE_SCALE_FACTOR (1e12).
      */
     private async getEpochRateDecimalFromProgram(): Promise<number> {
-        try {
+        const liqSolCoreProgram: any = this.program.getProgram('liqsolCore');
+        const payRateHistoryPda = this.program.derivePayRateHistoryPda();
+
+        const payRateHistory =
+            await liqSolCoreProgram.account.payRateHistory.fetch(payRateHistoryPda);
+
+        const totalEntriesAdded = Number(payRateHistory.totalEntriesAdded);
+        const maxEntries = Number(payRateHistory.maxEntries);
+
+        if (totalEntriesAdded === 0) {
+            // No real entries yet, fall back to default
+            return Number(DEFAULT_AVERAGE_PAY_RATE) / Number(PAY_RATE_SCALE_FACTOR);
+        }
 
-            const liqSolCoreProgram = this.program.getProgram('liqsolCore');
-            const stakeMetricsPda = deriveStakeMetricsPda();
-            const stakeMetrics =
-                await liqSolCoreProgram.account.stakeMetrics.fetch(stakeMetricsPda);
+        const currentIndex = Number(payRateHistory.currentIndex);
 
-            // solSystemPayRate is stored on-chain with PAY_RATE_SCALE_FACTOR (1e12)
-            const raw = BigInt(stakeMetrics.solSystemPayRate.toString());
+        // Only average entries that have actually been processed (written by add_entry),
+        // not the default-initialized slots. After 10+ entries, processedCount === maxEntries.
+        const processedCount = Math.min(totalEntriesAdded, maxEntries);
 
-            // Convert to JS number in **decimal per epoch** units
-            const rateDecimal = Number(raw) / Number(PAY_RATE_SCALE_FACTOR);
+        let sum = BigInt(0);
+        let validCount = 0;
+        // Walk backward from most recent entry
+        let idx = (currentIndex - 1 + maxEntries) % maxEntries;
 
-            return rateDecimal;
+        for (let i = 0; i < processedCount; i++) {
+            const entry = payRateHistory.entries[idx];
+            const scaledRate = BigInt(entry.scaledRate.toString());
+            if (scaledRate > BigInt(0)) {
+                sum += scaledRate;
+                validCount++;
+            }
+            idx = (idx - 1 + maxEntries) % maxEntries;
         }
-        catch (err) {
-            throw new Error(`Failed to read stakeMetrics from program: ${err}`);
+
+        if (validCount === 0) {
+            return Number(DEFAULT_AVERAGE_PAY_RATE) / Number(PAY_RATE_SCALE_FACTOR);
         }
+
+        // Average the processed entries
+        const average = Number(sum / BigInt(validCount));
+        return average / Number(PAY_RATE_SCALE_FACTOR);
     }
 
     // Simple cache so we don’t hammer RPC
@@ -690,7 +1090,7 @@ export class SolanaStakingClient implements IStakingClient {
             return BigInt(0);
         }
 
-        const [avgPayRate, globalConfig]: [BN, GlobalConfig] = await Promise.all([
+        const [avgPayRate, globalConfig]: [BN, GlobalConfig | null] = await Promise.all([
             this.distributionClient.getAverageScaledPayRate(windowSize),
             this.distributionClient.getGlobalConfig(),
         ]);
@@ -741,14 +1141,12 @@ export class SolanaStakingClient implements IStakingClient {
     }): Promise<bigint> {
         this.ensureUser();
 
-        const payer = this.solPubKey;
-
         // -------------------------------------------------------------
         // 1) Current wallet balance (prefer caller override)
         // -------------------------------------------------------------
         const balanceLamports: bigint =
             options?.balanceOverrideLamports ??
-            BigInt(await this.connection.getBalance(payer, commitment));
+            BigInt(await this.connection.getBalance(this.feePayer, commitment));
 
         if (balanceLamports <= BigInt(0)) {
             return BigInt(0);
@@ -859,7 +1257,7 @@ export class SolanaStakingClient implements IStakingClient {
             return this.cachedTxFee.value;
         }
 
-        const payer = this.solPubKey;
+        const payer = this.feePayer;
 
         const dummyIx = SystemProgram.transfer({
             fromPubkey: payer,
@@ -885,102 +1283,5 @@ export class SolanaStakingClient implements IStakingClient {
         return singleTxFeeLamports;
     }
 
-    // ---------------------------------------------------------------------
-    // Tx helpers
-    // ---------------------------------------------------------------------
-
-    /**
-     * Send a signed transaction over HTTP RPC and wait for confirmation.
-     * Throws if the transaction fails.
-     */
-    private async sendAndConfirmHttp(
-        signed: SolanaTransaction,
-        ctx: { blockhash: string; lastValidBlockHeight: number },
-    ): Promise<string> {
-        this.ensureUser();
-
-        const signature = await this.connection.sendRawTransaction(
-            signed.serialize(),
-            {
-                skipPreflight: false,
-                preflightCommitment: commitment,
-                maxRetries: 3,
-            },
-        );
-
-        const conf = await this.connection.confirmTransaction(
-            {
-                signature,
-                blockhash: ctx.blockhash,
-                lastValidBlockHeight: ctx.lastValidBlockHeight,
-            },
-            commitment,
-        );
-
-        if (conf.value.err) {
-            throw new Error(
-                `Transaction failed: ${JSON.stringify(conf.value.err)}`,
-            );
-        }
-
-        return signature;
-    }
-
-    /**
-     * Sign a single Solana transaction using the connected wallet adapter.
-     */
-    async signTransaction(
-        tx: SolanaTransaction,
-    ): Promise<SolanaTransaction> {
-        this.ensureUser();
-        return this.anchor.wallet.signTransaction(tx);
-    }
-
-    /**
-     * Generic "fire and forget" send helper if the caller already
-     * prepared and signed the transaction.
-     */
-    async sendTransaction(
-        signed: SolanaTransaction,
-    ): Promise<TransactionSignature> {
-        this.ensureUser();
-        return this.anchor.sendAndConfirm(signed);
-    }
-
-    /**
-     * Attach recent blockhash + fee payer to a transaction.
-     * Required before signing and sending.
-     */
-    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 };
-    }
-
-    /**
-     * Guard for all write operations (deposit/withdraw/stake/unstake/buy).
-     * Ensures we have a Wire pubKey and an Anchor wallet pubKey, and that they match.
-     */
-    ensureUser() {
-        if (!this.pubKey || !this.anchor.wallet.publicKey) {
-            throw new Error('User Authorization required: pubKey is undefined');
-        }
-        if (
-            this.solPubKey.toBase58() !==
-            this.anchor.wallet.publicKey.toBase58()
-        ) {
-            throw new Error(
-                'Write access requires connected wallet to match pubKey',
-            );
-        }
-    }
 
-}
+}