@aztec/bot 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/dest/factory.js

@@ -1,5 +1,5 @@
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { NO_FROM } from '@aztec/aztec.js/account';
+import { deriveSecretKeyFromSigningKey } from '@aztec/accounts/utils';
 import { BatchCall, NO_WAIT } from '@aztec/aztec.js/contracts';
 import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
@@ -8,40 +8,41 @@ import { createLogger } from '@aztec/aztec.js/log';
 import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
 import { waitForTx } from '@aztec/aztec.js/node';
 import { getFeeJuiceBalance } from '@aztec/aztec.js/utils';
-import { ContractInitializationStatus } from '@aztec/aztec.js/wallet';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Timer } from '@aztec/foundation/timer';
 import { AMMContract } from '@aztec/noir-contracts.js/AMM';
 import { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TestContract } from '@aztec/noir-test-contracts.js/Test';
-import { GasFees, GasSettings, ManaUsageEstimate } from '@aztec/stdlib/gas';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
 import { SupportedTokenContracts } from './config.js';
 import { seedL1ToL2Message } from './l1_to_l2_seeding.js';
 import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
 const MINT_BALANCE = 1e12;
 const MIN_BALANCE = 1e3;
 const FEE_JUICE_TOP_UP_THRESHOLD = 100n * 10n ** 18n;
