@wireio/stake 0.3.1 → 0.4.1

package/src/networks/solana/solana.ts

@@ -1,11 +1,10 @@
 import {
     Commitment,
+    ComputeBudgetProgram,
     Connection,
     ConnectionConfig,
-    LAMPORTS_PER_SOL,
     PublicKey as SolPubKey,
     Transaction,
-    TransactionInstruction,
     TransactionSignature,
 } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
@@ -41,6 +40,7 @@ import {
     deriveLiqsolMintPda,
     deriveReservePoolPda,
     deriveVaultPda,
+    INDEX_SCALE,
 } from './constants';
 
 import { buildSolanaTrancheSnapshot } from './utils';
@@ -52,23 +52,23 @@ const commitment: Commitment = 'confirmed';
  * Solana implementation of IStakingClient.
  *
  * Responsibilities:
- *  - Wire together liqSOL deposit/withdraw
- *  - Outpost stake/unstake
- *  - Prelaunch WIRE (pretokens) buy flows
- *  - Unified portfolio + tranche snapshot + buy quotes
+ *  - liqSOL deposit (SOL -> liqSOL)
+ *  - withdraw requests (liqSOL -> NFT receipt / encumbered SOL)
+ *  - Pretoken (WIRE) buys via liqSOL
+ *  - Unified portfolio + tranche snapshot + balance correction (later)
  *
