@wireio/stake 2.1.1 → 2.2.2

package/src/networks/solana/solana.ts

@@ -1,4 +1,5 @@
 import {
+    AddressLookupTableAccount,
     Commitment,
     ComputeBudgetProgram,
     Connection,
@@ -220,138 +221,21 @@ export class SolanaStakingClient implements IStakingClient {
     // IStakingClient core methods
     // ---------------------------------------------------------------------
 
-
-    async createVaultLiqsolAtaOneShot(params: {
-        connection: Connection;
-        payer: SolPubKey;      // user's wallet pubkey (signer)
-        vaultPda: SolPubKey;   // squads vault PDA (off-curve owner)
-    }): Promise<{ tx: Transaction; vaultAta: SolPubKey } | null> {
-        const { connection, payer, vaultPda } = params;
-
-        const liqsolMint = this.program.deriveLiqsolMintPda();
-
-        const vaultAta = getAssociatedTokenAddressSync(
-            liqsolMint,
-            vaultPda,
-            true, // allowOwnerOffCurve
-            TOKEN_2022_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID,
-        );
-
-        // If it already exists, just no-op
-        const info = await connection.getAccountInfo(vaultAta, "confirmed");
-
-        if (info) return null;
-
-        const ix = createAssociatedTokenAccountInstruction(
-            payer,      // payer = user
-            vaultAta,   // ata address
-            vaultPda,   // owner = vault
-            liqsolMint,
-            TOKEN_2022_PROGRAM_ID,
-            ASSOCIATED_TOKEN_PROGRAM_ID,
-        );
-
-        const tx = new Transaction().add(ix);
-        return { tx, vaultAta };
-    }
-
-    private async prepSquadsIxs(ix: TransactionInstruction): Promise<TransactionInstruction[]> {
-        if (!this.squadsX) throw new Error('Attempting to wrap Squads instruction without SquadsX config');
-
-        const multisigPda = this.squadsMultisigPDA!;
-        const vaultPda = this.squadsVaultPDA!;
-        const vaultIndex = this.squadsX?.vaultIndex ?? 0;
-        const creator = this.solPubKey;
-
-        // compute next transactionIndex 
-        const ms = await multisig.accounts.Multisig.fromAccountAddress(this.connection, multisigPda);
-        const current = BigInt(ms.transactionIndex?.toString() ?? 0);
-        const transactionIndex = current + BigInt(1);
-
-        // inner message uses vault as payer
-        // const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 });
-        const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
-        const transactionMessage = new TransactionMessage({
-            payerKey: vaultPda,
-            recentBlockhash: blockhash,
-            instructions: [ix],
-        });
-
-        const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
-            multisigPda,
-            transactionIndex,
-            creator,
-            vaultIndex,
-            transactionMessage,
-            ephemeralSigners: 0,
-        });
-
-        const createProposalIx = await multisig.instructions.proposalCreate({
-            multisigPda,
-            transactionIndex,
-            creator,
-        });
-
-        return [createVaultTxIx, createProposalIx];
-    }
-
     /**
      * Deposit native SOL into liqSOL (liqsol_core::deposit).
      * Handles tx build, sign, send, and confirmation.
      */
     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 {
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-            // console.log('amountLamports', amountLamports);
-
-            // if (!!this.squadsX) {
-
-            //     const createVaultTx = await this.createVaultLiqsolAtaOneShot({
-            //         connection: this.connection,
-            //         payer: this.solPubKey,
-            //         vaultPda: this.squadsVaultPDA!,
-            //     })
-
-            //     if (createVaultTx !== null) {
-            //         // console.log('need to create vault ata first...');
-            //         const tx0 = new Transaction().add(createVaultTx.tx);
-            //         const prepared0 = await this.prepareTx(tx0);
-            //         const signed0 = await this.signTransaction(prepared0.tx);
-            //         const sent0 = await this.sendAndConfirmHttp(signed0, prepared0);
-            //         // console.log('create Vault ATA', sent0);
-            //     }
-
-            //     const ix = await this.depositClient.buildDepositTx(amountLamports, this.squadsVaultPDA!)
-            //     const squadIxs = await this.prepSquadsIxs(ix)
-
-            //     const tx1 = new Transaction().add(cuIx, squadIxs[0]);
-            //     const prepared1 = await this.prepareTx(tx1);
-            //     const signed1 = await this.signTransaction(prepared1.tx);
-            //     const sent1 = await this.sendAndConfirmHttp(signed1, prepared1);
-            //     console.log('SENT 1', sent1);
-
-            //     const tx2 = new Transaction().add(cuIx, squadIxs[1]);
-            //     const prepared2 = await this.prepareTx(tx2);
-            //     const signed2 = await this.signTransaction(prepared2.tx);
-            //     const sent2 = await this.sendAndConfirmHttp(signed2, prepared2);
-            //     console.log('SENT 2', sent2);
-
-            //     return sent2;
-            // }
-            // else {
-            const ix = await this.depositClient.buildDepositTx(amountLamports)
-            const tx = new Transaction().add(ix);
-            const prepared = await this.prepareTx(tx);
-            const signed = await this.signTransaction(prepared.tx);
-
-            return this.sendAndConfirmHttp(signed, prepared);
-            // }
+            const ix = await this.depositClient.buildDepositTx(amountLamports, this.squadsVaultPDA)
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
+
         } catch (err) {
             console.log(`Failed to deposit Solana: ${err}`);
             throw err;
@@ -370,23 +254,15 @@ 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 });
+            const ix = await this.depositClient.buildWithdrawTx(amountLamports, this.squadsVaultPDA)
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
 
