@aztec/bot 0.0.1-commit.9ef841308 → 0.0.1-commit.a4600f49

package/src/bot.ts

@@ -4,6 +4,7 @@ import { TxHash } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
 import type { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { BlockTag } from '@aztec/stdlib/block';
 import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
@@ -33,6 +34,7 @@ export class Bot extends BaseBot {
     aztecNode: AztecNode,
     aztecNodeAdmin: AztecNodeAdmin | undefined,
     store: BotStore,
+    syncChainTip?: BlockTag,
   ): Promise<Bot> {
     const { defaultAccountAddress, token, recipient } = await new BotFactory(
       config,
@@ -40,6 +42,7 @@ export class Bot extends BaseBot {
       store,
       aztecNode,
       aztecNodeAdmin,
+      syncChainTip,
     ).setup();
     return new Bot(aztecNode, wallet, defaultAccountAddress, token, recipient, config);
   }

package/src/config.ts

@@ -2,6 +2,7 @@ import {
   type ConfigMappingsType,
   SecretValue,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -103,7 +104,7 @@ export const BotConfigSchema = zodFor<BotConfig>()(
       privateTransfersPerTx: z.number().int().nonnegative(),
       publicTransfersPerTx: z.number().int().nonnegative(),
       feePaymentMethod: z.literal('fee_juice'),
-      minFeePadding: z.number().int().nonnegative(),
+      minFeePadding: z.number().nonnegative(),
       noStart: z.boolean(),
       txMinedWaitSeconds: z.number(),
       followChain: z.enum(BotFollowChain),
@@ -204,7 +205,7 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
   minFeePadding: {
     env: 'BOT_MIN_FEE_PADDING',
     description: 'How much is the bot willing to overpay vs. the current base fee',
-    ...numberConfigHelper(3),
+    ...floatConfigHelper(3),
   },
   noStart: {
     env: 'BOT_NO_START',

package/src/cross_chain_bot.ts

@@ -26,11 +26,12 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { BatchCall, NO_WAIT } from '@aztec/aztec.js/contracts';
 import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
-import { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
+import type { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
 import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { TestContract } from '@aztec/noir-test-contracts.js/Test';
+import type { BlockTag } from '@aztec/stdlib/block';
 import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
@@ -60,6 +61,7 @@ export class CrossChainBot extends BaseBot {
     private readonly rollupVersion: bigint,
     private readonly store: BotStore,
     config: BotConfig,
+    private readonly syncChainTip?: BlockTag,
   ) {
     super(node, wallet, defaultAccountAddress, config);
   }
@@ -70,11 +72,12 @@ export class CrossChainBot extends BaseBot {
     aztecNode: AztecNode,
     aztecNodeAdmin: AztecNodeAdmin | undefined,
     store: BotStore,
+    syncChainTip?: BlockTag,
   ): Promise<CrossChainBot> {
     if (config.followChain === 'NONE') {
       throw new Error(`CrossChainBot requires followChain to be set (got NONE)`);
     }
-    const factory = new BotFactory(config, wallet, store, aztecNode, aztecNodeAdmin);
+    const factory = new BotFactory(config, wallet, store, aztecNode, aztecNodeAdmin, syncChainTip);
     const { defaultAccountAddress, contract, l1Client, rollupVersion } = await factory.setupCrossChain();
     const l1Recipient = EthAddress.fromString(l1Client.account!.address);
     const { l1ContractAddresses } = await aztecNode.getNodeInfo();
@@ -90,6 +93,7 @@ export class CrossChainBot extends BaseBot {
       rollupVersion,
       store,
       config,
+      syncChainTip,
     );
   }
 
@@ -146,9 +150,10 @@ export class CrossChainBot extends BaseBot {
 
   protected override async onTxMined(receipt: TxReceipt, logCtx: object): Promise<void> {
     // Verify L2→L1 messages appeared in this tx's effects
-    const indexed = await this.node.getTxEffect(receipt.txHash);
-    if (indexed) {
-      const l2ToL1Msgs = indexed.data.l2ToL1Msgs.filter(m => !m.isZero());
+    const minedReceipt = await this.node.getTxReceipt(receipt.txHash, { includeTxEffect: true });
+    const l2ToL1MsgsRaw = minedReceipt.txEffect?.l2ToL1Msgs;
+    if (l2ToL1MsgsRaw) {
+      const l2ToL1Msgs = l2ToL1MsgsRaw.filter(m => !m.isZero());
       if (l2ToL1Msgs.length >= this.config.l2ToL1MessagesPerTx) {
         this.l2ToL1Sent += l2ToL1Msgs.length;
       } else {
@@ -175,7 +180,7 @@ export class CrossChainBot extends BaseBot {
   ): Promise<PendingL1ToL2Message | undefined> {
     const now = Date.now();
     for (const msg of pendingMessages) {
-      const ready = await isL1ToL2MessageReady(this.node, Fr.fromHexString(msg.msgHash));
+      const ready = await isL1ToL2MessageReady(this.node, Fr.fromHexString(msg.msgHash), this.syncChainTip);
       if (ready) {
         return msg;
       }

package/src/factory.ts

@@ -1,5 +1,4 @@
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
   BatchCall,
@@ -16,18 +15,18 @@ import { deriveKeys } from '@aztec/aztec.js/keys';
 import { createLogger } from '@aztec/aztec.js/log';
 import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
 import { waitForTx } from '@aztec/aztec.js/node';
-import { ContractInitializationStatus } from '@aztec/aztec.js/wallet';
+import { getFeeJuiceBalance } from '@aztec/aztec.js/utils';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 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 type { BlockTag } from '@aztec/stdlib/block';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
@@ -40,6 +39,7 @@ import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils
 
 const MINT_BALANCE = 1e12;
 const MIN_BALANCE = 1e3;
+const FEE_JUICE_TOP_UP_THRESHOLD = 100n * 10n ** 18n;
 
 export class BotFactory {
   private log = createLogger('bot');
@@ -50,6 +50,7 @@ export class BotFactory {
     private readonly store: BotStore,
     private readonly aztecNode: AztecNode,
     private readonly aztecNodeAdmin?: AztecNodeAdmin,
+    private readonly syncChainTip?: BlockTag,
   ) {
     // Set fee padding on the wallet so that all transactions during setup
     // (token deploy, minting, etc.) use the configured padding, not the default.
@@ -69,6 +70,7 @@ export class BotFactory {
   }> {
     const defaultAccountAddress = await this.setupAccount();
     const recipient = (await this.wallet.createSchnorrAccount(Fr.random(), Fr.random())).address;
+    await this.ensureFeeJuiceBalance(defaultAccountAddress);
     const token = await this.setupToken(defaultAccountAddress);
     await this.mintTokens(token, defaultAccountAddress);
     return { wallet: this.wallet, defaultAccountAddress, token, node: this.aztecNode, recipient };
@@ -83,6 +85,7 @@ export class BotFactory {
     node: AztecNode;
   }> {
     const defaultAccountAddress = await this.setupAccount();
+    await this.ensureFeeJuiceBalance(defaultAccountAddress);
     const token0 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken0', 'BOT0');
     const token1 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken1', 'BOT1');
     const liquidityToken = await this.setupTokenContract(
@@ -118,6 +121,7 @@ export class BotFactory {
     rollupVersion: bigint;
   }> {
     const defaultAccountAddress = await this.setupAccount();
+    await this.ensureFeeJuiceBalance(defaultAccountAddress);
 
     // Create L1 client (same pattern as bridgeL1FeeJuice)
     const l1RpcUrls = this.config.l1RpcUrls;
@@ -136,7 +140,7 @@ export class BotFactory {
     const rollupContract = new RollupContract(l1Client, l1ContractAddresses.rollupAddress.toString());
     const rollupVersion = await rollupContract.getVersion();
 
-    // Deploy TestContract
+    // Deploy TestContract (pays from the standing balance funded above).
     const contract = await this.setupTestContract(defaultAccountAddress);
 
     // Recover any pending messages from store (clean up stale ones first)
@@ -163,6 +167,7 @@ export class BotFactory {
       const firstMsg = allMessages[0];
       await waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(firstMsg.msgHash), {
         timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+        chainTip: this.syncChainTip,
       });
       this.log.info(`First L1→L2 message is ready`);
     }
@@ -178,12 +183,8 @@ export class BotFactory {
   }
 
   private async setupTestContract(deployer: AztecAddress): Promise<TestContract> {
-    const deployOpts: DeployOptions = {
-      from: deployer,
-      contractAddressSalt: this.config.tokenSalt,
-      universalDeploy: true,
-    };
-    const deploy = TestContract.deploy(this.wallet);
+    const deployOpts: DeployOptions = { 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);
   }
@@ -203,48 +204,16 @@ export class BotFactory {
     }
   }
 
-  private async setupAccountWithPrivateKey(secret: Fr) {
-    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;
-    }
-  }
-
+  /**
+   * 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.
+   */
   private async setupTestAccount() {
     const [initialAccountData] = await getInitialTestAccountsData();
-    const accountManager = await this.wallet.createSchnorrAccount(
+    const accountManager = await this.wallet.createSchnorrInitializerlessAccount(
       initialAccountData.secret,
       initialAccountData.salt,
       initialAccountData.signingKey,
@@ -252,35 +221,44 @@ export class BotFactory {
     return accountManager.address;
   }
 
+  private async setupAccountWithPrivateKey(secret: Fr) {
+    const salt = this.config.senderSalt ?? Fr.ONE;
+    const signingKey = deriveSigningKey(secret);
+    const accountManager = await this.wallet.createSchnorrInitializerlessAccount(secret, salt, signingKey);
+    return accountManager.address;
+  }
+
   /**
    * Checks if the token contract is deployed and deploys it if necessary.
-   * @param wallet - Wallet to deploy the token contract from.
-   * @returns The TokenContract instance.
+   * Uses a bridge claim for deploy when balance is below threshold to avoid failing before refuel.
+   * @param sender - Aztec address to deploy the token contract from.
+   * @param existingToken - Optional token instance when called from setupTokenWithOptionalEarlyRefuel.
+   * @returns The TokenContract or PrivateTokenContract instance.
    */
   private async setupToken(sender: AztecAddress): Promise<TokenContract | PrivateTokenContract> {
     let deploy: DeployMethod<TokenContract | PrivateTokenContract>;
-    let tokenInstance: ContractInstanceWithAddress | undefined;
-    const deployOpts: DeployOptions = {
-      from: sender,
-      contractAddressSalt: this.config.tokenSalt,
-      universalDeploy: true,
-    };
+    const salt = this.config.tokenSalt;
+    const deployOpts: DeployOptions = { from: sender };
     let token: TokenContract | PrivateTokenContract;
     if (this.config.contract === SupportedTokenContracts.TokenContract) {
-      deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
-      tokenInstance = await deploy.getInstance(deployOpts);
-      token = TokenContract.at(tokenInstance.address, this.wallet);
+      deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18, { salt, universalDeploy: true });
+      const instance = await deploy.getInstance();
+      token = TokenContract.at(instance.address, this.wallet);
     } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
       // Generate keys for the contract since PrivateToken uses SinglePrivateMutable which requires keys
       const tokenSecretKey = Fr.random();
       const tokenPublicKeys = (await deriveKeys(tokenSecretKey)).publicKeys;
-      deploy = PrivateTokenContract.deployWithPublicKeys(tokenPublicKeys, this.wallet, MINT_BALANCE, sender);
+      deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender, {
+        salt,
+        universalDeploy: true,
+        publicKeys: tokenPublicKeys,
+      });
       deployOpts.skipInstancePublication = true;
       deployOpts.skipClassPublication = true;
       deployOpts.skipInitialization = false;
 
       // Register the contract with the secret key before deployment
-      tokenInstance = await deploy.getInstance(deployOpts);
+      const tokenInstance = await deploy.getInstance();
       token = PrivateTokenContract.at(tokenInstance.address, this.wallet);
       await this.wallet.registerContract(tokenInstance, PrivateTokenContract.artifact, tokenSecretKey);
       // The contract constructor initializes private storage vars that need the contract's own nullifier key.
@@ -289,20 +267,7 @@ export class BotFactory {
       throw new Error(`Unsupported token contract type: ${this.config.contract}`);
     }
 
-    const address = tokenInstance?.address ?? (await deploy.getInstance(deployOpts)).address;
-    const metadata = await this.wallet.getContractMetadata(address);
-    if (metadata.isContractPublished) {
-      this.log.info(`Token at ${address.toString()} already deployed`);
-      await deploy.register();
-    } else {
-      this.log.info(`Deploying token contract at ${address.toString()}`);
-      const { txHash } = await deploy.send({ ...deployOpts, wait: NO_WAIT });
-      this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
-      await this.withNoMinTxsPerBlock(async () => {
-        await waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
-        return token;
-      });
-    }
+    await this.registerOrDeployContract('token', deploy, deployOpts);
     return token;
   }
 
@@ -313,26 +278,29 @@ export class BotFactory {
    */
   private async setupTokenContract(
     deployer: AztecAddress,
-    contractAddressSalt: Fr,
+    salt: Fr,
     name: string,
     ticker: string,
     decimals = 18,
   ): Promise<TokenContract> {
-    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
-    const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
+    const deployOpts: DeployOptions = { from: deployer };
+    const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals, { salt, universalDeploy: true });
     const instance = await this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
     return TokenContract.at(instance.address, this.wallet);
   }
 
   private async setupAmmContract(
     deployer: AztecAddress,
-    contractAddressSalt: Fr,
+    salt: Fr,
     token0: TokenContract,
     token1: TokenContract,
     lpToken: TokenContract,
   ): Promise<AMMContract> {
-    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
-    const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address);
+    const deployOpts: DeployOptions = { 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);
 
@@ -448,27 +416,75 @@ export class BotFactory {
     deploy: DeployMethod<T>,
     deployOpts: DeployOptions,
   ): Promise<ContractInstanceWithAddress> {
-    const instance = await deploy.getInstance(deployOpts);
+    const instance = await deploy.getInstance();
     const address = instance.address;
     const metadata = await this.wallet.getContractMetadata(address);
     if (metadata.isContractPublished) {
       this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
       await deploy.register();
-    } else {
-      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} 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;
   }
 
+  /** True when the config allows bridging fee juice from L1 (fee_juice mode, an L1 RPC, and an L1 key). */
+  private isL1BridgingConfigured(): boolean {
+    const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
+    return this.config.feePaymentMethod === 'fee_juice' && !!this.config.l1RpcUrls?.length && !!mnemonicOrPrivateKey;
+  }
+
   /**
-   * Mints private and public tokens for the sender if their balance is below the minimum.
-   * @param token - Token contract.
+   * 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.
    */
+  private async ensureFeeJuiceBalance(account: AztecAddress): Promise<void> {
+    if (!this.isL1BridgingConfigured()) {
+      return;
+    }
+
+    let balance = await getFeeJuiceBalance(account, this.aztecNode);
+    if (balance >= FEE_JUICE_TOP_UP_THRESHOLD) {
+      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`);
+
+    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);
+
+      await this.withNoMinTxsPerBlock(async () => {
+        const executionPayload = await paymentMethod.getExecutionPayload();
+        const { txHash } = await this.wallet.sendTx(executionPayload, { from: account, wait: NO_WAIT });
+        this.log.info(`Sent fee juice top-up tx ${txHash.toString()}`);
+        return waitForTx(this.aztecNode, txHash, { 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}`);
+    }
+    this.log.info(`Fee juice top-up complete for ${account.toString()}`);
+  }
+
   private async mintTokens(token: TokenContract | PrivateTokenContract, minter: AztecAddress) {
     const isStandardToken = isStandardTokenContract(token);
     let privateBalance = 0n;
@@ -514,22 +530,20 @@ 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.
    */
   private async getOrCreateBridgeClaim(recipient: AztecAddress): Promise<L2AmountClaim> {
-    // 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,
+            chainTip: this.syncChainTip,
           }),
         );
         return existingClaim.claim;
@@ -541,7 +555,6 @@ export class BotFactory {
 
     const claim = await this.bridgeL1FeeJuice(recipient);
     await this.store.saveBridgeClaim(recipient, claim);
-
     return claim;
   }
 
@@ -568,6 +581,7 @@ export class BotFactory {
     await this.withNoMinTxsPerBlock(() =>
       waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
         timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+        chainTip: this.syncChainTip,
       }),
     );
 

package/src/interface.ts

@@ -22,11 +22,11 @@ export interface BotRunnerApi {
 }
 
 export const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi> = {
-  start: z.function().args().returns(z.void()),
-  stop: z.function().args().returns(z.void()),
-  run: z.function().args().returns(z.void()),
-  setup: z.function().args().returns(z.void()),
-  getInfo: z.function().args().returns(BotInfoSchema),
-  getConfig: z.function().args().returns(BotConfigSchema),
-  update: z.function().args(BotConfigSchema).returns(z.void()),
+  start: z.function({ input: z.tuple([]), output: z.void() }),
+  stop: z.function({ input: z.tuple([]), output: z.void() }),
+  run: z.function({ input: z.tuple([]), output: z.void() }),
+  setup: z.function({ input: z.tuple([]), output: z.void() }),
+  getInfo: z.function({ input: z.tuple([]), output: BotInfoSchema }),
+  getConfig: z.function({ input: z.tuple([]), output: BotConfigSchema }),
+  update: z.function({ input: z.tuple([BotConfigSchema]), output: z.void() }),
 };

package/src/runner.ts

@@ -2,6 +2,7 @@ import { createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import { omit } from '@aztec/foundation/collection';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { BlockTag } from '@aztec/stdlib/block';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 import type { EmbeddedWallet } from '@aztec/wallets/embedded';
@@ -30,6 +31,7 @@ export class BotRunner implements BotRunnerApi, Traceable {
     private readonly telemetry: TelemetryClient,
     private readonly aztecNodeAdmin: AztecNodeAdmin | undefined,
     private readonly store: BotStore,
+    private readonly syncChainTip?: BlockTag,
   ) {
     this.tracer = telemetry.getTracer('Bot');
 
@@ -149,13 +151,34 @@ export class BotRunner implements BotRunnerApi, Traceable {
     try {
       switch (this.config.botMode) {
         case 'crosschain':
-          this.bot = CrossChainBot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
+          this.bot = CrossChainBot.create(
+            this.config,
+            this.wallet,
+            this.aztecNode,
+            this.aztecNodeAdmin,
+            this.store,
+            this.syncChainTip,
+          );
           break;
         case 'amm':
-          this.bot = AmmBot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
+          this.bot = AmmBot.create(
+            this.config,
+            this.wallet,
+            this.aztecNode,
+            this.aztecNodeAdmin,
+            this.store,
+            this.syncChainTip,
+          );
           break;
         case 'transfer':
-          this.bot = Bot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
+          this.bot = Bot.create(
+            this.config,
+            this.wallet,
+            this.aztecNode,
+            this.aztecNodeAdmin,
+            this.store,
+            this.syncChainTip,
+          );
           break;
         default: {
           const _exhaustive: never = this.config.botMode;