-const FEE_JUICE_TOP_UP_TARGET = 10_000n * 10n ** 18n;
 export class BotFactory {
     config;
     wallet;
     store;
     aztecNode;
     aztecNodeAdmin;
+    syncChainTip;
     log;
-    constructor(config, wallet, store, aztecNode, aztecNodeAdmin){
+    /** Number of in-flight withNoMinTxsPerBlock calls; see that method for why they are counted. */ noMinTxsPerBlockDepth;
+    /** Set by the first withNoMinTxsPerBlock entrant; resolves to the minTxsPerBlock value to restore. */ savedMinTxsPerBlock;
+    constructor(config, wallet, store, aztecNode, aztecNodeAdmin, syncChainTip){
         this.config = config;
         this.wallet = wallet;
         this.store = store;
         this.aztecNode = aztecNode;
         this.aztecNodeAdmin = aztecNodeAdmin;
+        this.syncChainTip = syncChainTip;
         this.log = createLogger('bot');
+        this.noMinTxsPerBlockDepth = 0;
         // Set fee padding on the wallet so that all transactions during setup
         // (token deploy, minting, etc.) use the configured padding, not the default.
         this.wallet.setMinFeePadding(config.minFeePadding);
@@ -51,9 +52,9 @@ export class BotFactory {
    * deploying the token contract, and minting tokens if necessary.
    */ async setup() {
         const defaultAccountAddress = await this.setupAccount();
-        const recipient = (await this.wallet.createSchnorrAccount(Fr.random(), Fr.random())).address;
-        const token = await this.setupTokenWithOptionalEarlyRefuel(defaultAccountAddress);
-        await this.ensureFeeJuiceBalance(defaultAccountAddress, token);
+        const recipient = (await this.wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random())).address;
+        await this.ensureFeeJuiceBalance(defaultAccountAddress);
+        const token = await this.setupToken(defaultAccountAddress);
         await this.mintTokens(token, defaultAccountAddress);
         return {
             wallet: this.wallet,
@@ -65,12 +66,31 @@ export class BotFactory {
     }
     async setupAmm() {
         const defaultAccountAddress = await this.setupAccount();
-        const token0 = await this.setupTokenContractWithOptionalEarlyRefuel(defaultAccountAddress, this.config.tokenSalt, 'BotToken0', 'BOT0');
-        await this.ensureFeeJuiceBalance(defaultAccountAddress, token0);
-        const token1 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken1', 'BOT1');
-        const liquidityToken = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotLPToken', 'BOTLP');
-        const amm = await this.setupAmmContract(defaultAccountAddress, this.config.tokenSalt, token0, token1, liquidityToken);
-        await this.fundAmm(defaultAccountAddress, defaultAccountAddress, amm, token0, token1, liquidityToken);
+        await this.ensureFeeJuiceBalance(defaultAccountAddress);
+        const salt = this.config.tokenSalt;
+        // token0, token1 and the LP token are independent contracts with no shared state, so deploy them
+        // concurrently rather than one slot at a time.
+        const [token0, token1, liquidityToken] = await Promise.all([
+            this.setupTokenContract(defaultAccountAddress, salt, 'BotToken0', 'BOT0'),
+            this.setupTokenContract(defaultAccountAddress, salt, 'BotToken1', 'BOT1'),
+            this.setupTokenContract(defaultAccountAddress, salt, 'BotLPToken', 'BOTLP')
+        ]);
+        const ammDeploy = AMMContract.deploy(this.wallet, token0.address, token1.address, liquidityToken.address, {
+            salt,
+            universalDeploy: true
+        });
+        const ammAddress = (await ammDeploy.getInstance()).address;
+        // The AMM constructor only stores the (already-derived) token addresses, and set_minter only records
+        // the AMM address on the LP token: neither reads the other's on-chain state, so the AMM deploy, the
+        // LP-minter grant, and the token0/token1 mints are mutually independent and run concurrently.
+        const [amm] = await Promise.all([
+            this.deployAmmContract(defaultAccountAddress, ammDeploy),
+            this.grantLpTokenMinter(defaultAccountAddress, liquidityToken, ammAddress),
+            this.mintAmmLiquidity(defaultAccountAddress, token0, token1)
+        ]);
+        // add_liquidity spends the minted token0/token1 balances and mints LP tokens, so it must follow both
+        // the mints and the minter grant, and target the deployed AMM.
+        await this.addAmmLiquidity(defaultAccountAddress, defaultAccountAddress, amm, token0, token1, liquidityToken);
         this.log.info(`AMM initialized and funded`);
         return {
             wallet: this.wallet,
@@ -86,6 +106,7 @@ export class BotFactory {
    * seeding initial L1→L2 messages, and waiting for the first to be ready.
    */ async setupCrossChain() {
         const defaultAccountAddress = await this.setupAccount();
+        await this.ensureFeeJuiceBalance(defaultAccountAddress);
         // Create L1 client (same pattern as bridgeL1FeeJuice)
         const l1RpcUrls = this.config.l1RpcUrls;
         if (!l1RpcUrls?.length) {
@@ -101,23 +122,38 @@ export class BotFactory {
         // Fetch Rollup version (needed for Inbox L2Actor struct)
         const rollupContract = new RollupContract(l1Client, l1ContractAddresses.rollupAddress.toString());
         const rollupVersion = await rollupContract.getVersion();
-        // Deploy TestContract
-        const contract = await this.setupTestContract(defaultAccountAddress);
+        // Derive the TestContract address up front (deterministic from the salt). Seeding L1→L2 messages only
+        // needs the L2 recipient address — the messages are queued on L1 and don't require the L2 contract to
+        // exist yet (they're consumed later, after setup completes) — so the deploy (an L2 tx paying from the
+        // standing balance funded above) and the L1 seeding run concurrently.
+        const testContractDeploy = TestContract.deploy(this.wallet, {
+            salt: this.config.tokenSalt,
+            universalDeploy: true
+        });
+        const contractAddress = (await testContractDeploy.getInstance()).address;
         // Recover any pending messages from store (clean up stale ones first)
         await this.store.cleanupOldPendingMessages();
         const pendingMessages = await this.store.getUnconsumedL1ToL2Messages();
-        // Seed initial L1→L2 messages if pipeline is empty
+        // Seed initial L1→L2 messages if pipeline is empty. The seeds are sent one at a time: they share the
+        // bot's L1 account, so concurrent sends would race on the L1 nonce.
         const seedCount = Math.max(0, this.config.l1ToL2SeedCount - pendingMessages.length);
-        for(let i = 0; i < seedCount; i++){
-            await seedL1ToL2Message(l1Client, EthAddress.fromString(l1ContractAddresses.inboxAddress.toString()), contract.address, rollupVersion, this.store, this.log);
-        }
+        const inboxAddress = EthAddress.fromString(l1ContractAddresses.inboxAddress.toString());
+        const [contract] = await Promise.all([
+            this.deployTestContract(defaultAccountAddress, testContractDeploy),
+            (async ()=>{
+                for(let i = 0; i < seedCount; i++){
+                    await seedL1ToL2Message(l1Client, inboxAddress, contractAddress, rollupVersion, this.store, this.log);
+                }
+            })()
+        ]);
         // Block until at least one message is ready
         const allMessages = await this.store.getUnconsumedL1ToL2Messages();
         if (allMessages.length > 0) {
             this.log.info(`Waiting for first L1→L2 message to be ready...`);
             const firstMsg = allMessages[0];
             await waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(firstMsg.msgHash), {
-                timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds
+                timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+                chainTip: this.syncChainTip
             });
             this.log.info(`First L1→L2 message is ready`);
         }
@@ -130,15 +166,10 @@ export class BotFactory {
             rollupVersion
         };
     }
-    async setupTestContract(deployer) {
-        const deployOpts = {
+    async deployTestContract(deployer, deploy) {
+        const instance = await this.registerOrDeployContract('TestContract', deploy, {
             from: deployer
-        };
-        const deploy = TestContract.deploy(this.wallet, {
-            salt: this.config.tokenSalt,
-            universalDeploy: true
         });
-        const instance = await this.registerOrDeployContract('TestContract', deploy, deployOpts);
         return TestContract.at(instance.address, this.wallet);
     }
     /**
@@ -154,100 +185,23 @@ export class BotFactory {
             return await this.setupTestAccount();
         }
     }
-    async setupAccountWithPrivateKey(secret) {
-        const salt = this.config.senderSalt ?? Fr.ONE;
-        const signingKey = deriveSigningKey(secret);
-        const accountManager = await this.wallet.createSchnorrAccount(secret, salt, signingKey);
-        const metadata = await this.wallet.getContractMetadata(accountManager.address);
-        if (metadata.initializationStatus === ContractInitializationStatus.INITIALIZED) {
-            this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
-            const timer = new Timer();
-            const address = accountManager.address;
-            this.log.info(`Account at ${address} registered. duration=${timer.ms()}`);
-            await this.store.deleteBridgeClaim(address);
-            return address;
-        } else {
-            const address = accountManager.address;
-            this.log.info(`Deploying account at ${address}`);
-            const claim = await this.getOrCreateBridgeClaim(address);
-            const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
-            const deployMethod = await accountManager.getDeployMethod();
-            await this.withNoMinTxsPerBlock(async ()=>{
-                const { txHash } = await deployMethod.send({
-                    from: NO_FROM,
-                    fee: {
-                        paymentMethod
-                    },
-                    wait: NO_WAIT
-                });
-                this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
-                return waitForTx(this.aztecNode, txHash, {
-                    timeout: this.config.txMinedWaitSeconds
-                });
-            });
-            this.log.info(`Account deployed at ${address}`);
-            // Clean up the consumed bridge claim
-            await this.store.deleteBridgeClaim(address);
-            return accountManager.address;
-        }
-    }
-    async setupTestAccount() {
+    /**
+   * Keyless fallback for tests and local dev: reuses the first genesis test account, whose address is
+   * pre-funded with fee juice via `initialFundedAccounts`. The test accounts are initializerless, so this
+   * must create an initializerless account for the address to match the funded one. Production bots set a
+   * sender private key and fund the resulting initializerless account from L1 instead; see
+   * setupAccountWithPrivateKey.
+   */ async setupTestAccount() {
         const [initialAccountData] = await getInitialTestAccountsData();
-        const accountManager = await this.wallet.createSchnorrAccount(initialAccountData.secret, initialAccountData.salt, initialAccountData.signingKey);
+        const accountManager = await this.wallet.createSchnorrInitializerlessAccount(initialAccountData.secret, initialAccountData.salt, initialAccountData.signingKey);
         return accountManager.address;
     }
-    /**
-   * Setup token and refuel first: if the token already exists (restart scenario),
-   * run ensureFeeJuiceBalance before any step that might need fee juice. When deploying,
-   * use a bridge claim if balance is below threshold.
-   */ async setupTokenWithOptionalEarlyRefuel(sender) {
-        const token = await this.getTokenInstance(sender);
-        const address = token.address;
-        const metadata = await this.wallet.getContractMetadata(address);
-        if (metadata.isContractPublished) {
-            this.log.info(`Token at ${address.toString()} already deployed, refueling before setup`);
-            await this.ensureFeeJuiceBalance(sender, token);
-        }
-        return this.setupToken(sender);
-    }
-    /**
-   * Setup token0 for AMM with refuel-first behaviour when token already exists.
-   */ async setupTokenContractWithOptionalEarlyRefuel(deployer, salt, name, ticker, decimals = 18) {
-        const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals, {
-            salt,
-            universalDeploy: true
-        });
-        const instance = await deploy.getInstance();
-        const metadata = await this.wallet.getContractMetadata(instance.address);
-        if (metadata.isContractPublished) {
-            this.log.info(`Token ${name} at ${instance.address.toString()} already deployed, refueling before setup`);
-            const token = TokenContract.at(instance.address, this.wallet);
-            await this.ensureFeeJuiceBalance(deployer, token);
-        }
-        return this.setupTokenContract(deployer, salt, name, ticker, decimals);
-    }
-    async getTokenInstance(sender) {
-        const salt = this.config.tokenSalt;
-        if (this.config.contract === SupportedTokenContracts.TokenContract) {
-            const deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18, {
-                salt,
-                universalDeploy: true
-            });
-            const instance = await deploy.getInstance();
-            return TokenContract.at(instance.address, this.wallet);
-        }
-        if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
-            const tokenSecretKey = Fr.random();
-            const tokenPublicKeys = (await deriveKeys(tokenSecretKey)).publicKeys;
-            const deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender, {
-                salt,
-                universalDeploy: true,
-                publicKeys: tokenPublicKeys
-            });
-            const instance = await deploy.getInstance();
-            return PrivateTokenContract.at(instance.address, this.wallet);
-        }
-        throw new Error(`Unsupported token contract type: ${this.config.contract}`);
+    async setupAccountWithPrivateKey(privateKey) {
+        const salt = this.config.senderSalt ?? Fr.ONE;
+        const signingKey = GrumpkinScalar.fromBuffer(privateKey.toBuffer());
+        const secret = await deriveSecretKeyFromSigningKey(signingKey);
+        const accountManager = await this.wallet.createSchnorrInitializerlessAccount(secret, salt, signingKey);
+        return accountManager.address;
     }
     /**
    * Checks if the token contract is deployed and deploys it if necessary.
@@ -310,48 +264,45 @@ export class BotFactory {
         const instance = await this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
         return TokenContract.at(instance.address, this.wallet);
     }
-    async setupAmmContract(deployer, salt, token0, token1, lpToken) {
-        const deployOpts = {
+    async deployAmmContract(deployer, deploy) {
+        const instance = await this.registerOrDeployContract('AMM', deploy, {
             from: deployer
-        };
-        const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address, {
-            salt,
-            universalDeploy: true
         });
-        const instance = await this.registerOrDeployContract('AMM', deploy, deployOpts);
         const amm = AMMContract.at(instance.address, this.wallet);
         this.log.info(`AMM deployed at ${amm.address}`);
-        const setMinterInteraction = lpToken.methods.set_minter(amm.address, true);
-        const { receipt: minterReceipt } = await setMinterInteraction.send({
+        return amm;
+    }
+    /** Grants the AMM minting rights over the LP token. set_minter only records the address, so it does not
+   * require the AMM contract to be deployed first. */ async grantLpTokenMinter(deployer, lpToken, amm) {
+        const { receipt } = await lpToken.methods.set_minter(amm, true).send({
             from: deployer,
             wait: {
                 timeout: this.config.txMinedWaitSeconds
             }
         });
-        this.log.info(`Set LP token minter to AMM txHash=${minterReceipt.txHash.toString()}`);
-        this.log.info(`Liquidity token initialized`);
-        return amm;
+        this.log.info(`Set LP token minter to AMM txHash=${receipt.txHash.toString()}`);
     }
-    async fundAmm(defaultAccountAddress, liquidityProvider, amm, token0, token1, lpToken) {
-        const getPrivateBalances = ()=>Promise.all([
-                token0.methods.balance_of_private(liquidityProvider).simulate({
-                    from: liquidityProvider
-                }).then((r)=>r.result),
-                token1.methods.balance_of_private(liquidityProvider).simulate({
-                    from: liquidityProvider
-                }).then((r)=>r.result),
-                lpToken.methods.balance_of_private(liquidityProvider).simulate({
-                    from: liquidityProvider
-                }).then((r)=>r.result)
-            ]);
+    async mintAmmLiquidity(minter, token0, token1) {
+        this.log.info(`Minting ${MINT_BALANCE} tokens of each BotToken0 and BotToken1 for ${minter}`);
+        const mintBatch = new BatchCall(this.wallet, [
+            token0.methods.mint_to_private(minter, MINT_BALANCE),
+            token1.methods.mint_to_private(minter, MINT_BALANCE)
+        ]);
+        const { receipt } = await mintBatch.send({
+            from: minter,
+            wait: {
+                timeout: this.config.txMinedWaitSeconds
+            }
+        });
+        this.log.info(`Sent mint tx: ${receipt.txHash.toString()}`);
+    }
+    async addAmmLiquidity(defaultAccountAddress, liquidityProvider, amm, token0, token1, lpToken) {
         const authwitNonce = Fr.random();
         // keep some tokens for swapping
         const amount0Max = MINT_BALANCE / 2;
         const amount0Min = MINT_BALANCE / 4;
         const amount1Max = MINT_BALANCE / 2;
         const amount1Min = MINT_BALANCE / 4;
-        const [t0Bal, t1Bal, lpBal] = await getPrivateBalances();
-        this.log.info(`Minting ${MINT_BALANCE} tokens of each BotToken0 and BotToken1. Current private balances of ${liquidityProvider}: token0=${t0Bal}, token1=${t1Bal}, lp=${lpBal}`);
         // Add authwitnesses for the transfers in AMM::add_liquidity function
         const token0Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
             caller: amm.address,
@@ -361,19 +312,7 @@ export class BotFactory {
             caller: amm.address,
             call: await token1.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount1Max, authwitNonce).getFunctionCall()
         });
-        const mintBatch = new BatchCall(this.wallet, [
-            token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
-            token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE)
-        ]);
-        const { receipt: mintReceipt } = await mintBatch.send({
-            from: liquidityProvider,
-            wait: {
-                timeout: this.config.txMinedWaitSeconds
-            }
-        });
-        this.log.info(`Sent mint tx: ${mintReceipt.txHash.toString()}`);
-        const addLiquidityInteraction = amm.methods.add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce);
-        const { receipt: addLiquidityReceipt } = await addLiquidityInteraction.send({
+        const { receipt } = await amm.methods.add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce).send({
             from: liquidityProvider,
             authWitnesses: [
                 token0Authwit,
@@ -383,10 +322,20 @@ export class BotFactory {
                 timeout: this.config.txMinedWaitSeconds
             }
         });
-        this.log.info(`Sent tx to add liquidity to the AMM: ${addLiquidityReceipt.txHash.toString()}`);
+        this.log.info(`Sent tx to add liquidity to the AMM: ${receipt.txHash.toString()}`);
         this.log.info(`Liquidity added`);
-        const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
-        this.log.info(`Updated private balances of ${defaultAccountAddress} after minting and funding AMM: token0=${newT0Bal}, token1=${newT1Bal}, lp=${newLPBal}`);
+        const [t0Bal, t1Bal, lpBal] = await Promise.all([
+            token0.methods.balance_of_private(liquidityProvider).simulate({
+                from: liquidityProvider
+            }).then((r)=>r.result),
+            token1.methods.balance_of_private(liquidityProvider).simulate({
+                from: liquidityProvider
+            }).then((r)=>r.result),
+            lpToken.methods.balance_of_private(liquidityProvider).simulate({
+                from: liquidityProvider
+            }).then((r)=>r.result)
+        ]);
+        this.log.info(`Updated private balances of ${defaultAccountAddress} after minting and funding AMM: token0=${t0Bal}, token1=${t1Bal}, lp=${lpBal}`);
     }
     async registerOrDeployContract(name, deploy, deployOpts) {
         const instance = await deploy.getInstance();
@@ -395,83 +344,38 @@ export class BotFactory {
         if (metadata.isContractPublished) {
             this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
             await deploy.register();
-        } else {
-            const sender = deployOpts.from === NO_FROM ? undefined : deployOpts.from;
-            const balance = sender ? await getFeeJuiceBalance(sender, this.aztecNode) : 0n;
-            const useClaim = sender && balance < FEE_JUICE_TOP_UP_THRESHOLD && this.config.feePaymentMethod === 'fee_juice' && !!this.config.l1RpcUrls?.length;
-            const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
-            if (useClaim && mnemonicOrPrivateKey) {
-                const claim = await this.getOrCreateBridgeClaim(sender);
-                const paymentMethod = new FeeJuicePaymentMethodWithClaim(sender, claim);
-                const { estimatedGas } = await deploy.simulate({
-                    ...deployOpts,
-                    fee: {
-                        estimateGas: true,
-                        paymentMethod
-                    }
-                });
-                const maxFeesPerGas = (await this.getMinFees()).mul(1 + this.config.minFeePadding);
-                const gasSettings = GasSettings.from({
-                    ...estimatedGas,
-                    maxFeesPerGas,
-                    maxPriorityFeesPerGas: GasFees.empty()
-                });
-                await this.withNoMinTxsPerBlock(async ()=>{
-                    const { txHash } = await deploy.send({
-                        ...deployOpts,
-                        fee: {
-                            gasSettings,
-                            paymentMethod
-                        },
-                        wait: NO_WAIT
-                    });
-                    this.log.info(`Sent contract ${name} deploy tx ${txHash.toString()} (using bridge claim, balance was ${balance})`);
-                    return waitForTx(this.aztecNode, txHash, {
-                        timeout: this.config.txMinedWaitSeconds
-                    });
-                });
-                await this.store.deleteBridgeClaim(sender);
-            } else {
-                const { estimatedGas } = await deploy.simulate({
-                    ...deployOpts,
-                    fee: {
-                        estimateGas: true
-                    }
-                });
-                this.log.info(`Deploying contract ${name} at ${address.toString()}`, {
-                    estimatedGas
-                });
-                await this.withNoMinTxsPerBlock(async ()=>{
-                    const { txHash } = await deploy.send({
-                        ...deployOpts,
-                        fee: {
-                            gasSettings: estimatedGas
-                        },
-                        wait: NO_WAIT
-                    });
-                    this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
-                    return waitForTx(this.aztecNode, txHash, {
-                        timeout: this.config.txMinedWaitSeconds
-                    });
-                });
-            }
+            return instance;
         }
+        // Setup always runs ensureFeeJuiceBalance before any deploy, so the account pays from its standing
+        // balance here. No manual gas estimation: the embedded wallet simulates before sending and derives
+        // the gas limits and padded maxFeesPerGas itself.
+        this.log.info(`Deploying contract ${name} at ${address.toString()}`);
+        await this.withNoMinTxsPerBlock(async ()=>{
+            const { txHash } = await deploy.send({
+                ...deployOpts,
+                wait: NO_WAIT
+            });
+            this.log.info(`Sent contract ${name} deploy tx ${txHash.toString()}`);
+            return waitForTx(this.aztecNode, txHash, {
+                timeout: this.config.txMinedWaitSeconds
+            });
+        });
         return instance;
     }
-    /**
-   * Mints private and public tokens for the sender if their balance is below the minimum.
-   * @param token - Token contract.
-   */ /**
-   * Ensures the account has sufficient fee juice by bridging from L1 if balance is below threshold.
-   * Bridges repeatedly until balance reaches the target (10k FJ).
-   * Used on startup/restart to top up when the account has run out after previous runs.
-   */ async ensureFeeJuiceBalance(account, token) {
-        const { feePaymentMethod, l1RpcUrls } = this.config;
-        if (feePaymentMethod !== 'fee_juice' || !l1RpcUrls?.length) {
-            return;
-        }
+    /** True when the config allows bridging fee juice from L1 (fee_juice mode, an L1 RPC, and an L1 key). */ isL1BridgingConfigured() {
         const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
-        if (!mnemonicOrPrivateKey) {
+        return this.config.feePaymentMethod === 'fee_juice' && !!this.config.l1RpcUrls?.length && !!mnemonicOrPrivateKey;
+    }
+    /**
+   * Ensures the account holds enough fee juice before any other setup step. The account starts empty
+   * (initializerless accounts have no deployment tx) and the runtime loop pays fees from this balance and
+   * never refuels itself, so every flow funds the account up front. Bridges claims from L1 and consumes
+   * each with a claim-only tx until the balance clears the threshold, working from a zero (fresh run) or
+   * drained (restart) balance. Each bridge mints a fixed amount well above the threshold, so this is a
+   * single bridge in practice. No-op when L1 bridging is not configured or the balance is already above
+   * the threshold.
+   */ async ensureFeeJuiceBalance(account) {
+        if (!this.isL1BridgingConfigured()) {
             return;
         }
         let balance = await getFeeJuiceBalance(account, this.aztecNode);
@@ -479,31 +383,16 @@ export class BotFactory {
             this.log.info(`Fee juice balance ${balance} above threshold ${FEE_JUICE_TOP_UP_THRESHOLD}, skipping top-up`);
             return;
         }
-        this.log.info(`Fee juice balance ${balance} below threshold ${FEE_JUICE_TOP_UP_THRESHOLD}, bridging from L1 until ${FEE_JUICE_TOP_UP_TARGET}`);
-        const maxFeesPerGas = (await this.getMinFees()).mul(1 + this.config.minFeePadding);
-        const minimalInteraction = isStandardTokenContract(token) ? token.methods.transfer_in_public(account, account, 0n, 0) : token.methods.transfer(0n, account, account);
-        while(balance < FEE_JUICE_TOP_UP_TARGET){
-            const claim = await this.bridgeL1FeeJuice(account);
+        this.log.info(`Fee juice balance ${balance} below threshold ${FEE_JUICE_TOP_UP_THRESHOLD}, bridging from L1`);
+        while(balance < FEE_JUICE_TOP_UP_THRESHOLD){
+            // Persist the claim before consuming it: if the top-up tx fails or the bot crashes mid-loop, the
+            // next run reuses the pending claim instead of bridging again (and wasting the bridged funds).
+            const claim = await this.getOrCreateBridgeClaim(account);
             const paymentMethod = new FeeJuicePaymentMethodWithClaim(account, claim);
-            const { estimatedGas } = await minimalInteraction.simulate({
-                from: account,
-                fee: {
-                    estimateGas: true,
-                    paymentMethod
-                }
-            });
-            const gasSettings = GasSettings.from({
-                ...estimatedGas,
-                maxFeesPerGas,
-                maxPriorityFeesPerGas: GasFees.empty()
-            });
             await this.withNoMinTxsPerBlock(async ()=>{
-                const { txHash } = await minimalInteraction.send({
+                const executionPayload = await paymentMethod.getExecutionPayload();
+                const { txHash } = await this.wallet.sendTx(executionPayload, {
                     from: account,
-                    fee: {
-                        gasSettings,
-                        paymentMethod
-                    },
                     wait: NO_WAIT
                 });
                 this.log.info(`Sent fee juice top-up tx ${txHash.toString()}`);
@@ -511,6 +400,7 @@ export class BotFactory {
                     timeout: this.config.txMinedWaitSeconds
                 });
             });
+            await this.store.deleteBridgeClaim(account);
             balance = await getFeeJuiceBalance(account, this.aztecNode);
             this.log.info(`Fee juice balance after top-up: ${balance}`);
         }
@@ -556,19 +446,18 @@ export class BotFactory {
         });
     }
     /**
-   * Gets or creates a bridge claim for the recipient.
-   * Checks if a claim already exists in the store and reuses it if valid.
-   * Only creates a new bridge if fee juice balance is below threshold.
+   * Returns a usable bridge claim for the recipient, reusing a persisted one when its L1→L2 message is
+   * still available (resuming a top-up that failed or crashed before the claim was consumed) and bridging
+   * a fresh claim otherwise. The caller deletes the claim from the store once it has been consumed.
    */ async getOrCreateBridgeClaim(recipient) {
-        // Check if we have an existing claim in the store
         const existingClaim = await this.store.getBridgeClaim(recipient);
         if (existingClaim) {
             this.log.info(`Found existing bridge claim for ${recipient.toString()}, checking validity...`);
-            // Check if the message is ready on L2
             try {
                 const messageHash = Fr.fromHexString(existingClaim.claim.messageHash);
                 await this.withNoMinTxsPerBlock(()=>waitForL1ToL2MessageReady(this.aztecNode, messageHash, {
-                        timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds
+                        timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+                        chainTip: this.syncChainTip
                     }));
                 return existingClaim.claim;
             } catch (err) {
@@ -596,39 +485,48 @@ export class BotFactory {
         const mintAmount = await portal.getTokenManager().getMintAmount();
         const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true);
         await this.withNoMinTxsPerBlock(()=>waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
-                timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds
+                timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+                chainTip: this.syncChainTip
             }));
         this.log.info(`Created a claim for ${mintAmount} L1 fee juice to ${recipient}.`, claim);
         return claim;
     }
-    /** Returns worst-case min fees across predicted slots, with fallback to current min fees. */ async getMinFees() {
-        try {
-            const predicted = await this.aztecNode.getPredictedMinFees(ManaUsageEstimate.Limit);
-            if (predicted.length === 0) {
-                return this.aztecNode.getCurrentMinFees();
-            }
-            return predicted.reduce((worst, fees)=>fees.feePerL2Gas > worst.feePerL2Gas ? fees : worst);
-        } catch  {
-            return this.aztecNode.getCurrentMinFees();
-        }
-    }
     async withNoMinTxsPerBlock(fn) {
         if (!this.aztecNodeAdmin || !this.config.flushSetupTransactions) {
             this.log.verbose(`No node admin client or flushing not requested (not setting minTxsPerBlock to 0)`);
             return fn();
         }
-        const { minTxsPerBlock } = await this.aztecNodeAdmin.getConfig();
-        this.log.warn(`Setting sequencer minTxsPerBlock to 0 from ${minTxsPerBlock} to flush setup transactions`);
-        await this.aztecNodeAdmin.setConfig({
-            minTxsPerBlock: 0
-        });
+        const aztecNodeAdmin = this.aztecNodeAdmin;
+        // Setup steps run concurrently, so this wrapper can be re-entered while another call is in flight.
+        // Reference-count the entrants: the first saves the current value and zeroes it, the last restores it.
+        // A naive save/zero/restore per call could interleave, with a late entrant reading the already-zeroed
+        // value and "restoring" 0 at the end.
+        if (this.noMinTxsPerBlockDepth++ === 0) {
+            this.savedMinTxsPerBlock = (async ()=>{
+                const { minTxsPerBlock } = await aztecNodeAdmin.getConfig();
+                this.log.warn(`Setting sequencer minTxsPerBlock to 0 from ${minTxsPerBlock} to flush setup transactions`);
+                await aztecNodeAdmin.setConfig({
+                    minTxsPerBlock: 0
+                });
+                return {
+                    minTxsPerBlock
+                };
+            })();
+        }
         try {
+            await this.savedMinTxsPerBlock;
             return await fn();
         } finally{
-            this.log.warn(`Restoring sequencer minTxsPerBlock to ${minTxsPerBlock}`);
-            await this.aztecNodeAdmin.setConfig({
-                minTxsPerBlock
-            });
+            if (--this.noMinTxsPerBlockDepth === 0) {
+                // If saving/zeroing itself failed there is nothing to restore.
+                const saved = await this.savedMinTxsPerBlock.catch(()=>undefined);
+                if (saved) {
+                    this.log.warn(`Restoring sequencer minTxsPerBlock to ${saved.minTxsPerBlock}`);
+                    await aztecNodeAdmin.setConfig({
+                        minTxsPerBlock: saved.minTxsPerBlock
+                    });
+                }
+            }
         }
     }
 }