-            // 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);
-
-            return this.sendAndConfirmHttp(signed, prepared);
         } catch (err) {
             console.log(`Failed to withdraw Solana: ${err}`);
             throw err;
@@ -398,26 +274,15 @@ export class SolanaStakingClient implements IStakingClient {
      */
     async stake(amountLamports: bigint): Promise<string> {
         this.ensureUser();
-
-        if (!amountLamports || amountLamports <= BigInt(0)) {
+        if (!amountLamports || amountLamports <= BigInt(0))
             throw new Error('Stake 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 synd instruction
-            const ix = await this.outpostClient.buildStakeIx(amountLamports, user);
+            const ix = await this.outpostClient.buildStakeIx(amountLamports, this.squadsVaultPDA)
+            return !!this.squadsX
+                ? await this.sendSquadsIxs(ix)
+                : await this.buildAndSendIx(ix)
 
-            // 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);
         } catch (err) {
             console.log(`Failed to stake Solana: ${err}`);
             throw err;
@@ -429,26 +294,14 @@ 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) {
             console.log(`Failed to unstake Solana: ${err}`);
@@ -464,20 +317,14 @@ 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 user = this.solPubKey;
-            const cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
-            const ix = await this.tokenClient.buildPurchaseIx(amountLamports, user);
-
-            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.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}`);
@@ -495,8 +342,7 @@ export class SolanaStakingClient implements IStakingClient {
      *  - extras: useful internal addresses and raw state for debugging/UX
      */
     async getPortfolio(): Promise<Portfolio> {
-        if (!this.pubKey) throw new Error('User pubKey is undefined');
-
+        // if (!this.pubKey) throw new Error('User pubKey is undefined');
         try {
             const user = !!this.squadsX ? this.squadsVaultPDA! : this.solPubKey;
 
@@ -507,7 +353,7 @@ export class SolanaStakingClient implements IStakingClient {
             const userLiqsolAta = getAssociatedTokenAddressSync(
                 liqsolMint,
                 user,
-                true,   //set to true to allow off curve (e.g. PDA for squadsx wallet)
+                true,
                 TOKEN_2022_PROGRAM_ID,
                 ASSOCIATED_TOKEN_PROGRAM_ID,
             );
@@ -652,18 +498,224 @@ export class SolanaStakingClient implements IStakingClient {
     // SquadsX Helpers
     // ---------------------------------------------------------------------
 
-    get squadsMultisigPDA(): SolPubKey | null {
-        if (!this.squadsX) return null;
+    get squadsMultisigPDA(): SolPubKey | undefined {
+        if (!this.squadsX) return undefined;
         return new SolPubKey(this.squadsX.multisigPDA);
     }
-    get squadsVaultPDA(): SolPubKey | null {
-        if (!this.squadsX || !this.squadsMultisigPDA) return null;
+
+    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];
     }
 
+    private async sendSquadsIxs(ix: TransactionInstruction): Promise<string> {
+        if (!this.squadsX) throw new Error('Attempting to wrap Squads instruction without SquadsX config');
+
+        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_LOOKUP_TABLE;
+        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: 400_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, ix],
+        });
+
+        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 cuIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 });
+        const ixs = Array.isArray(ix) ? ix : [ix];
+        const tx = new Transaction().add(cuIx, ...ixs);
+        const prepared = await this.prepareTx(tx);
+        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',
+        //     );
+        // }
+    }
+
     // ---------------------------------------------------------------------
     // READ-ONLY Public Methods
     // ---------------------------------------------------------------------
@@ -745,13 +797,34 @@ export class SolanaStakingClient implements IStakingClient {
             return Number(DEFAULT_AVERAGE_PAY_RATE) / Number(PAY_RATE_SCALE_FACTOR);
         }
 
-        // Latest entry is at (currentIndex - 1 + maxEntries) % maxEntries
         const currentIndex = Number(payRateHistory.currentIndex);
-        const latestIdx = (currentIndex - 1 + maxEntries) % maxEntries;
-        const latestEntry = payRateHistory.entries[latestIdx];
 
-        const raw = BigInt(latestEntry.scaledRate.toString());
-        return Number(raw) / Number(PAY_RATE_SCALE_FACTOR);
+        // 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);
+
+        let sum = BigInt(0);
+        let validCount = 0;
+        // Walk backward from most recent entry
+        let idx = (currentIndex - 1 + maxEntries) % maxEntries;
+
+        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;
+        }
+
+        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
@@ -1029,130 +1102,5 @@ export class SolanaStakingClient implements IStakingClient {
         return singleTxFeeLamports;
     }
 
-    // ---------------------------------------------------------------------
-    // Tx helpers
-    // ---------------------------------------------------------------------
-
-    /**
-     * 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',
-        //     );
-        // }
-    }
 
 }