@aztec/bot 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/config.js

@@ -1,8 +1,9 @@
-import { booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper, secretFrConfigHelper, secretStringConfigHelper } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper, pickConfigMappings, secretFrConfigHelper, secretStringConfigHelper } from '@aztec/foundation/config';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { dataConfigMappings } from '@aztec/kv-store/config';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { schemas } from '@aztec/stdlib/schemas';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { schemas, zodFor } from '@aztec/stdlib/schemas';
 import { z } from 'zod';
 const BotFollowChain = [
     'NONE',
@@ -14,22 +15,21 @@ export var SupportedTokenContracts = /*#__PURE__*/ function(SupportedTokenContra
     SupportedTokenContracts["PrivateTokenContract"] = "PrivateTokenContract";
     return SupportedTokenContracts;
 }({});
-export const BotConfigSchema = z.object({
+export const BotConfigSchema = zodFor()(z.object({
     nodeUrl: z.string().optional(),
     nodeAdminUrl: z.string().optional(),
-    pxeUrl: z.string().optional(),
     l1RpcUrls: z.array(z.string()).optional(),
     l1Mnemonic: schemas.SecretValue(z.string()).optional(),
     l1PrivateKey: schemas.SecretValue(z.string()).optional(),
     l1ToL2MessageTimeoutSeconds: z.number(),
     senderPrivateKey: schemas.SecretValue(schemas.Fr).optional(),
     senderSalt: schemas.Fr.optional(),
-    recipientEncryptionSecret: schemas.SecretValue(schemas.Fr),
     tokenSalt: schemas.Fr,
     txIntervalSeconds: z.number(),
     privateTransfersPerTx: z.number().int().nonnegative(),
     publicTransfersPerTx: z.number().int().nonnegative(),
     feePaymentMethod: z.literal('fee_juice'),
+    minFeePadding: z.number().int().nonnegative(),
     noStart: z.boolean(),
     txMinedWaitSeconds: z.number(),
     followChain: z.enum(BotFollowChain),
@@ -40,11 +40,12 @@ export const BotConfigSchema = z.object({
     contract: z.nativeEnum(SupportedTokenContracts),
     maxConsecutiveErrors: z.number().int().nonnegative(),
     stopWhenUnhealthy: z.boolean(),
-    ammTxs: z.boolean().default(false)
+    ammTxs: z.boolean().default(false),
+    dataDirectory: z.string().optional(),
+    dataStoreMapSizeKb: z.number().optional()
 }).transform((config)=>({
         nodeUrl: undefined,
         nodeAdminUrl: undefined,
-        pxeUrl: undefined,
         l1RpcUrls: undefined,
         senderSalt: undefined,
         l2GasLimit: undefined,
@@ -52,8 +53,10 @@ export const BotConfigSchema = z.object({
         l1Mnemonic: undefined,
         l1PrivateKey: undefined,
         senderPrivateKey: undefined,
+        dataDirectory: undefined,
+        dataStoreMapSizeKb: 1_024 * 1_024,
         ...config
-    }));
+    })));
 export const botConfigMappings = {
     nodeUrl: {
         env: 'AZTEC_NODE_URL',
@@ -63,10 +66,6 @@ export const botConfigMappings = {
         env: 'AZTEC_NODE_ADMIN_URL',
         description: 'The URL to the Aztec node admin API to force-flush txs if configured.'
     },
-    pxeUrl: {
-        env: 'BOT_PXE_URL',
-        description: 'URL to the PXE for sending txs, or undefined if an in-proc PXE is used.'
-    },
     l1RpcUrls: {
         env: 'ETHEREUM_HOSTS',
         description: 'URL of the ethereum host.',
@@ -85,7 +84,7 @@ export const botConfigMappings = {
     l1ToL2MessageTimeoutSeconds: {
         env: 'BOT_L1_TO_L2_TIMEOUT_SECONDS',
         description: 'How long to wait for L1 to L2 messages to become available on L2',
-        ...numberConfigHelper(60)
+        ...numberConfigHelper(3600)
     },
     senderPrivateKey: {
         env: 'BOT_PRIVATE_KEY',
@@ -94,18 +93,12 @@ export const botConfigMappings = {
     },
     senderSalt: {
         env: 'BOT_ACCOUNT_SALT',
-        description: 'The salt to use to deploys the sender account.',
+        description: 'The salt to use to deploy the sender account.',
         parseEnv: (val)=>val ? Fr.fromHexString(val) : undefined
     },
-    recipientEncryptionSecret: {
-        env: 'BOT_RECIPIENT_ENCRYPTION_SECRET',
-        description: 'Encryption secret for a recipient account.',
-        printDefault: (sv)=>sv?.getValue(),
-        ...secretFrConfigHelper(Fr.fromHexString('0xcafecafe'))
-    },
     tokenSalt: {
         env: 'BOT_TOKEN_SALT',
-        description: 'Salt for the token contract deployment.',
+        description: 'The salt to use to deploy the token contract.',
         parseEnv: (val)=>Fr.fromHexString(val),
         defaultValue: Fr.fromHexString('1')
     },
@@ -130,6 +123,11 @@ export const botConfigMappings = {
         parseEnv: (val)=>val || undefined,
         defaultValue: 'fee_juice'
     },
+    minFeePadding: {
+        env: 'BOT_MIN_FEE_PADDING',
+        description: 'How much is the bot willing to overpay vs. the current base fee',
+        ...numberConfigHelper(3)
+    },
     noStart: {
         env: 'BOT_NO_START',
         description: 'True to not automatically setup or start the bot on initialization.',
@@ -196,7 +194,11 @@ export const botConfigMappings = {
         env: 'BOT_AMM_TXS',
         description: 'Deploy an AMM and send swaps to it',
         ...booleanConfigHelper(false)
-    }
+    },
+    ...pickConfigMappings(dataConfigMappings, [
+        'dataStoreMapSizeKb',
+        'dataDirectory'
+    ])
 };
 export function getBotConfigFromEnv() {
     return getConfigFromMappings(botConfigMappings);
@@ -206,7 +208,7 @@ export function getBotDefaultConfig() {
 }
 export function getVersions() {
     return {
-        l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+        l2ProtocolContractsHash: protocolContractsHash.toString(),
         l2CircuitsVkTreeRoot: getVKTreeRoot().toString()
     };
 }

package/dest/factory.d.ts

@@ -1,55 +1,41 @@
-import { AztecAddress, type PXE } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 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 type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { TestWallet } from '@aztec/test-wallet/server';
 import { type BotConfig } from './config.js';
+import type { BotStore } from './store/index.js';
 export declare class BotFactory {
     private readonly config;
-    private pxe;
-    private node?;
-    private nodeAdmin?;
+    private readonly wallet;
+    private readonly store;
+    private readonly aztecNode;
+    private readonly aztecNodeAdmin?;
     private log;
-    constructor(config: BotConfig, dependencies: {
-        pxe?: PXE;
-        nodeAdmin?: AztecNodeAdmin;
-        node?: AztecNode;
-    });
+    constructor(config: BotConfig, wallet: TestWallet, store: BotStore, aztecNode: AztecNode, aztecNodeAdmin?: AztecNodeAdmin | undefined);
     /**
      * Initializes a new bot by setting up the sender account, registering the recipient,
      * deploying the token contract, and minting tokens if necessary.
      */
     setup(): Promise<{
-        wallet: import("@aztec/aztec.js").AccountWalletWithSecretKey;
+        wallet: TestWallet;
         defaultAccountAddress: AztecAddress;
         token: TokenContract | PrivateTokenContract;
-        pxe: PXE;
+        node: AztecNode;
         recipient: AztecAddress;
     }>;
     setupAmm(): Promise<{
-        wallet: import("@aztec/aztec.js").AccountWalletWithSecretKey;
+        wallet: TestWallet;
         defaultAccountAddress: AztecAddress;
         amm: AMMContract;
         token0: TokenContract;
         token1: TokenContract;
-        pxe: PXE;
+        node: AztecNode;
     }>;
-    /**
-     * Checks if the sender account contract is initialized, and initializes it if necessary.
-     * @returns The sender wallet.
-     */
     private setupAccount;
     private setupAccountWithPrivateKey;
     private setupTestAccount;
-    /**
-     * Registers the recipient for txs in the pxe.
-     */
-    private registerRecipient;
-    /**
-     * 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.
-     */
     private setupToken;
     /**
      * Checks if the token contract is deployed and deploys it if necessary.
@@ -60,13 +46,9 @@ export declare class BotFactory {
     private setupAmmContract;
     private fundAmm;
     private registerOrDeployContract;
-    /**
-     * Mints private and public tokens for the sender if their balance is below the minimum.
-     * @param token - Token contract.
-     */
     private mintTokens;
+    private getOrCreateBridgeClaim;
     private bridgeL1FeeJuice;
     private withNoMinTxsPerBlock;
-    private advanceL2Block;
 }
-//# sourceMappingURL=factory.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBa0J6RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0QsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDN0UsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRy9ELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVqRixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFdkQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUEyQixNQUFNLGFBQWEsQ0FBQztBQUN0RSxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQU1qRCxxQkFBYSxVQUFVO0lBSW5CLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQUN2QixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBQ3RCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQztJQVBsQyxPQUFPLENBQUMsR0FBRyxDQUF1QjtJQUVsQyxZQUNtQixNQUFNLEVBQUUsU0FBUyxFQUNqQixNQUFNLEVBQUUsVUFBVSxFQUNsQixLQUFLLEVBQUUsUUFBUSxFQUNmLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGNBQWMsQ0FBQyw0QkFBZ0IsRUFDOUM7SUFFSjs7O09BR0c7SUFDVSxLQUFLLElBQUksT0FBTyxDQUFDO1FBQzVCLE1BQU0sRUFBRSxVQUFVLENBQUM7UUFDbkIscUJBQXFCLEVBQUUsWUFBWSxDQUFDO1FBQ3BDLEtBQUssRUFBRSxhQUFhLEdBQUcsb0JBQW9CLENBQUM7UUFDNUMsSUFBSSxFQUFFLFNBQVMsQ0FBQztRQUNoQixTQUFTLEVBQUUsWUFBWSxDQUFDO0tBQ3pCLENBQUMsQ0FNRDtJQUVZLFFBQVEsSUFBSSxPQUFPLENBQUM7UUFDL0IsTUFBTSxFQUFFLFVBQVUsQ0FBQztRQUNuQixxQkFBcUIsRUFBRSxZQUFZLENBQUM7UUFDcEMsR0FBRyxFQUFFLFdBQVcsQ0FBQztRQUNqQixNQUFNLEVBQUUsYUFBYSxDQUFDO1FBQ3RCLE1BQU0sRUFBRSxhQUFhLENBQUM7UUFDdEIsSUFBSSxFQUFFLFNBQVMsQ0FBQztLQUNqQixDQUFDLENBc0JEO1lBTWEsWUFBWTtZQVdaLDBCQUEwQjtZQXdDMUIsZ0JBQWdCO1lBZ0JoQixVQUFVO0lBdUN4Qjs7OztPQUlHO0lBQ0gsT0FBTyxDQUFDLGtCQUFrQjtZQVlaLGdCQUFnQjtZQW9CaEIsT0FBTztZQThFUCx3QkFBd0I7WUFzQnhCLFVBQVU7WUF3Q1Ysc0JBQXNCO1lBNEJ0QixnQkFBZ0I7WUFnQ2hCLG9CQUFvQjtDQWVuQyJ9

package/dest/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,YAAY,EAQZ,KAAK,GAAG,EAIT,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAIjF,OAAO,EAAE,KAAK,SAAS,EAAwC,MAAM,aAAa,CAAC;AAMnF,qBAAa,UAAU;IAOnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,IAAI,CAAC,CAAY;IACzB,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,GAAG,CAAuB;gBAGf,MAAM,EAAE,SAAS,EAClC,YAAY,EAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE;IA4B3E;;;OAGG;IACU,KAAK;;;;;;;IASL,QAAQ;;;;;;;;IAuCrB;;;OAGG;YACW,YAAY;YASZ,0BAA0B;YA8B1B,gBAAgB;IAc9B;;OAEG;YACW,iBAAiB;IAK/B;;;;OAIG;YACW,UAAU;IA+BxB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;YAaZ,gBAAgB;YAqBhB,OAAO;YA0EP,wBAAwB;IAkBtC;;;OAGG;YACW,UAAU;YAmCV,gBAAgB;YAgChB,oBAAoB;YAapB,cAAc;CAM7B"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAkBzD,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjF,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD,OAAO,EAAE,KAAK,SAAS,EAA2B,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAMjD,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAPlC,OAAO,CAAC,GAAG,CAAuB;IAElC,YACmB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,SAAS,EACpB,cAAc,CAAC,4BAAgB,EAC9C;IAEJ;;;OAGG;IACU,KAAK,IAAI,OAAO,CAAC;QAC5B,MAAM,EAAE,UAAU,CAAC;QACnB,qBAAqB,EAAE,YAAY,CAAC;QACpC,KAAK,EAAE,aAAa,GAAG,oBAAoB,CAAC;QAC5C,IAAI,EAAE,SAAS,CAAC;QAChB,SAAS,EAAE,YAAY,CAAC;KACzB,CAAC,CAMD;IAEY,QAAQ,IAAI,OAAO,CAAC;QAC/B,MAAM,EAAE,UAAU,CAAC;QACnB,qBAAqB,EAAE,YAAY,CAAC;QACpC,GAAG,EAAE,WAAW,CAAC;QACjB,MAAM,EAAE,aAAa,CAAC;QACtB,MAAM,EAAE,aAAa,CAAC;QACtB,IAAI,EAAE,SAAS,CAAC;KACjB,CAAC,CAsBD;YAMa,YAAY;YAWZ,0BAA0B;YAwC1B,gBAAgB;YAgBhB,UAAU;IAuCxB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;YAYZ,gBAAgB;YAoBhB,OAAO;YA8EP,wBAAwB;YAsBxB,UAAU;YAwCV,sBAAsB;YA4BtB,gBAAgB;YAgChB,oBAAoB;CAenC"}

package/dest/factory.js

@@ -1,83 +1,71 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { getDeployedTestAccountsWallets, getInitialTestAccounts } from '@aztec/accounts/testing';
-import { BatchCall, FeeJuicePaymentMethodWithClaim, L1FeeJuicePortalManager, createLogger, createPXEClient, retryUntil } from '@aztec/aztec.js';
-import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall } from '@aztec/aztec.js/contracts';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
+import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
+import { deriveKeys } from '@aztec/aztec.js/keys';
+import { createLogger } from '@aztec/aztec.js/log';
+import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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 { GasSettings } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { makeTracedFetch } from '@aztec/telemetry-client';
-import { SupportedTokenContracts, getVersions } from './config.js';
+import { SupportedTokenContracts } from './config.js';
 import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
 const MINT_BALANCE = 1e12;
 const MIN_BALANCE = 1e3;
 export class BotFactory {
     config;
-    pxe;
-    node;
-    nodeAdmin;
+    wallet;
+    store;
+    aztecNode;
+    aztecNodeAdmin;
     log;
-    constructor(config, dependencies){
+    constructor(config, wallet, store, aztecNode, aztecNodeAdmin){
         this.config = config;
+        this.wallet = wallet;
+        this.store = store;
+        this.aztecNode = aztecNode;
+        this.aztecNodeAdmin = aztecNodeAdmin;
         this.log = createLogger('bot');
-        if (config.flushSetupTransactions && !dependencies.nodeAdmin) {
-            throw new Error(`Either a node admin client or node admin url must be provided if transaction flushing is requested`);
-        }
-        if (config.senderPrivateKey && config.senderPrivateKey.getValue() && !dependencies.node) {
-            throw new Error(`Either a node client or node url must be provided for bridging L1 fee juice to deploy an account with private key`);
-        }
-        if (!dependencies.pxe && !config.pxeUrl) {
-            throw new Error(`Either a PXE client or a PXE URL must be provided`);
-        }
-        this.node = dependencies.node;
-        this.nodeAdmin = dependencies.nodeAdmin;
-        if (dependencies.pxe) {
-            this.log.info(`Using local PXE`);
-            this.pxe = dependencies.pxe;
-            return;
-        }
-        this.log.info(`Using remote PXE at ${config.pxeUrl}`);
-        this.pxe = createPXEClient(config.pxeUrl, getVersions(), makeTracedFetch([
-            1,
-            2,
-            3
-        ], false));
     }
     /**
    * Initializes a new bot by setting up the sender account, registering the recipient,
    * deploying the token contract, and minting tokens if necessary.
    */ async setup() {
-        const recipient = await this.registerRecipient();
-        const wallet = await this.setupAccount();
-        const defaultAccountAddress = wallet.getAddress();
-        const token = await this.setupToken(wallet, defaultAccountAddress);
+        const recipient = (await this.wallet.createAccount()).address;
+        const defaultAccountAddress = await this.setupAccount();
+        const token = await this.setupToken(defaultAccountAddress);
         await this.mintTokens(token, defaultAccountAddress);
         return {
-            wallet,
+            wallet: this.wallet,
             defaultAccountAddress,
             token,
-            pxe: this.pxe,
+            node: this.aztecNode,
             recipient
         };
     }
     async setupAmm() {
-        const wallet = await this.setupAccount();
-        const defaultAccountAddress = wallet.getAddress();
-        const token0 = await this.setupTokenContract(wallet, wallet.getAddress(), this.config.tokenSalt, 'BotToken0', 'BOT0');
-        const token1 = await this.setupTokenContract(wallet, wallet.getAddress(), this.config.tokenSalt, 'BotToken1', 'BOT1');
-        const liquidityToken = await this.setupTokenContract(wallet, wallet.getAddress(), this.config.tokenSalt, 'BotLPToken', 'BOTLP');
-        const amm = await this.setupAmmContract(wallet, wallet.getAddress(), this.config.tokenSalt, token0, token1, liquidityToken);
-        await this.fundAmm(wallet, wallet.getAddress(), amm, token0, token1, liquidityToken);
+        const defaultAccountAddress = await this.setupAccount();
+        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(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);
         this.log.info(`AMM initialized and funded`);
         return {
-            wallet,
+            wallet: this.wallet,
             defaultAccountAddress,
             amm,
             token0,
             token1,
-            pxe: this.pxe
+            node: this.aztecNode
         };
     }
     /**
@@ -86,86 +74,98 @@ export class BotFactory {
    */ async setupAccount() {
         const privateKey = this.config.senderPrivateKey?.getValue();
         if (privateKey) {
+            this.log.info(`Setting up account with provided private key`);
             return await this.setupAccountWithPrivateKey(privateKey);
         } else {
+            this.log.info(`Setting up test account`);
             return await this.setupTestAccount();
         }
     }
-    async setupAccountWithPrivateKey(privateKey) {
+    async setupAccountWithPrivateKey(secret) {
         const salt = this.config.senderSalt ?? Fr.ONE;
-        const signingKey = deriveSigningKey(privateKey);
-        const account = await getSchnorrAccount(this.pxe, privateKey, signingKey, salt);
-        const isInit = (await this.pxe.getContractMetadata(account.getAddress())).isContractInitialized;
+        const signingKey = deriveSigningKey(secret);
+        const accountData = {
+            secret,
+            salt,
+            contract: new SchnorrAccountContract(signingKey)
+        };
+        const accountManager = await this.wallet.createAccount(accountData);
+        const isInit = (await this.wallet.getContractMetadata(accountManager.address)).isContractInitialized;
         if (isInit) {
-            this.log.info(`Account at ${account.getAddress().toString()} already initialized`);
+            this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
             const timer = new Timer();
-            const wallet = await account.register();
-            this.log.info(`Account at ${account.getAddress()} registered. duration=${timer.ms()}`);
-            return wallet;
+            const address = accountManager.address;
+            this.log.info(`Account at ${address} registered. duration=${timer.ms()}`);
+            await this.store.deleteBridgeClaim(address);
+            return address;
         } else {
-            const address = account.getAddress();
+            const address = accountManager.address;
             this.log.info(`Deploying account at ${address}`);
-            const claim = await this.bridgeL1FeeJuice(address);
-            // docs:start:claim_and_deploy
-            const wallet = await account.getWallet();
-            const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claim);
-            const sentTx = account.deploy({
+            const claim = await this.getOrCreateBridgeClaim(address);
+            const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
+            const deployMethod = await accountManager.getDeployMethod();
+            const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1 + this.config.minFeePadding);
+            const gasSettings = GasSettings.default({
+                maxFeesPerGas
+            });
+            const sentTx = deployMethod.send({
+                from: AztecAddress.ZERO,
                 fee: {
+                    gasSettings,
                     paymentMethod
                 }
             });
             const txHash = await sentTx.getTxHash();
-            // docs:end:claim_and_deploy
             this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
             await this.withNoMinTxsPerBlock(()=>sentTx.wait({
                     timeout: this.config.txMinedWaitSeconds
                 }));
             this.log.info(`Account deployed at ${address}`);
-            return wallet;
+            // Clean up the consumed bridge claim
+            await this.store.deleteBridgeClaim(address);
+            return accountManager.address;
         }
     }
     async setupTestAccount() {
-        let [wallet] = await getDeployedTestAccountsWallets(this.pxe);
-        if (wallet) {
-            this.log.info(`Using funded test account: ${wallet.getAddress()}`);
-        } else {
-            this.log.info('Registering funded test account');
-            const [account] = await getInitialTestAccounts();
-            const manager = await getSchnorrAccount(this.pxe, account.secret, account.signingKey, account.salt);
-            wallet = await manager.register();
-            this.log.info(`Funded test account registered: ${wallet.getAddress()}`);
-        }
-        return wallet;
-    }
-    /**
-   * Registers the recipient for txs in the pxe.
-   */ async registerRecipient() {
-        const recipient = await this.pxe.registerAccount(this.config.recipientEncryptionSecret.getValue(), Fr.ONE);
-        return recipient.address;
+        const [initialAccountData] = await getInitialTestAccountsData();
+        const accountData = {
+            secret: initialAccountData.secret,
+            salt: initialAccountData.salt,
+            contract: new SchnorrAccountContract(initialAccountData.signingKey)
+        };
+        const accountManager = await this.wallet.createAccount(accountData);
+        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.
-   */ async setupToken(wallet, sender) {
+   */ async setupToken(sender) {
         let deploy;
+        let tokenInstance;
         const deployOpts = {
             from: sender,
             contractAddressSalt: this.config.tokenSalt,
             universalDeploy: true
         };
         if (this.config.contract === SupportedTokenContracts.TokenContract) {
-            deploy = TokenContract.deploy(wallet, sender, 'BotToken', 'BOT', 18);
+            deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
         } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
-            deploy = PrivateTokenContract.deploy(wallet, MINT_BALANCE, sender);
+            // 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);
             deployOpts.skipInstancePublication = true;
             deployOpts.skipClassPublication = true;
             deployOpts.skipInitialization = false;
+            // Register the contract with the secret key before deployment
+            tokenInstance = await deploy.getInstance(deployOpts);
+            await this.wallet.registerContract(tokenInstance, PrivateTokenContract.artifact, tokenSecretKey);
         } else {
             throw new Error(`Unsupported token contract type: ${this.config.contract}`);
         }
-        const address = (await deploy.getInstance(deployOpts)).address;
-        if ((await this.pxe.getContractMetadata(address)).isContractPublished) {
+        const address = tokenInstance?.address ?? (await deploy.getInstance(deployOpts)).address;
+        if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
             this.log.info(`Token at ${address.toString()} already deployed`);
             return deploy.register();
         } else {
@@ -182,22 +182,22 @@ export class BotFactory {
    * 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.
-   */ setupTokenContract(wallet, deployer, contractAddressSalt, name, ticker, decimals = 18) {
+   */ setupTokenContract(deployer, contractAddressSalt, name, ticker, decimals = 18) {
         const deployOpts = {
             from: deployer,
             contractAddressSalt,
             universalDeploy: true
         };
-        const deploy = TokenContract.deploy(wallet, deployer, name, ticker, decimals);
+        const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
         return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
     }
-    async setupAmmContract(wallet, deployer, contractAddressSalt, token0, token1, lpToken) {
+    async setupAmmContract(deployer, contractAddressSalt, token0, token1, lpToken) {
         const deployOpts = {
             from: deployer,
             contractAddressSalt,
             universalDeploy: true
         };
-        const deploy = AMMContract.deploy(wallet, token0.address, token1.address, lpToken.address);
+        const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address);
         const amm = await this.registerOrDeployContract('AMM', deploy, deployOpts);
         this.log.info(`AMM deployed at ${amm.address}`);
         const minterTx = lpToken.methods.set_minter(amm.address, true).send({
@@ -210,7 +210,7 @@ export class BotFactory {
         this.log.info(`Liquidity token initialized`);
         return amm;
     }
-    async fundAmm(wallet, liquidityProvider, amm, token0, token1, lpToken) {
+    async fundAmm(defaultAccountAddress, liquidityProvider, amm, token0, token1, lpToken) {
         const getPrivateBalances = ()=>Promise.all([
                 token0.methods.balance_of_private(liquidityProvider).simulate({
                     from: liquidityProvider
@@ -231,15 +231,15 @@ export class BotFactory {
         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 wallet.createAuthWit({
+        const token0Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
             caller: amm.address,
-            action: token0.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount0Max, authwitNonce)
+            call: await token0.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount0Max, authwitNonce).getFunctionCall()
         });
-        const token1Authwit = await wallet.createAuthWit({
+        const token1Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
             caller: amm.address,
-            action: token1.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount1Max, authwitNonce)
+            call: await token1.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount1Max, authwitNonce).getFunctionCall()
         });
-        const mintTx = new BatchCall(wallet, [
+        const mintTx = new BatchCall(this.wallet, [
             token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
             token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE)
         ]).send({
@@ -262,11 +262,11 @@ export class BotFactory {
         });
         this.log.info(`Liquidity added`);
         const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
-        this.log.info(`Updated private balances of ${wallet.getAddress()} after minting and funding AMM: token0=${newT0Bal}, token1=${newT1Bal}, lp=${newLPBal}`);
+        this.log.info(`Updated private balances of ${defaultAccountAddress} after minting and funding AMM: token0=${newT0Bal}, token1=${newT1Bal}, lp=${newLPBal}`);
     }
     async registerOrDeployContract(name, deploy, deployOpts) {
         const address = (await deploy.getInstance(deployOpts)).address;
-        if ((await this.pxe.getContractMetadata(address)).isContractPublished) {
+        if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
             this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
             return deploy.register();
         } else {
@@ -313,6 +313,32 @@ export class BotFactory {
                 timeout: this.config.txMinedWaitSeconds
             }));
     }
+    /**
+   * 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.
+   */ 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,
+                        forPublicConsumption: false
+                    }));
+                return existingClaim.claim;
+            } catch (err) {
+                this.log.warn(`Failed to verify existing claim, creating new one: ${err}`);
+                await this.store.deleteBridgeClaim(recipient);
+            }
+        }
+        const claim = await this.bridgeL1FeeJuice(recipient);
+        await this.store.saveBridgeClaim(recipient, claim);
+        return claim;
+    }
     async bridgeL1FeeJuice(recipient) {
         const l1RpcUrls = this.config.l1RpcUrls;
         if (!l1RpcUrls?.length) {
@@ -322,40 +348,36 @@ export class BotFactory {
         if (!mnemonicOrPrivateKey) {
             throw new Error('Either a mnemonic or private key of an L1 account is required to bridge the fee juice to fund the deployment of the account.');
         }
-        const { l1ChainId } = await this.pxe.getNodeInfo();
+        const { l1ChainId } = await this.aztecNode.getNodeInfo();
         const chain = createEthereumChain(l1RpcUrls, l1ChainId);
         const extendedClient = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
-        const portal = await L1FeeJuicePortalManager.new(this.pxe, extendedClient, this.log);
+        const portal = await L1FeeJuicePortalManager.new(this.aztecNode, extendedClient, this.log);
         const mintAmount = await portal.getTokenManager().getMintAmount();
         const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true);
-        const isSynced = async ()=>await this.pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
-        await retryUntil(isSynced, `message ${claim.messageHash} sync`, this.config.l1ToL2MessageTimeoutSeconds, 1);
+        await this.withNoMinTxsPerBlock(()=>waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
+                timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+                forPublicConsumption: false
+            }));
         this.log.info(`Created a claim for ${mintAmount} L1 fee juice to ${recipient}.`, claim);
-        // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
-        await this.advanceL2Block();
-        await this.advanceL2Block();
         return claim;
     }
     async withNoMinTxsPerBlock(fn) {
-        if (!this.nodeAdmin || !this.config.flushSetupTransactions) {
+        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.nodeAdmin.getConfig();
-        await this.nodeAdmin.setConfig({
+        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
         });
         try {
             return await fn();
         } finally{
-            await this.nodeAdmin.setConfig({
+            this.log.warn(`Restoring sequencer minTxsPerBlock to ${minTxsPerBlock}`);
+            await this.aztecNodeAdmin.setConfig({
                 minTxsPerBlock
             });
         }
     }
-    async advanceL2Block() {
-        await this.withNoMinTxsPerBlock(async ()=>{
-            const initialBlockNumber = await this.node.getBlockNumber();
-            await retryUntil(async ()=>await this.node.getBlockNumber() >= initialBlockNumber + 1);
-        });
-    }
 }