- * This class composes lower-level clients; it does not know about UI.
+ * This composes lower-level clients; it does not know about UI.
  */
 export class SolanaStakingClient implements IStakingClient {
-    public pubKey?: PublicKey;
+    public pubKey?: PublicKey; // Wire ED key (optional → read-only)
     public connection: Connection;
     public anchor: AnchorProvider;
 
-    private depositClient: DepositClient;
-    private distributionClient: DistributionClient;
-    private leaderboardClient: LeaderboardClient;
-    private outpostClient: OutpostClient;
-    private tokenClient: TokenClient;
+    public depositClient: DepositClient;
+    public distributionClient: DistributionClient;
+    public leaderboardClient: LeaderboardClient;
+    public outpostClient: OutpostClient;
+    public tokenClient: TokenClient;
 
     get solPubKey(): SolPubKey {
         if (!this.pubKey) throw new Error('pubKey is undefined');
@@ -80,20 +80,53 @@ export class SolanaStakingClient implements IStakingClient {
     }
 
     constructor(private config: StakerConfig) {
-        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');
-        
-        const publicKey = adapter.publicKey || new SolPubKey(new Uint8Array(32))
-        if (config.pubKey){
-            // If pubKey provided, ensure it matches the adapter's pubkey
-            const wirePub = new PublicKey(KeyType.ED, publicKey.toBytes());
-            if (!wirePub.equals(config.pubKey)) 
-                throw new Error("Passed-in pubKey doesn't match adapter.publicKey");
-            // All good; assign it
+        const adapter = config.provider as BaseSignerWalletAdapter | undefined;
+
+        if (!config.network.rpcUrls.length) {
+            throw new Error('No RPC URLs provided');
+        }
+
+        // -------------------------------------------------------------
+        // Resolve Solana wallet pubkey (or dummy in read-only mode)
+        // -------------------------------------------------------------
+        let solWalletPubkey: SolPubKey;
+        if (adapter?.publicKey) {
+            solWalletPubkey = adapter.publicKey;
+        } else {
+            // Zeroed pubkey when no wallet (read-only usage)
+            solWalletPubkey = new SolPubKey(new Uint8Array(32));
+        }
+
+        // -------------------------------------------------------------
+        // Resolve Wire pubKey
+        // -------------------------------------------------------------
+        if (config.pubKey) {
+            const wirePub = config.pubKey;
+
+            if (adapter?.publicKey) {
+                const derived = new PublicKey(
+                    KeyType.ED,
+                    adapter.publicKey.toBytes(),
+                );
+                if (!derived.equals(wirePub)) {
+                    throw new Error(
+                        "Passed-in pubKey doesn't match adapter.publicKey",
+                    );
+                }
+            }
+
             this.pubKey = wirePub;
+        } else if (adapter?.publicKey) {
+            // Derive Wire pubKey from adapter when not explicitly passed
+            this.pubKey = new PublicKey(
+                KeyType.ED,
+                adapter.publicKey.toBytes(),
+            );
         }
 
+        // -------------------------------------------------------------
+        // Connection + AnchorProvider
+        // -------------------------------------------------------------
         const opts: ConnectionConfig = { commitment };
         if (
             config.network.rpcUrls.length > 1 &&
@@ -102,20 +135,47 @@ export class SolanaStakingClient implements IStakingClient {
             opts.wsEndpoint = config.network.rpcUrls[1];
         }
 
-        const anchorWallet = {
-            publicKey,
-            async signTransaction<T extends SolanaTransaction>(tx: T): Promise<T> {
-                return adapter.signTransaction(tx);
-            },
-            async signAllTransactions<T extends SolanaTransaction>(
-                txs: T[],
-            ): Promise<T[]> {
-                return Promise.all(txs.map((tx) => adapter.signTransaction(tx)));
-            },
-        };
+        const anchorWallet = adapter
+            ? {
+                publicKey: solWalletPubkey,
+                async signTransaction<T extends SolanaTransaction>(
+                    tx: T,
+                ): Promise<T> {
+                    return adapter.signTransaction(tx);
+                },
+                async signAllTransactions<T extends SolanaTransaction>(
+                    txs: T[],
+                ): Promise<T[]> {
+                    if (adapter.signAllTransactions) {
+                        return adapter.signAllTransactions(txs);
+                    }
+                    return Promise.all(
+                        txs.map((tx) => adapter.signTransaction(tx)),
+                    );
+                },
+            }
+            : {
+                publicKey: solWalletPubkey,
+                async signTransaction<T extends SolanaTransaction>(
+                    _tx: T,
+                ): Promise<T> {
+                    throw new Error(
+                        'Wallet not connected: signTransaction not available',
+                    );
+                },
+                async signAllTransactions<T extends SolanaTransaction>(
+                    _txs: T[],
+                ): Promise<T[]> {
+                    throw new Error(
+                        'Wallet not connected: signAllTransactions not available',
+                    );
+                },
+            };
 
         this.connection = new Connection(config.network.rpcUrls[0], opts);
-        this.anchor = new AnchorProvider(this.connection, anchorWallet, { commitment });
+        this.anchor = new AnchorProvider(this.connection, anchorWallet, {
+            commitment,
+        });
 
         this.depositClient = new DepositClient(this.anchor);
         this.distributionClient = new DistributionClient(this.anchor);
@@ -139,9 +199,8 @@ export class SolanaStakingClient implements IStakingClient {
         }
 
         const tx = await this.depositClient.buildDepositTx(amountLamports);
-        const { tx: prepared, blockhash, lastValidBlockHeight } = await this.prepareTx(
-            tx,
-        );
+        const { tx: prepared, blockhash, lastValidBlockHeight } =
+            await this.prepareTx(tx);
         const signed = await this.signTransaction(prepared);
         return await this.sendAndConfirmHttp(signed, {
             blockhash,
@@ -150,89 +209,109 @@ export class SolanaStakingClient implements IStakingClient {
     }
 
     /**
-     * Withdraw SOL from liqSOL protocol.
-     * NOTE: placeholder until a withdraw flow is implemented in DepositClient.
+     * Request a withdraw from liqSOL to SOL (liqsol_core::requestWithdraw).
+     *
+     * This:
+     *  - burns liqSOL from the user ATA
+     *  - mints an NFT withdrawal receipt
+     *  - increases totalEncumberedFunds in global state
+     *
+     * Actual SOL payout happens later via the operator-side flow.
      */
-    async withdraw(_amountLamports: bigint): Promise<string> {
+    async withdraw(amountLamports: bigint): Promise<string> {
         this.ensureWriteAccess();
-        throw new Error('Withdraw method not yet implemented.');
+        if (amountLamports <= BigInt(0)) {
+            throw new Error('Withdraw amount must be greater than zero.');
+        }
+
+        const tx = await this.depositClient.buildWithdrawTx(amountLamports);
+        const { tx: prepared, blockhash, lastValidBlockHeight } =
+            await this.prepareTx(tx);
+        const signed = await this.signTransaction(prepared);
+        return await this.sendAndConfirmHttp(signed, {
+            blockhash,
+            lastValidBlockHeight,
+        });
     }
 
     /**
-     * Stake liqSOL into Outpost (liqSOL -> pool).
-     * Ensures user ATA exists, then stakes via outpostClient.
+     * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
      */
     async stake(amountLamports: bigint): Promise<string> {
         this.ensureWriteAccess();
-        if (amountLamports <= BigInt(0)) {
+
+        if (!amountLamports || amountLamports <= BigInt(0)) {
             throw new Error('Stake amount must be greater than zero.');
         }
 
-        const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(
-            this.solPubKey,
-        );
-        const stakeIx = await this.outpostClient.buildStakeLiqsolIx(amountLamports);
-        const tx = new Transaction().add(...preIxs, stakeIx);
+        const user = this.solPubKey;
+
+        // Build the Outpost synd instruction
+        const ix = await this.outpostClient.buildStakeIx(amountLamports, user);
 
+        // Wrap in a transaction and send
+        const tx = new Transaction().add(ix);
         const prepared = await this.prepareTx(tx);
         const signed = await this.signTransaction(prepared.tx);
-        return await this.sendAndConfirmHttp(signed, prepared);
+
+        return this.sendAndConfirmHttp(signed, prepared);
     }
 
     /**
-     * Unstake liqSOL from Outpost (pool -> liqSOL).
-     * Mirrors stake() but calls withdrawStake.
+     * Unstake liqSOL from Outpost (pool → liqSOL) via liqsol_core::desynd.
      */
     async unstake(amountLamports: bigint): Promise<string> {
         this.ensureWriteAccess();
-        if (amountLamports <= BigInt(0)) {
+
+        if (!amountLamports || amountLamports <= BigInt(0)) {
             throw new Error('Unstake amount must be greater than zero.');
         }
 
         const user = this.solPubKey;
-        const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
-        const withdrawIx =
-            await this.outpostClient.buildWithdrawStakeIx(amountLamports);
-        const tx = new Transaction().add(...preIxs, withdrawIx);
 
+        // Build the Outpost desynd instruction
+        const ix = await this.outpostClient.buildUnstakeIx(amountLamports, user);
+
+        // Wrap in a transaction and send
+        const tx = new Transaction().add(ix);
         const prepared = await this.prepareTx(tx);
         const signed = await this.signTransaction(prepared.tx);
-        return await this.sendAndConfirmHttp(signed, prepared);
+
+        return this.sendAndConfirmHttp(signed, prepared);
     }
 
     /**
-     * Buy prelaunch WIRE “pretokens” using a supported asset.
+     * Buy prelaunch WIRE “pretokens” using liqSOL.
      *
-     * - SOL: uses purchase_with_sol
-     * - LIQSOL: uses purchase_with_liqsol
-     * - YIELD: uses purchase_warrants_from_yield
-     *
-     * ETH / LIQETH are not valid on Solana.
+     * This delegates to TokenClient, which uses the `purchase`-style
+     * instruction under the new IDL (no more native-SOL purchase).
      */
     async buy(amountLamports: bigint): Promise<string> {
         this.ensureWriteAccess();
-        if (!amountLamports || amountLamports <= BigInt(0)) 
+        if (!amountLamports || amountLamports <= BigInt(0)) {
             throw new Error('liqSOL pretoken purchase requires a positive amount.');
-        
+        }
+
         const user = this.solPubKey;
-        const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
-        const ix = await this.tokenClient.buildPurchaseWithLiqsolIx(
-            amountLamports,
-            user,
-        );
-        const tx = new Transaction().add(...preIxs, ix);
-        const prepared = await this.prepareTx(tx);
-        const signed = await this.signTransaction(prepared.tx);
-        return await this.sendAndConfirmHttp(signed, prepared);
+        const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
+        const ix = await this.tokenClient.buildPurchaseIx(amountLamports, user);
+        const tx = new Transaction().add(cuIx, ix);
+        const { tx: prepared, blockhash, lastValidBlockHeight } =
+            await this.prepareTx(tx);
+        const signed = await this.signTransaction(prepared);
+        return await this.sendAndConfirmHttp(signed, {
+            blockhash,
+            lastValidBlockHeight,
+        });
     }
 
     /**
      * Aggregate view of the user’s balances on Solana:
      *  - native: SOL wallet balance
      *  - liq: liqSOL token balance (Token-2022 ATA)
-     *  - staked: Outpost-staked liqSOL principal
-     *  - tracked: distribution program trackedBalance (liqSOL)
-     *  - wire: total prelaunch WIRE shares (warrants/pretokens, 1e8)
+     *  - staked: liqSOL staked in Outpost (synd/desynd) → outpostAccount.stakedLiqsol
+     *  - wire: total WIRE pretokens purchased (1e8 scale)
+     *  - 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> {
@@ -252,75 +331,123 @@ export class SolanaStakingClient implements IStakingClient {
             ASSOCIATED_TOKEN_PROGRAM_ID,
         );
 
-        const [
-            nativeLamports,
-            actualBalResp,
-            userRecord,
-            snapshot,
-        ] = await Promise.all([
+        // NOTE:
+        //  - nativeLamports: wallet SOL
+        //  - actualBalResp: liqSOL balance in user ATA
+        //  - snapshot: Outpost + pretokens + global index/shares
+        const [nativeLamports, actualBalResp, snapshot] = await Promise.all([
             this.connection.getBalance(user, 'confirmed'),
             this.connection
                 .getTokenAccountBalance(userLiqsolAta, 'confirmed')
                 .catch(() => null),
-            this.distributionClient.getUserRecord(user).catch(() => null),
-            this.outpostClient.getWireStateSnapshot(user).catch(() => null),
+            this.outpostClient.fetchWireState(user).catch(() => null),
         ]);
 
         const LIQSOL_DECIMALS = 9;
 
         const actualAmountStr = actualBalResp?.value?.amount ?? '0';
-        const trackedAmountStr =
-            userRecord?.trackedBalance?.toString() ?? '0';
 
-        const wireReceipt = snapshot?.wireReceipt ?? null;
-        const userWarrantRecord = snapshot?.userWarrantRecord ?? null;
-        const trancheState = snapshot?.trancheState ?? null;
         const globalState = snapshot?.globalState ?? null;
-
-        const stakedAmountStr =
-            wireReceipt?.stakedLiqsol?.toString() ?? '0';
-
-        const wireSharesStr =
-            userWarrantRecord?.totalWarrantsPurchased?.toString() ?? '0';
+        const outpostAccount = snapshot?.outpostAccount ?? null;
+        const trancheState = snapshot?.trancheState ?? null;
+        const userPretokenRecord = snapshot?.userPretokenRecord ?? null;
+
+        // -----------------------------
+        //  Staked liqSOL (Outpost)
+        // -----------------------------
+        // This is the liqSOL that has been syndicated into Outpost via `synd`.
+        // It lives on the outpost account as `stakedLiqsol`.
+        const stakedLiqsolStr =
+            outpostAccount?.stakedLiqsol?.toString?.() ?? '0';
+
+        // -----------------------------
+        //  WIRE pretokens (1e8 scale)
+        // -----------------------------
+        // This is NOT stake — it’s the prelaunch WIRE position.
+        const wirePretokensStr =
+            userPretokenRecord?.totalPretokensPurchased?.toString?.() ??
+            '0';
+
+        // -----------------------------
+        //  Yield view (index + shares)
+        // -----------------------------
+        // We expose:
+        //  - currentIndex: globalState.currentIndex (1e12 scale)
+        //  - totalShares:  globalState.totalShares
+        //  - userShares:   outpostAccount.stakedShares
+        //  - estimatedClaimLiqsol: floor(userShares * index / INDEX_SCALE)
+        //  - estimatedYieldLiqsol: max(0, estimatedClaim - stakedLiqsol)
+        //
+        // This matches the capital-staking math:
+        //   sharesToTokens(shares, index) = shares * index / INDEX_SCALE
+        const currentIndexStr =
+            globalState?.currentIndex?.toString?.() ?? '0';
+        const totalSharesStr =
+            globalState?.totalShares?.toString?.() ?? '0';
+        const userSharesStr =
+            outpostAccount?.stakedShares?.toString?.() ?? '0';
+
+        const stakedLiqsol = BigInt(stakedLiqsolStr);
+        const currentIndex = BigInt(currentIndexStr);
+        const totalShares = BigInt(totalSharesStr);
+        const userShares = BigInt(userSharesStr);
+
+        let estimatedClaimLiqsol = BigInt(0);
+        let estimatedYieldLiqsol = BigInt(0);
+
+        if (userShares > BigInt(0) && currentIndex > BigInt(0)) {
+            // sharesToTokens(userShares, currentIndex)
+            estimatedClaimLiqsol = (userShares * currentIndex) / INDEX_SCALE;
+
+            if (estimatedClaimLiqsol > stakedLiqsol) {
+                estimatedYieldLiqsol = estimatedClaimLiqsol - stakedLiqsol;
+            }
+        }
 
         return {
             native: {
                 amount: BigInt(nativeLamports),
-                symbol: "SOL",
+                symbol: 'SOL',
                 decimals: 9,
             },
             liq: {
                 amount: BigInt(actualAmountStr),
-                symbol: "LiqSOL",
+                symbol: 'LiqSOL',
                 decimals: LIQSOL_DECIMALS,
                 ata: userLiqsolAta,
             },
             staked: {
-                amount: BigInt(stakedAmountStr),
-                symbol: "LiqSOL",
+                // liqSOL staked in Outpost via `synd`
+                amount: stakedLiqsol,
+                symbol: 'LiqSOL',
                 decimals: LIQSOL_DECIMALS,
             },
             wire: {
-                // Prelaunch pretokens / WIRE shares (1e8)
-                amount: BigInt(wireSharesStr),
-                symbol: "$WIRE",
+                // Prelaunch WIRE pretokens (1e8 scale)
+                amount: BigInt(wirePretokensStr),
+                symbol: '$WIRE',
                 decimals: 8,
             },
-            tracked: {
-                amount: BigInt(trackedAmountStr),
-                symbol: "LiqSOL",
-                decimals: LIQSOL_DECIMALS,
+            yield: {
+                // Raw primitives so the frontend can display curves, charts, etc.
+                currentIndex,
+                indexScale: INDEX_SCALE,
+                totalShares,
+                userShares,
+                // liqSOL amounts (lamports) implied by index/shares
+                estimatedClaimLiqsol,
+                estimatedYieldLiqsol,
             },
             extras: {
                 userLiqsolAta: userLiqsolAta.toBase58(),
                 reservePoolPDA: reservePoolPDA.toBase58(),
                 vaultPDA: vaultPDA.toBase58(),
-                wireReceipt,
-                userWarrantRecord,
                 globalIndex: globalState?.currentIndex?.toString(),
                 totalShares: globalState?.totalShares?.toString(),
-                currentTrancheNumber: trancheState?.currentTrancheNumber?.toString(),
-                currentTranchePriceUsd: trancheState?.currentTranchePriceUsd?.toString(), // 1e8 USD
+                currentTrancheNumber:
+                    trancheState?.currentTrancheNumber?.toString(),
+                currentTranchePriceUsd:
+                    trancheState?.currentTranchePriceUsd?.toString(), // 1e8 USD
             },
             chainID: this.network.chainId,
         };
@@ -332,13 +459,9 @@ export class SolanaStakingClient implements IStakingClient {
      * Uses:
      *  - liqsol_core.globalState (currentIndex, totalShares, etc.)
      *  - liqsol_core.trancheState (price, supply, total sold, etc.)
-     *  - Chainlink/PriceHistory for SOL/USD (via TokenClient.getSolPriceUsdSafe)
+     *  - PriceHistory/Chainlink SOL/USD via TokenClient.getSolPriceUsdSafe()
      *
-     * windowBefore/windowAfter control how many ladder rows we precompute
-     * around the current tranche for UI, but you can pass nothing if you
-     * only need current tranche info.
-     * 
-     * READ-ONLY allowed
+     * This is READ-ONLY and works even with no connected wallet.
      */
     async getTrancheSnapshot(options?: {
         chainID?: ChainID;
@@ -351,14 +474,11 @@ export class SolanaStakingClient implements IStakingClient {
             windowAfter,
         } = options ?? {};
 
-        // Canonical program state
         const [globalState, trancheState] = await Promise.all([
             this.tokenClient.fetchGlobalState(),
             this.tokenClient.fetchTrancheState(),
         ]);
 
-
-        // Latest SOL/USD price (1e8) + timestamp from PriceHistory
         const { price: solPriceUsd, timestamp } =
             await this.tokenClient.getSolPriceUsdSafe();
 
@@ -382,29 +502,6 @@ export class SolanaStakingClient implements IStakingClient {
         return this.distributionClient.getUserRecord(this.solPubKey);
     }
 
-    /**
-     * Run the "correct & register" flow on Solana:
-     *  - builds the minimal transaction (maybe multi-user) to reconcile liqSOL
-     *  - signs and sends the transaction if it can succeed
-     */
-    async correctBalance(amount?: bigint): Promise<string> {
-        this.ensureWriteAccess();
-        const build = await this.distributionClient.buildCorrectRegisterTx({ amount });
-        if (!build.canSucceed || !build.transaction) {
-            throw new Error(build.reason ?? 'Unable to build Correct&Register transaction');
-        }
-
-        const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(
-            build.transaction,
-        );
-        const signed = await this.signTransaction(tx);
-        const signature = await this.sendAndConfirmHttp(signed, {
-            blockhash,
-            lastValidBlockHeight,
-        });
-        return signature;
-    }
-
     // ---------------------------------------------------------------------
     // Tx helpers
     // ---------------------------------------------------------------------
@@ -418,7 +515,8 @@ export class SolanaStakingClient implements IStakingClient {
         ctx: { blockhash: string; lastValidBlockHeight: number },
     ): Promise<string> {
         this.ensureWriteAccess();
-            const signature = await this.connection.sendRawTransaction(
+
+        const signature = await this.connection.sendRawTransaction(
             signed.serialize(),
             {
                 skipPreflight: false,
@@ -437,7 +535,9 @@ export class SolanaStakingClient implements IStakingClient {
         );
 
         if (conf.value.err) {
-            throw new Error(`Transaction failed: ${JSON.stringify(conf.value.err)}`);
+            throw new Error(
+                `Transaction failed: ${JSON.stringify(conf.value.err)}`,
+            );
         }
 
         return signature;
@@ -446,7 +546,9 @@ export class SolanaStakingClient implements IStakingClient {
     /**
      * Sign a single Solana transaction using the connected wallet adapter.
      */
-    async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
+    async signTransaction(
+        tx: SolanaTransaction,
+    ): Promise<SolanaTransaction> {
         this.ensureWriteAccess();
         return this.anchor.wallet.signTransaction(tx);
     }
@@ -455,7 +557,9 @@ export class SolanaStakingClient implements IStakingClient {
      * Generic "fire and forget" send helper if the caller already
      * prepared and signed the transaction.
      */
-    async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
+    async sendTransaction(
+        signed: SolanaTransaction,
+    ): Promise<TransactionSignature> {
         this.ensureWriteAccess();
         return this.anchor.sendAndConfirm(signed);
     }
@@ -466,7 +570,11 @@ export class SolanaStakingClient implements IStakingClient {
      */
     async prepareTx(
         tx: Transaction,
-    ): Promise<{ tx: Transaction; blockhash: string; lastValidBlockHeight: number }> {
+    ): Promise<{
+        tx: Transaction;
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }> {
         const { blockhash, lastValidBlockHeight } =
             await this.connection.getLatestBlockhash('confirmed');
         tx.recentBlockhash = blockhash;
@@ -474,10 +582,21 @@ export class SolanaStakingClient implements IStakingClient {
         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.
+     */
     ensureWriteAccess() {
-        if (!this.pubKey || !this.anchor.wallet.publicKey)
+        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');
+        }
+        if (
+            this.solPubKey.toBase58() !==
+            this.anchor.wallet.publicKey.toBase58()
+        ) {
+            throw new Error(
+                'Write access requires connected wallet to match pubKey',
+            );
+        }
     }
 }