@wireio/stake 0.5.2 → 0.6.69

package/src/networks/ethereum/ethereum.ts

@@ -8,13 +8,14 @@ import {
     TrancheSnapshot
 } from '../../types';
 import { EthereumContractService } from './contract';
-import { preLaunchReceipt } from './types';
-import { buildEthereumTrancheSnapshot } from './utils';
+import { preLaunchReceipt, WithdrawReceipt } from './types';
+import { buildEthereumTrancheSnapshot, formatContractErrors } from './utils';
 import { ConvertClient } from './clients/convert.client';
 import { StakeClient } from './clients/stake.client';
 import { PretokenClient } from './clients/pretoken.client';
 import { OPPClient } from './clients/opp.client';
 import { ReceiptClient } from './clients/receipt.client';
+import { ValidatorClient } from './clients/validator.client';
 
 export const INITIAL_TRANCHE_SUPPLY = 35000;
 
@@ -29,10 +30,11 @@ export class EthereumStakingClient implements IStakingClient {
     private stakeClient: StakeClient;
     private oppClient: OPPClient;
     private receiptClient: ReceiptClient;
-
+    private validatorClient: ValidatorClient;
 
     get contract() { return this.contractService.contract; }
     get network() { return this.config.network; }
+    get address() { return this.signer?.getAddress(); }
 
     constructor(private config: StakerConfig) {
         try {
@@ -48,6 +50,7 @@ export class EthereumStakingClient implements IStakingClient {
             this.contractService = new EthereumContractService({
                 provider: this.provider,
                 signer: this.signer,
+                chainId: config.network.chainId as EvmChainID,
             });
 
             this.convertClient = new ConvertClient(this.contractService);
@@ -55,6 +58,7 @@ 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)
         }
         catch (error) {
             // console.error('Error initializing EthereumStakingClient:', error);
@@ -91,26 +95,51 @@ export class EthereumStakingClient implements IStakingClient {
     async withdraw(amount: bigint): Promise<string> {
         this.ensureUser();
 
-        const address = await this.signer!.getAddress();
+        const address = await this.address!;
         const amountWei = BigNumber.from(amount);
 
         const result = await this.convertClient.performWithdraw(address, amountWei)
         return result.txHash;
     }
 
+    /**
+     * List withdrawal queue receipts for a wallet (pending / in-progress exits after safeBurn).
+     * @param address  Owner to query; defaults to the connected wallet.
+     * @returns Withdrawal receipt NFT entries from the protocol view
+     */
+    async getPendingWithdraws(address?: string): Promise<WithdrawReceipt[]> {
+        this.ensureUser();
+        const owner = address ?? await this.address!;
+        return await this.receiptClient.fetchWithdrawReceipts(owner);
+    }
+
+    /**
+     * Claim native ETH for a matured withdrawal using the WithdrawalQueue NFT token id
+     * (via DepositManager.claim after the delay has passed).
+     * @param tokenId  Withdrawal request / queue NFT token id
+     * @returns transaction hash
+     */
+    async claimWithdraw(tokenId: bigint): Promise<string> {
+        this.ensureUser();
+
+        const tokenIdBigNum = BigNumber.from(tokenId)
+        const result = await this.convertClient.claimWithdraw(tokenIdBigNum)
+        return result.txHash;
+    }
+
 
     /**
      * Stake liqETH via DepositManager.
      * @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.signer!.getAddress();
+        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;
     }
 
@@ -120,6 +149,57 @@ export class EthereumStakingClient implements IStakingClient {
         throw new Error("Method not yet implemented.");
     }
 
+    /**
+     * Deposit ETH to liqETH, then stake the liqETH.
+     * @param amountWei  Amount in wei.
+     * @returns transaction hash
+     */
+    async depositAndStake(amount: bigint, wireAccount?: string): Promise<string> {
+        this.ensureUser();
+        if (!amount || amount <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+
+        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;
+    }
+
+    /**
+     * Deposit ETH to liqETH, then purchase pretokens in a single transaction.
+     * @param amountWei  Amount in wei.
+     * @returns transaction hash
+     */
+    async depositAndBuy(amountWei: bigint): Promise<string> {
+        this.ensureUser();
+        if (!amountWei || amountWei <= BigInt(0))
+            throw new Error('Amount must be greater than zero.');
+
+        const result = await this.stakeClient.performDepositAndPurchase(BigNumber.from(amountWei));
+        return result.txHash;
+    }
+
+    /**
+     * Unstake liqETH, then request a withdrawal in a single transaction.
+     * @param tokenId  The ReceiptNFT token ID for the stake position
+     * @returns transaction hash
+     */
+    async unstakeAndWithdraw(tokenId: bigint): Promise<string> {
+        this.ensureUser();
+
+        const result = await this.stakeClient.performUnstakeAndRequestWithdraw(BigNumber.from(tokenId));
+        return result.txHash;
+    }
+
 
     /**
      * ETH Prelaunch function to unstake liqEth
@@ -139,16 +219,55 @@ export class EthereumStakingClient implements IStakingClient {
     async buy(amount: bigint): Promise<string> {
         this.ensureUser();
 
-        const buyer = await this.signer!.getAddress();
-
-        // ! Hoodi only - check if the mock aggregator price is stale, and if so, update it before submitting the buy request
-        await this.updateMockAggregatorPrice();
+        const buyer = await this.address!;
 
         let result = await this.pretokenClient.purchasePretokensWithLiqETH(amount, buyer);
         return result && result.txHash ? result.txHash : "Error - no resulting txHash";
     }
 
 
+    /**
+     * Validator functions
+     */
+    async validatorDeposit(): Promise<string> {
+        this.ensureUser();
+
+        let result = await this.validatorClient.validatorDepositAndLockBond();
+        return result && result.txHash ? result.txHash : "Error - no resulting txHash";
+    }
+    
+
+
+
+
+    // ! 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.
      *
@@ -156,101 +275,107 @@ export class EthereumStakingClient implements IStakingClient {
      * actual  = liqETH token balance (ERC-20)
      * tracked = liqETH tracked balance (protocol/accounting view)
      */
-    async getPortfolio(): Promise<Portfolio | null> {
-        if (!this.signer) return Promise.resolve(null);
+    async getPortfolio(address?: string): Promise<Portfolio | null> {
 
-        const walletAddress = await this.signer!.getAddress();
+        try {
+            if (!this.signer) return Promise.resolve(null);
 
-        // 1) Native ETH balance
-        const nativeBalance = await this.provider.getBalance(walletAddress);
-        const nativeDecimals = this.network?.nativeCurrency?.decimals ?? 18;
-        const nativeSymbol = this.network?.nativeCurrency?.symbol ?? 'ETH';
+            const walletAddress = address ?? await this.address!;
 
-        // 2) liqETH ERC-20 balance (actual)
-        const liqBalance: ethers.BigNumber = await this.contract.LiqEthToken.balanceOf(walletAddress);
-        const liqSymbol = 'Liq' + (this.network?.nativeCurrency?.symbol ?? 'ETH');
+            // 1) Native ETH balance
+            const nativeBalance = await this.provider.getBalance(walletAddress);
+            const nativeDecimals = this.network?.nativeCurrency?.decimals ?? 18;
+            const nativeSymbol = this.network?.nativeCurrency?.symbol ?? 'ETH';
 
-        // 3) staked liqEth ERC-20 balance (calculate from receipts)
-        let stakeReceipts = await this.receiptClient.stakeReceipts(walletAddress);
-        let stakeBalanceBN = BigNumber.from(0);
-        for (let r of stakeReceipts) {
-            stakeBalanceBN = stakeBalanceBN.add(BigNumber.from(r.receipt.principal.amount));
-        }
-        let stakeSharesBN = BigNumber.from(0);
-        for (let r of stakeReceipts) {
-            stakeSharesBN = stakeSharesBN.add(BigNumber.from(r.receipt.shares.amount));
-        }
+            // 2) liqETH ERC-20 balance (actual)
+            const liqBalance: ethers.BigNumber = await this.contract.LiqEthToken.balanceOf(walletAddress);
+            const liqSymbol = 'Liq' + (this.network?.nativeCurrency?.symbol ?? 'ETH');
 
-        // 4) WIRE pretoken balance
-        const wireBalance: ethers.BigNumber = await this.contract.Pretoken.balanceOf(walletAddress);
+            // 3) staked liqEth ERC-20 balance (calculate from receipts)
+            let stakeReceipts = await this.receiptClient.stakeReceipts(walletAddress);
 
+            let stakeBalanceBN = BigNumber.from(0);
+            for (let r of stakeReceipts) {
+                stakeBalanceBN = stakeBalanceBN.add(BigNumber.from(r.receipt.principal.amount));
+            }
+            let stakeSharesBN = BigNumber.from(0);
+            for (let r of stakeReceipts) {
+                stakeSharesBN = stakeSharesBN.add(BigNumber.from(r.receipt.shares.amount));
+            }
 
-        // 5) Calculate staking yield 
-        let currentIndex = BigInt(0);
-        let totalShares = BigInt(0);
-        let userShares = BigInt(0);
-        const indexScale = BigInt(1e27);
-        try {
-            // These may throw if not implemented on contract
-            const [indexBn, totalSharesBn] = await Promise.all([
-                this.contract.Depositor.index().catch(() => BigNumber.from(0)),
-                this.contract.Depositor.totalShares().catch(() => BigNumber.from(0)),
-            ]);
+            // 4) WIRE pretoken balance
+            const wireBalance: ethers.BigNumber = await this.contract.Pretoken.balanceOf(walletAddress);
 
-            const userSharesBn = stakeSharesBN;
-            currentIndex = BigInt(indexBn.toString());
-            totalShares = BigInt(totalSharesBn.toString());
-            userShares = BigInt(userSharesBn.toString());
-        } catch { }
-
-        // sharesToTokens(userShares, currentIndex) = userShares * currentIndex / indexScale
-        let estimatedClaim = BigInt(0);
-        let estimatedYield = BigInt(0);
-
-        // started work on estimating the user's personal APY - not necessary at the moment
-        // let estimatedAPY: number | null = null;
-        // if (userShares > BigInt(0) && currentIndex > BigInt(0)) {
-        //     estimatedClaim = (userShares * currentIndex) / indexScale;
-        //     if (estimatedClaim > stakeBalanceBN.toBigInt()) {
-        //         estimatedYield = estimatedClaim - stakeBalanceBN.toBigInt();
-        //     }
-
-        //     estimatedAPY = null;
-        // }
-
-        const portfolio: Portfolio = {
-            native: {
-                amount: nativeBalance.toBigInt(),
-                decimals: nativeDecimals,
-                symbol: nativeSymbol,
-            },
-            liq: {
-                amount: liqBalance.toBigInt(),
-                decimals: nativeDecimals,
-                symbol: liqSymbol,
-            },
-            staked: {
-                amount: stakeBalanceBN.toBigInt(),
-                decimals: nativeDecimals,
-                symbol: liqSymbol,
-            },
-            wire: {
-                amount: wireBalance.toBigInt(),
-                decimals: 18,
-                symbol: '$WIRE',
-            },
-
-            yield: {
-                currentIndex,
-                indexScale,
-                totalShares,
-                userShares,
-                estimatedClaim,
-                estimatedYield,
-            },
-            chainID: this.network.chainId
+            // 5) Calculate staking yield 
+            let currentIndex = BigInt(0);
+            let totalShares = BigInt(0);
+            let userShares = BigInt(0);
+            const indexScale = BigInt(1e27);
+            try {
+                // These may throw if not implemented on contract
+                const [indexBn, totalSharesBn] = await Promise.all([
+                    this.contract.Depositor.index().catch(() => BigNumber.from(0)),
+                    this.contract.Depositor.totalShares().catch(() => BigNumber.from(0)),
+                ]);
+
+                const userSharesBn = stakeSharesBN;
+                currentIndex = BigInt(indexBn.toString());
+                totalShares = BigInt(totalSharesBn.toString());
+                userShares = BigInt(userSharesBn.toString());
+            } catch (error) {
+                console.log('Error fetching staking index/shares:', error);
+            }
+
+            // sharesToTokens(userShares, currentIndex) = userShares * currentIndex / indexScale
+            let estimatedClaim = BigInt(0);
+            let estimatedYield = BigInt(0);
+            
+            if (userShares > BigInt(0) && currentIndex > BigInt(0)) {
+                estimatedClaim = (userShares * currentIndex) / indexScale;
+                if (estimatedClaim > stakeBalanceBN.toBigInt()) {
+                    estimatedYield = estimatedClaim - stakeBalanceBN.toBigInt();
+                }
+            }
+
+
+            const portfolio: Portfolio = {
+                native: {
+                    amount: nativeBalance.toBigInt(),
+                    decimals: nativeDecimals,
+                    symbol: nativeSymbol,
+                },
+                liq: {
+                    amount: liqBalance.toBigInt(),
+                    decimals: nativeDecimals,
+                    symbol: liqSymbol,
+                },
+                staked: {
+                    amount: stakeBalanceBN.toBigInt(),
+                    decimals: nativeDecimals,
+                    symbol: liqSymbol,
+                },
+                wire: {
+                    amount: wireBalance.toBigInt(),
+                    decimals: 18,
+                    symbol: '$WIRE',
+                },
+
+                yield: {
+                    currentIndex,
+                    indexScale,
+                    totalShares,
+                    userShares,
+                    estimatedClaim,
+                    estimatedYield,
+                },
+                chainID: this.network.chainId
+            }
+            return portfolio;
+        }
+        catch (error) {
+            // console.log('Error fetching Ethereum portfolio:', error);
+            throw error;
         }
-        return portfolio;
     }
 
     /**
@@ -261,7 +386,7 @@ export class EthereumStakingClient implements IStakingClient {
     async fetchPrelaunchReceipts(address?: string): Promise<preLaunchReceipt[]> {
         this.ensureUser();
 
-        if (address === undefined) address = await this.signer!.getAddress();
+        if (address === undefined) address = await this.address!;
 
         //default to stake receipts
         return await this.receiptClient.stakeReceipts(address);
@@ -270,11 +395,13 @@ export class EthereumStakingClient implements IStakingClient {
     async getOPPMessages(address?: string): Promise<OPPAssertion[]> {
         this.ensureUser();
 
-        if (!address) address = await this.signer!.getAddress();
+        if (!address) address = await this.address!;
 
         return await this.oppClient.getMessages(address);
     }
 
+
+
     // Ensure that signer wallet is available for write operations
     private ensureUser() {
         if (!this.signer) {
@@ -330,26 +457,13 @@ export class EthereumStakingClient implements IStakingClient {
      * 
      * SUPPORTS READ-ONLY ACcESS
      */
-    async getTrancheSnapshot(options?: {
-        chainID?: ChainID;
-        windowBefore?: number;
-        windowAfter?: number;
-    }): Promise<TrancheSnapshot> {
-        const {
-            chainID = EvmChainID.Hoodi,
-            windowBefore,
-            windowAfter,
-        } = options ?? {};
-
-
+    async getTrancheSnapshot(chainID: ChainID): Promise<TrancheSnapshot> {
         try {
-
             const blockNumber = await this.provider.getBlockNumber();
             const blockTag = { blockTag: blockNumber };
 
-
             // Fetch all required contract data
-            const [totalSharesBn, indexBn, trancheNumberBn, trancheSupplyBn, tranchePriceWadBn, totalSupplyBn, supplyGrowthBps, priceGrowthCents, minPriceUsd, maxPriceUsd] = await Promise.all([
+            const [totalSharesBn, indexBn, trancheNumberBn, trancheSupplyBn, tranchePriceUsdBn, totalSupplyBn, supplyGrowthBps, priceGrowthCents, minPriceUsd, maxPriceUsd] = await Promise.all([
                 this.contract.Depositor.totalShares(blockTag),
                 this.contract.Depositor.index(blockTag),
                 this.contract.Pretoken.trancheNumber(blockTag),
@@ -362,15 +476,18 @@ export class EthereumStakingClient implements IStakingClient {
                 this.contract.EthUsdPriceConsumer.MAX_PRICE(),
             ]);
 
-
             const totalTrancheSupply = BigInt(totalSupplyBn.toString()) / BigInt(1e10);
             const currentTrancheSupply = BigInt(trancheSupplyBn.toString()) / BigInt(1e10);
 
-
             // fetch price and timestamp from aggregator
-            const [roundId, answer, startedAt, updatedAt, answeredInRound] = await this.contract.MockAggregator.latestRoundData();
-            let ethPriceUsd: bigint = BigInt(answer.toString());
-            let nativePriceTimestamp: number = Number(updatedAt);
+            // const [roundId, answer, startedAt, updatedAt, answeredInRound] = await this.contract.MockAggregator.latestRoundData();
+            //originally fetched ethPrice from aggregator - pulling from EthUsdPriceConsumer instead - this is where the actual price gets pulled from when purchasing pretokens.
+            // let ethPriceUsd: bigint = BigInt(answer.toString());)
+
+            let ethPriceUsdBn = await this.contract.EthUsdPriceConsumer.getPrice18Decimals();
+            let ethPriceUsd: bigint = BigInt(ethPriceUsdBn.toString()) / BigInt(1e10);
+
+            // let nativePriceTimestamp: number = Number(updatedAt);
 
             const initialTrancheSupply = BigInt(INITIAL_TRANCHE_SUPPLY) * BigInt(1e8);
 
@@ -380,23 +497,17 @@ export class EthereumStakingClient implements IStakingClient {
                 indexBn,
                 trancheNumberBn,
                 currentTrancheSupply,
-                tranchePriceWadBn,
+                tranchePriceUsdBn,
                 totalTrancheSupply,
                 initialTrancheSupply,
                 supplyGrowthBps,
                 priceGrowthCents,
                 minPriceUsd,
                 maxPriceUsd,
-
                 ethPriceUsd,
-                nativePriceTimestamp,
-                ladderWindowBefore: windowBefore,
-                ladderWindowAfter: windowAfter,
             });
         }
         catch (err: any) {
-            console.log(err);
-
             throw new Error(`Error fetching Ethereum tranche snapshot: ${err?.message || err}`);
         }
     }
@@ -413,14 +524,15 @@ export class EthereumStakingClient implements IStakingClient {
      * @param options.safetyMultiplier Additional safety multiplier on top of txCount (default 1.5x)
      * @param options.minBufferWei    Optional override minimum buffer (defaults ~0.002 ETH)
      */
-    async estimateGasBuffer(options?: {
+    async getDepositBuffer(options?: {
         txCount?: number;
         safetyMultiplier?: number;
         minBufferWei?: bigint;
+        balanceOverrideLamports?: bigint;
     }): Promise<bigint> {
         this.ensureUser();
 
-        const walletAddress = await this.signer!.getAddress();
+        const walletAddress = await this.address!;
 
         // 1) Estimate a baseline gas usage using a simple self-transfer.
         //    This is cheap and doesn't depend on your contract ABI at all.
@@ -475,7 +587,8 @@ 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
+    // ! This is a temporary measure for testnet because there is no aggregator deployed
+    /*
     private async updateMockAggregatorPrice() {
         const aggregator = this.contract.MockAggregator;
 
@@ -487,10 +600,12 @@ export class EthereumStakingClient implements IStakingClient {
         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([560048]);
+            const allowedTestChains = new Set([560048, 31337]);
             if (!allowedTestChains.has(chainId)) {
                 console.warn(`MockAggregator is stale (${ageSec}s) but chainId ${chainId} is not a test/local network — skipping update.`);
                 return;
@@ -504,6 +619,8 @@ export class EthereumStakingClient implements IStakingClient {
 
             const currentEthPrice = ethers.utils.parseUnits(ethUsd.toString(), 8);
 
+            console.log('currentEthPrice', currentEthPrice.toString())
+
             try {
                 //update to be intentionally stale
                 // const alttx = await aggregator.updateStale(currentEthPrice, now - 7200);
@@ -513,7 +630,8 @@ export class EthereumStakingClient implements IStakingClient {
                 //update answer with current timestamp
                 const tx = await aggregator.updateAnswer(currentEthPrice);
                 const txreceipt = await tx.wait(1);
-                // console.log('MockAggregator answer updated - receipt:', txreceipt)
+                console.log('MockAggregator answer updated - receipt:', txreceipt)
+                return txreceipt
             } catch (err: any) {
                 console.error('MockAggregator updateAnswer failed', err?.message || err);
             }
@@ -521,4 +639,98 @@ export class EthereumStakingClient implements IStakingClient {
             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>([560048n, 31337n]);
+        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);
+        }
+    }
+    */
+}