@wireio/stake 2.7.4 → 3.0.0

package/src/networks/{ethereum/ethereum.ts → evm/evm.ts}

@@ -1,5 +1,6 @@
 import { BigNumber, ethers } from 'ethers';
-import { ChainID, EvmChainID, PublicKey as WirePubKey } from '@wireio/core';
+import { ChainID, PublicKey as WirePubKey } from '@wireio/core';
+import { EVM_WIRE_DEVNET_CHAIN_ID, isSupportedEvmContractChain } from '../../chains';
 import {
     IStakingClient,
     OPPAssertion,
@@ -7,10 +8,11 @@ import {
     StakerConfig,
     TrancheSnapshot
 } from '../../types';
-import { EthereumContractService } from './contract';
+import { EvmContractService } from './contract';
 import { preLaunchReceipt, WithdrawReceipt } from './types';
-import { buildEthereumTrancheSnapshot } from './utils';
+import { buildEvmTrancheSnapshot, formatContractErrors } from './utils';
 import { ConvertClient } from './clients/convert.client';
+import { EvmInstaswapClient } from './clients/instaswap.client';
 import { StakeClient } from './clients/stake.client';
 import { PretokenClient } from './clients/pretoken.client';
 import { OPPClient } from './clients/opp.client';
@@ -19,11 +21,11 @@ import { ValidatorClient } from './clients/validator.client';
 
 export const INITIAL_TRANCHE_SUPPLY = 35000;
 
-export class EthereumStakingClient implements IStakingClient {
+export class EvmStakingClient implements IStakingClient {
     private readonly provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
     public readonly pubKey?: WirePubKey;
     private readonly signer?: ethers.Signer;
-    private readonly contractService: EthereumContractService;
+    private readonly contractService: EvmContractService;
 
     private convertClient: ConvertClient;
     private pretokenClient: PretokenClient;
@@ -31,6 +33,7 @@ export class EthereumStakingClient implements IStakingClient {
     private oppClient: OPPClient;
     private receiptClient: ReceiptClient;
     private validatorClient: ValidatorClient;
+    public readonly instaswapClient: EvmInstaswapClient;
 
     get contract() { return this.contractService.contract; }
     get network() { return this.config.network; }
@@ -47,10 +50,15 @@ export class EthereumStakingClient implements IStakingClient {
             }
             this.pubKey = config.pubKey;
 
-            this.contractService = new EthereumContractService({
+            const chainId = config.network.chainId;
+            if (!isSupportedEvmContractChain(chainId)) {
+                throw new Error(`EVM contract suite is not configured for chainId=${chainId}`);
+            }
+
+            this.contractService = new EvmContractService({
                 provider: this.provider,
                 signer: this.signer,
-                chainId: config.network.chainId as EvmChainID,
+                chainId,
             });
 
             this.convertClient = new ConvertClient(this.contractService);
@@ -58,10 +66,16 @@ export class EthereumStakingClient implements IStakingClient {
             this.stakeClient = new StakeClient(this.contractService);
             this.oppClient = new OPPClient(this.contractService);
             this.receiptClient = new ReceiptClient(this.contractService);
-            this.validatorClient = new ValidatorClient(this.contractService)
+            this.validatorClient = new ValidatorClient(this.contractService);
+            this.instaswapClient = new EvmInstaswapClient(
+                this.contractService,
+                this.signer,
+                config.network.chainId as number,
+                config.network.rpcUrls[0],
+            );
         }
         catch (error) {
-            // console.error('Error initializing EthereumStakingClient:', error);
+            // console.error('Error initializing EvmStakingClient:', error);
             throw error;
         }
     }
@@ -133,13 +147,13 @@ export class EthereumStakingClient implements IStakingClient {
      * @param amount  Amount in wei - Keep this as a bigint / string in the caller; avoid JS floats.
      * @returns transaction hash
      */
-    async stake(amount: bigint): Promise<string> {
+    async stake(amount: bigint, wireAccount?: string): Promise<string> {
         this.ensureUser();
 
         const walletAddress = await this.address!;
         const amountWei = BigNumber.from(amount);
 
-        const result = await this.stakeClient.performStake(amountWei, walletAddress);
+        const result = await this.stakeClient.performStakeToWire(amountWei, walletAddress, wireAccount);
         return result.txHash;
     }
 
@@ -150,17 +164,28 @@ export class EthereumStakingClient implements IStakingClient {
     }
 
     /**
-     * Deposit ETH to liqETH, then stake liqETH in a single transaction.
+     * Deposit ETH to liqETH, then stake the liqETH.
      * @param amountWei  Amount in wei.
      * @returns transaction hash
      */
-    async depositAndStake(amountWei: bigint): Promise<string> {
+    async depositAndStake(amount: bigint, wireAccount?: string): Promise<string> {
         this.ensureUser();
-        if (!amountWei || amountWei <= BigInt(0))
+        if (!amount || amount <= BigInt(0))
             throw new Error('Amount must be greater than zero.');
 
-        const result = await this.stakeClient.performDepositAndStake(BigNumber.from(amountWei));
-        return result.txHash;
+
+        const walletAddress = await this.address!;
+        let amountWei = BigNumber.from(amount);
+
+
+        const result = await this.convertClient.performDeposit(amountWei);
+        console.log('result of performDeposit()', result);
+
+        const result2 = await this.stakeClient.performStakeToWire(amountWei, walletAddress, wireAccount);
+        console.log('result of performStakeToWire()', result2);
+
+        // const result = await this.stakeClient.performDepositAndStakeToWire(BigNumber.from(amountWei), wireAccount);
+        return result2.txHash;
     }
 
     /**
@@ -210,12 +235,6 @@ export class EthereumStakingClient implements IStakingClient {
 
         const buyer = await this.address!;
 
-        // ! Hoodi only - check if the mock aggregator price is stale, and if so, update it before submitting the buy request
-        // const network = await this.provider.getNetwork();
-        // const chainId = network.chainId;
-        // const allowedTestChains = new Set([560048]);
-        // if (allowedTestChains.has(chainId)) await this.updateMockAggregatorPrice();
-
         let result = await this.pretokenClient.purchasePretokensWithLiqETH(amount, buyer);
         return result && result.txHash ? result.txHash : "Error - no resulting txHash";
     }
@@ -235,6 +254,33 @@ export class EthereumStakingClient implements IStakingClient {
 
 
 
+    // ! Testnet only - check if the mock aggregator price is stale, and if so, update it before submitting the buy request
+    // async crankTestnetAggregator(): Promise<string> {
+    //     this.ensureUser();
+
+    //     const network = await this.provider.getNetwork();
+    //     const chainId = network.chainId;
+    //     const allowedTestChains = new Set([560048, 31337]);
+    //     if (!allowedTestChains.has(chainId)) return "Testnet crank is only intended for test/local networks - current chain is "+chainId+". Skipping aggregator update";
+
+    //     const [agg, opp] = await Promise.allSettled([
+    //         this.updateMockAggregatorPrice(),
+    //         this.fixOppTooManyAttestations(),
+    //     ]);
+
+    //     const fmt = (name: string, r: PromiseSettledResult<unknown>) => {
+    //         if (r.status === 'fulfilled') {
+    //             const suffix = r.value !== undefined ? ` (${String(r.value)})` : '';
+    //             return `${name}: ok${suffix}`;
+    //         }
+    //         return `${name}: failed (${String(r.reason)})`;
+    //     };
+
+    //     console.log('crankTestnetAggregator()', { agg, opp });
+    //     return `${fmt('updateMockAggregatorPrice', agg)}; ${fmt('fixOppTooManyAttestations', opp)}`;
+    // }
+
+
 
     /**
      * Resolve the user's ETH + liqETH balances.
@@ -341,7 +387,7 @@ export class EthereumStakingClient implements IStakingClient {
             return portfolio;
         }
         catch (error) {
-            // console.log('Error fetching Ethereum portfolio:', error);
+            // console.log('Error fetching EVM portfolio:', error);
             throw error;
         }
     }
@@ -374,7 +420,7 @@ export class EthereumStakingClient implements IStakingClient {
     private ensureUser() {
         if (!this.signer) {
             throw new Error(
-                'EthereumStakingClient: write operation requires a wallet-connected Web3 provider',
+                'EvmStakingClient: write operation requires a wallet-connected Web3 provider',
             );
         }
     }
@@ -421,7 +467,7 @@ export class EthereumStakingClient implements IStakingClient {
     }
 
     /**
-     * Program-level prelaunch WIRE / tranche snapshot for Ethereum
+     * Program-level prelaunch WIRE / tranche snapshot for EVM
      * 
      * SUPPORTS READ-ONLY ACcESS
      */
@@ -459,7 +505,7 @@ export class EthereumStakingClient implements IStakingClient {
 
             const initialTrancheSupply = BigInt(INITIAL_TRANCHE_SUPPLY) * BigInt(1e8);
 
-            return buildEthereumTrancheSnapshot({
+            return buildEvmTrancheSnapshot({
                 chainID,
                 totalSharesBn,
                 indexBn,
@@ -476,7 +522,7 @@ export class EthereumStakingClient implements IStakingClient {
             });
         }
         catch (err: any) {
-            throw new Error(`Error fetching Ethereum tranche snapshot: ${err?.message || err}`);
+            throw new Error(`Error fetching EVM tranche snapshot: ${err?.message || err}`);
         }
     }
 
@@ -555,50 +601,150 @@ export class EthereumStakingClient implements IStakingClient {
     // Internal ETH Staking client helper functions
     // ---------------------------------------------------------------------
 
-    // ! This is a temporary measure for Hoodi testnet because there is no aggregator deployed
-    // private async updateMockAggregatorPrice() {
-    //     const aggregator = this.contract.MockAggregator;
-
-    //     // read latest round & compute age
-    //     const [roundId, answer, startedAt, updatedAt, answeredInRound] = await aggregator.latestRoundData();
-    //     const now = (await this.provider.getBlock("latest")).timestamp;
-    //     const ageSec = Number(now) - Number(updatedAt);
-
-    //     const ONE_HOUR = 1 * 3600;
-    //     // const ONE_HOUR = 10;
-    //     if (ageSec > ONE_HOUR) {
-    //         // safety check - only run in non-production contexts
-    //         const network = await this.provider.getNetwork();
-    //         const chainId = network.chainId;
-    //         const allowedTestChains = new Set([560048]);
-    //         if (!allowedTestChains.has(chainId)) {
-    //             console.warn(`MockAggregator is stale (${ageSec}s) but chainId ${chainId} is not a test/local network — skipping update.`);
-    //             return;
-    //         }
+    // ! This is a temporary measure for testnet because there is no aggregator deployed
+    /*
+    private async updateMockAggregatorPrice() {
+        const aggregator = this.contract.MockAggregator;
+
+        // read latest round & compute age
+        const [roundId, answer, startedAt, updatedAt, answeredInRound] = await aggregator.latestRoundData();
+        const now = (await this.provider.getBlock("latest")).timestamp;
+        const ageSec = Number(now) - Number(updatedAt);
+
+        const ONE_HOUR = 1 * 3600;
+        // const ONE_HOUR = 10;
+        if (ageSec > ONE_HOUR) {
+            console.log('Attempt to run updateMockAggregatorPrice - MockAggregator price is stale by', ageSec, 'seconds - updating price before proceeding with buy...');
+
+            // safety check - only run in non-production contexts
+            const network = await this.provider.getNetwork();
+            const chainId = network.chainId;
+            const allowedTestChains = new Set([Number(EVM_WIRE_DEVNET_CHAIN_ID)]);
+            if (!allowedTestChains.has(chainId)) {
+                console.warn(`MockAggregator is stale (${ageSec}s) but chainId ${chainId} is not a test/local network — skipping update.`);
+                return;
+            }
 
 
-    //         //fetch the current ETH / USD price
-    //         const res = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
-    //         const data = await res.json();
-    //         const ethUsd = data.ethereum.usd;
+            //fetch the current ETH / USD price
+            const res = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
+            const data = await res.json();
+            const ethUsd = data.ethereum.usd;
 
-    //         const currentEthPrice = ethers.utils.parseUnits(ethUsd.toString(), 8);
+            const currentEthPrice = ethers.utils.parseUnits(ethUsd.toString(), 8);
 
-    //         try {
-    //             //update to be intentionally stale
-    //             // const alttx = await aggregator.updateStale(currentEthPrice, now - 7200);
-    //             // const altreceipt = await alttx.wait(1);
-    //             // console.log('stale update receipt', altreceipt)
+            console.log('currentEthPrice', currentEthPrice.toString())
 
-    //             //update answer with current timestamp
-    //             const tx = await aggregator.updateAnswer(currentEthPrice);
-    //             const txreceipt = await tx.wait(1);
-    //             // console.log('MockAggregator answer updated - receipt:', txreceipt)
-    //         } catch (err: any) {
-    //             console.error('MockAggregator updateAnswer failed', err?.message || err);
-    //         }
-    //     } else {
-    //         console.log(`MockAggregator updated ${ageSec}s ago — no update needed`);
-    //     }
-    // }
+            try {
+                //update to be intentionally stale
+                // const alttx = await aggregator.updateStale(currentEthPrice, now - 7200);
+                // const altreceipt = await alttx.wait(1);
+                // console.log('stale update receipt', altreceipt)
+
+                //update answer with current timestamp
+                const tx = await aggregator.updateAnswer(currentEthPrice);
+                const txreceipt = await tx.wait(1);
+                console.log('MockAggregator answer updated - receipt:', txreceipt)
+                return txreceipt
+            } catch (err: any) {
+                console.error('MockAggregator updateAnswer failed', err?.message || err);
+            }
+        } else {
+            console.log(`MockAggregator updated ${ageSec}s ago — no update needed`);
+        }
+    }
+
+
+    private async fixOppTooManyAttestations() {
+        const opp = this.contract.OPP;
+        const outpostManager = this.contract.OutpostManager;
+
+        const [authority, pendingCountRaw, maxRaw, sendModeTagRaw] = await Promise.all([
+            opp.authority(),
+            opp.pendingAttestationCount(),
+            opp.MESSAGE_EPOCH_MAX_ATTESTATIONS(),
+            opp.sendModeTag(),
+        ]);
+
+        const toBigInt = (v: any) => (typeof v === "bigint" ? v : BigInt(v.toString()));
+        const pendingCount = toBigInt(pendingCountRaw);
+        const maxAttestations = toBigInt(maxRaw);
+        const sendModeTag = toBigInt(sendModeTagRaw);
+
+        console.log(`OPP status: authority=${authority}, pendingAttestationCount=${pendingCount}, MESSAGE_EPOCH_MAX_ATTESTATIONS=${maxAttestations}, sendModeTag=${sendModeTag}`);
+        
+        if (sendModeTag === 0n) {
+            console.log("OPP is not in send mode.");
+            // return;
+        }
+
+        const shouldBumpMax = maxAttestations === 1n || pendingCount > maxAttestations;
+        if (!shouldBumpMax) {
+            console.log(
+                `No fix needed: pendingAttestationCount=${pendingCount} <= MESSAGE_EPOCH_MAX_ATTESTATIONS=${maxAttestations}`,
+            );
+            // return;
+        }
+
+        console.log(
+            `OPP bump needed (pending=${pendingCount}, max=${maxAttestations}) — attempting to set new max and ${sendModeTag === 0n ? 'skip' : 'call'} exitSendMode(${sendModeTag})...`
+        );
+
+        console.log(await this.provider.getNetwork());
+
+        
+
+        // safety check to only run in testnet
+        const network = await this.provider.getNetwork();
+        const chainId = toBigInt(network.chainId);
+        const allowedTestChains = new Set<bigint>([BigInt(Number(EVM_WIRE_DEVNET_CHAIN_ID))]);
+        if (!allowedTestChains.has(chainId)) {
+            console.warn(
+            `Refusing to modify OPP config on chainId ${chainId}. Add it to allowedTestChains if this is expected.`
+            );
+            return;
+        }
+
+        // minimal bump bump: set max to pendingCount (or a small default when max was 1) + buffer.
+        const base = pendingCount > 0n ? pendingCount : 1n;
+        // const newMax = base + 2n; // add a small buffer to prevent immediate recurrence
+        const newMax = 1n; // add a small buffer to prevent immediate recurrence
+
+        const encodeOppCall = (fn: string, args: any[]) =>
+            opp.interface.encodeFunctionData(fn, args);
+
+        try {
+            const data = encodeOppCall('setMessageEpochMaxAttestations', [newMax]);
+            await outpostManager.callStatic.execute(opp.address, data);
+            console.log('OutpostManager.execute(callStatic) setMessageEpochMaxAttestations passed');
+        } catch (e) {
+            console.error('OutpostManager.execute(callStatic) setMessageEpochMaxAttestations revert:', e);
+        }
+
+
+        try {
+            const data1 = encodeOppCall('setMessageEpochMaxAttestations', [newMax]);
+            const tx1 = await outpostManager.execute(opp.address, data1, {
+                gasLimit: 500_000,
+            });
+            const receipt1 = await tx1.wait(1);
+            console.log("setMessageEpochMaxAttestations confirmed:", receipt1);
+
+            if (sendModeTag !== 0n) {
+                const data2 = encodeOppCall('exitSendMode', [sendModeTag]);
+                const tx2 = await outpostManager.execute(opp.address, data2, {
+                    gasLimit: 500_000,
+                });
+                const receipt2 = await tx2.wait(1);
+                console.log("exitSendMode confirmed:", receipt2);
+                return { setMaxReceipt: receipt1, exitReceipt: receipt2 };
+            }
+
+            return { setMaxReceipt: receipt1 };
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            console.error("fixOppTooManyAttestations failed:", err?.message || err, errorObj);
+        }
+    }
+    */
 }

package/src/networks/{ethereum → evm}/utils.ts

@@ -16,6 +16,9 @@ export interface CustomContractError {
     raw: string;
 }
 
+const DEFAULT_WRITE_GAS_PADDING_BPS = 2_000;
+const DEFAULT_WRITE_GAS_FALLBACK_LIMIT = ethers.BigNumber.from(8_000_000);
+
 
 
 export function formatContractErrors(err: any): CustomContractError {
@@ -110,6 +113,55 @@ export async function sendOPPFinalize(opp: ethers.Contract, gasLimit?: ethers.Bi
     }
 }
 
+export async function resolveContractWriteOverrides(
+    contract: ethers.Contract,
+    method: string,
+    args: any[] = [],
+    overrides: Record<string, unknown> = {},
+    options?: {
+        fallbackGasLimit?: ethers.BigNumberish;
+        paddingBps?: number;
+    },
+): Promise<Record<string, unknown>> {
+    if (overrides['gasLimit'] != null) {
+        return overrides;
+    }
+
+    const paddingBps = options?.paddingBps ?? DEFAULT_WRITE_GAS_PADDING_BPS;
+    const fallbackGasLimit = ethers.BigNumber.from(
+        options?.fallbackGasLimit ?? DEFAULT_WRITE_GAS_FALLBACK_LIMIT,
+    );
+
+    try {
+        const estimateGas = contract.estimateGas?.[method];
+        if (typeof estimateGas !== 'function') {
+            return {
+                ...overrides,
+                gasLimit: fallbackGasLimit,
+            };
+        }
+
+        const estimated = await estimateGas(...args, overrides);
+        const gasLimit = ethers.BigNumber.from(estimated)
+            .mul(10_000 + paddingBps)
+            .div(10_000);
+
+        return {
+            ...overrides,
+            gasLimit,
+        };
+    } catch (error) {
+        console.warn(
+            `[EvmGas] estimateGas.${method} failed, using fallback gasLimit ${fallbackGasLimit.toString()}`,
+            error,
+        );
+        return {
+            ...overrides,
+            gasLimit: fallbackGasLimit,
+        };
+    }
+}
+
 
 const BPS_DENOM = BigInt(10_000);
 
@@ -154,7 +206,7 @@ function usd1e18To1e8(raw: bigint): bigint {
  *  - `currentPriceUsd` and `priceGrowthCents` are treated as 1e18-scaled USD.
  *  - Output `priceUsd` is 1e8-scaled USD (for fromScale8()).
  */
-export function buildEthereumTrancheLadder(options: {
+export function buildEvmTrancheLadder(options: {
     currentTranche: number;
     totalTrancheSupply: bigint;   // not used in local window, but kept for API parity
     initialTrancheSupply: bigint;
@@ -242,7 +294,7 @@ export function buildEthereumTrancheLadder(options: {
  * Turn raw liqsol_core accounts into a chain-agnostic TrancheSnapshot for SOL.
  * All math stays here; TokenClient just wires accounts + connection.
  */
-export async function buildEthereumTrancheSnapshot(options: {
+export async function buildEvmTrancheSnapshot(options: {
     chainID: ChainID;
     totalSharesBn;
     indexBn;
@@ -310,7 +362,7 @@ export async function buildEthereumTrancheSnapshot(options: {
 
     // ---- Build ladder ----
 
-    const ladder = buildEthereumTrancheLadder({
+    const ladder = buildEvmTrancheLadder({
         currentTranche,
         totalTrancheSupply: totalTrancheSupplyBig,
         initialTrancheSupply: initialTrancheSupplyBig,
@@ -337,4 +389,4 @@ export async function buildEthereumTrancheSnapshot(options: {
         nativePriceTimestamp,
         ladder,
     };
-}
+}

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

@@ -1,4 +1,4 @@
-import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import {
     SystemProgram,
     TransactionInstruction,
@@ -17,7 +17,7 @@ import {
     getAssociatedTokenAddressSync,
 } from '@solana/spl-token';
 
-import { LiqsolCoreClientIdl, SolanaProgramService } from '../program';
+import { SolanaProgramService } from '../program';
 import { GlobalAccount, ReceiptData, WalletLike } from '../types';
 import { BalanceView, WithdrawReceipt } from '../../../types';
 import { normalizeToBigInt } from '../utils';
@@ -30,7 +30,7 @@ import { normalizeToBigInt } from '../utils';
  * - build claim_withdraw instruction
  */
 export class ConvertClient {
-    private program: Program<LiqsolCoreClientIdl>;
+    private program: any;
 
     get connection(): Connection {
         return this.provider.connection;
@@ -54,6 +54,7 @@ export class ConvertClient {
         amount: bigint,
         user = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
+        const program = this.program;
         if (!user) throw new Error('ConvertClient.buildDepositTx: wallet not connected');
         if (!amount || amount <= BigInt(0))
             throw new Error('ConvertClient.buildDepositTx: amount must be greater than zero.');
@@ -82,7 +83,7 @@ export class ConvertClient {
         const seed = Math.floor(Math.random() * 2 ** 32);
         const ephemeralStake = await this.pgs.deriveEphemeralStakeAddress(user, seed);
 
-        return await this.program.methods
+        return await program.methods
             .deposit(new BN(amount.toString()), seed)
             .accounts({
                 user,
@@ -114,6 +115,38 @@ export class ConvertClient {
             .instruction();
     }
 
+    async buildRegisterUserIx(
+        user = this.wallet.publicKey,
+    ): Promise<TransactionInstruction> {
+        const program = this.program;
+        if (!user) throw new Error('ConvertClient.buildRegisterUserIx: wallet not connected');
+
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+        const userAta = getAssociatedTokenAddressSync(liqsolMint, user, true, TOKEN_2022_PROGRAM_ID);
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        return program.methods
+            .registerUser()
+            .accounts({
+                payer: user,
+                userAta,
+                userRecord,
+                distributionState,
+                bucketAuthority,
+                bucketTokenAccount,
+                systemProgram: SystemProgram.programId,
+            })
+            .instruction();
+    }
+
     /**
      * Build a withdraw-request instruction (liqSOL burn -> NFT receipt).
      */
@@ -121,6 +154,7 @@ export class ConvertClient {
         amount: bigint,
         user = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
+        const program = this.program;
         if (!user) throw new Error('ConvertClient.buildWithdrawTx: wallet not connected');
         if (!amount || amount <= BigInt(0))
             throw new Error('ConvertClient.buildWithdrawTx: amount must be greater than zero.');
@@ -137,7 +171,7 @@ export class ConvertClient {
         const maintenanceLedger = this.pgs.deriveMaintenanceLedgerPda();
         const globalConfig = this.pgs.deriveGlobalConfigPda();
 
-        const globalAcct: GlobalAccount = await this.program.account.global.fetch(global);
+        const globalAcct: GlobalAccount = await program.account.global.fetch(global);
         const rawId = globalAcct.nextReceiptId;
         const receiptId = normalizeToBigInt(rawId);
 
@@ -156,7 +190,7 @@ export class ConvertClient {
             TOKEN_2022_PROGRAM_ID,
         );
 
-        return await this.program.methods
+        return await program.methods
             .requestWithdraw(new BN(amount.toString()))
             .accounts({
                 user,
@@ -191,8 +225,9 @@ export class ConvertClient {
      * Enumerate withdrawal receipt NFTs owned by `owner`.
      */
     async fetchWithdrawReceipts(owner: PublicKey): Promise<WithdrawReceipt[]> {
+        const program = this.program;
         const globalPda = this.pgs.deriveWithdrawGlobalPda();
-        const globalAcct: GlobalAccount = await this.program.account.global.fetch(globalPda);
+        const globalAcct: GlobalAccount = await program.account.global.fetch(globalPda);
         const nextId = normalizeToBigInt(globalAcct.nextReceiptId);
 
         const mintToId = new Map<string, bigint>();
@@ -208,7 +243,7 @@ export class ConvertClient {
         const receipts: WithdrawReceipt[] = [];
 
         for (const { pubkey, account } of tokenAccounts.value) {
-            const info: any = account.data?.['parsed']?.info;
+            const info = account.data?.['parsed']?.info;
             if (!info) continue;
             const amount = info.tokenAmount;
             const decimals = Number(amount?.decimals ?? 0);
@@ -225,7 +260,7 @@ export class ConvertClient {
 
             let receiptData: ReceiptData;
             try {
-                const raw = await this.program.account.liqReceiptData.fetch(receiptDataPda);
+                const raw = await program.account.liqReceiptData.fetch(receiptDataPda);
                 receiptData = {
                     receiptId: normalizeToBigInt(raw.receiptId),
                     liqports: normalizeToBigInt(raw.liqports),
@@ -270,6 +305,7 @@ export class ConvertClient {
         receiptId: bigint,
         user: PublicKey,
     ): Promise<TransactionInstruction> {
+        const program = this.program;
         const mintAccount = this.pgs.deriveWithdrawNftMintPda(receiptId);
         const receiptData = this.pgs.deriveLiqReceiptDataPda(mintAccount);
         const ownerAta = getAssociatedTokenAddressSync(
@@ -297,7 +333,7 @@ export class ConvertClient {
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
         };
 
-        return this.program.methods.claimWithdraw().accounts(accounts).instruction();
+        return program.methods.claimWithdraw().accounts(accounts).instruction();
     }
 
     /**
@@ -338,4 +374,4 @@ export class ConvertClient {
         const etaMs = Math.max(0, Math.round(etaSeconds * 1000));
         return { etaMs, readyAtMs: Date.now() + etaMs };
     }
-}
+}