@aztec/bot 0.0.0-test.0

package/README.md

@@ -0,0 +1,3 @@
+# Transactions Bot
+
+Simple bot that connects to a PXE to send txs on a recurring basis.

package/dest/bot.d.ts

@@ -0,0 +1,33 @@
+import { type AztecAddress, type Wallet } from '@aztec/aztec.js';
+import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import type { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { BotConfig } from './config.js';
+export declare class Bot {
+    readonly wallet: Wallet;
+    readonly token: TokenContract | EasyPrivateTokenContract;
+    readonly recipient: AztecAddress;
+    config: BotConfig;
+    private log;
+    private attempts;
+    private successes;
+    protected constructor(wallet: Wallet, token: TokenContract | EasyPrivateTokenContract, recipient: AztecAddress, config: BotConfig);
+    static create(config: BotConfig, dependencies?: {
+        pxe?: PXE;
+        node?: AztecNode;
+    }): Promise<Bot>;
+    updateConfig(config: Partial<BotConfig>): void;
+    run(): Promise<void>;
+    getBalances(): Promise<{
+        sender: {
+            privateBalance: bigint;
+            publicBalance: bigint;
+        };
+        recipient: {
+            privateBalance: bigint;
+            publicBalance: bigint;
+        };
+    }>;
+    private getSendMethodOpts;
+}
+//# sourceMappingURL=bot.d.ts.map

package/dest/bot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../src/bot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAIjB,KAAK,MAAM,EAEZ,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAGpE,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,qBAAa,GAAG;aAOI,MAAM,EAAE,MAAM;aACd,KAAK,EAAE,aAAa,GAAG,wBAAwB;aAC/C,SAAS,EAAE,YAAY;IAChC,MAAM,EAAE,SAAS;IAT1B,OAAO,CAAC,GAAG,CAAuB;IAElC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,SAAS,CAAa;IAE9B,SAAS,aACS,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,GAAG,wBAAwB,EAC/C,SAAS,EAAE,YAAY,EAChC,MAAM,EAAE,SAAS;WAGb,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,GAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAO,GAAG,OAAO,CAAC,GAAG,CAAC;IAKjG,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC;IAKjC,GAAG;IAoEH,WAAW;;;;;;;;;;IAoBxB,OAAO,CAAC,iBAAiB;CAkB1B"}

package/dest/bot.js

@@ -0,0 +1,122 @@
+import { BatchCall, FeeJuicePaymentMethod, createLogger } from '@aztec/aztec.js';
+import { timesParallel } from '@aztec/foundation/collection';
+import { Gas } from '@aztec/stdlib/gas';
+import { BotFactory } from './factory.js';
+import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
+const TRANSFER_AMOUNT = 1;
+export class Bot {
+    wallet;
+    token;
+    recipient;
+    config;
+    log;
+    attempts;
+    successes;
+    constructor(wallet, token, recipient, config){
+        this.wallet = wallet;
+        this.token = token;
+        this.recipient = recipient;
+        this.config = config;
+        this.log = createLogger('bot');
+        this.attempts = 0;
+        this.successes = 0;
+    }
+    static async create(config, dependencies = {}) {
+        const { wallet, token, recipient } = await new BotFactory(config, dependencies).setup();
+        return new Bot(wallet, token, recipient, config);
+    }
+    updateConfig(config) {
+        this.log.info(`Updating bot config ${Object.keys(config).join(', ')}`);
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    async run() {
+        this.attempts++;
+        const logCtx = {
+            runId: Date.now() * 1000 + Math.floor(Math.random() * 1000)
+        };
+        const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod, followChain, txMinedWaitSeconds } = this.config;
+        const { token, recipient, wallet } = this;
+        const sender = wallet.getAddress();
+        this.log.verbose(`Preparing tx with ${feePaymentMethod} fee with ${privateTransfersPerTx} private and ${publicTransfersPerTx} public transfers`, logCtx);
+        const calls = [];
+        if (isStandardTokenContract(token)) {
+            calls.push(...await timesParallel(privateTransfersPerTx, ()=>token.methods.transfer(recipient, TRANSFER_AMOUNT).request()));
+            calls.push(...await timesParallel(publicTransfersPerTx, ()=>token.methods.transfer_in_public(sender, recipient, TRANSFER_AMOUNT, 0).request()));
+        } else {
+            calls.push(...await timesParallel(privateTransfersPerTx, ()=>token.methods.transfer(TRANSFER_AMOUNT, sender, recipient).request()));
+        }
+        const opts = this.getSendMethodOpts();
+        const batch = new BatchCall(wallet, calls);
+        this.log.verbose(`Simulating transaction with ${calls.length}`, logCtx);
+        await batch.simulate();
+        this.log.verbose(`Proving transaction`, logCtx);
+        const provenTx = await batch.prove(opts);
+        this.log.verbose(`Sending tx`, logCtx);
+        const tx = provenTx.send();
+        const txHash = await tx.getTxHash();
+        if (followChain === 'NONE') {
+            this.log.info(`Transaction ${txHash} sent, not waiting for it to be mined`);
+            return;
+        }
+        this.log.verbose(`Awaiting tx ${txHash} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`, logCtx);
+        const receipt = await tx.wait({
+            timeout: txMinedWaitSeconds,
+            provenTimeout: txMinedWaitSeconds,
+            proven: followChain === 'PROVEN'
+        });
+        this.log.info(`Tx #${this.attempts} ${receipt.txHash} successfully mined in block ${receipt.blockNumber} (stats: ${this.successes}/${this.attempts} success)`, logCtx);
+        this.successes++;
+    }
+    async getBalances() {
+        if (isStandardTokenContract(this.token)) {
+            return {
+                sender: await getBalances(this.token, this.wallet.getAddress()),
+                recipient: await getBalances(this.token, this.recipient)
+            };
+        } else {
+            return {
+                sender: {
+                    privateBalance: await getPrivateBalance(this.token, this.wallet.getAddress()),
+                    publicBalance: 0n
+                },
+                recipient: {
+                    privateBalance: await getPrivateBalance(this.token, this.recipient),
+                    publicBalance: 0n
+                }
+            };
+        }
+    }
+    getSendMethodOpts() {
+        const sender = this.wallet.getAddress();
+        const { l2GasLimit, daGasLimit, skipPublicSimulation } = this.config;
+        const paymentMethod = new FeeJuicePaymentMethod(sender);
+        let gasSettings, estimateGas;
+        if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
+            gasSettings = {
+                gasLimits: Gas.from({
+                    l2Gas: l2GasLimit,
+                    daGas: daGasLimit
+                })
+            };
+            estimateGas = false;
+            this.log.verbose(`Using gas limits ${l2GasLimit} L2 gas ${daGasLimit} DA gas`);
+        } else {
+            estimateGas = true;
+            this.log.verbose(`Estimating gas for transaction`);
+        }
+        const baseFeePadding = 2; // Send 3x the current base fee
+        this.log.verbose(skipPublicSimulation ? `Skipping public simulation` : `Simulating public transfers`);
+        return {
+            fee: {
+                estimateGas,
+                paymentMethod,
+                gasSettings,
+                baseFeePadding
+            },
+            skipPublicSimulation
+        };
+    }
+}

package/dest/config.d.ts

@@ -0,0 +1,186 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor } from '@aztec/stdlib/schemas';
+import type { ComponentsVersions } from '@aztec/stdlib/versioning';
+import { z } from 'zod';
+declare const BotFollowChain: readonly ["NONE", "PENDING", "PROVEN"];
+type BotFollowChain = (typeof BotFollowChain)[number];
+export declare enum SupportedTokenContracts {
+    TokenContract = "TokenContract",
+    EasyPrivateTokenContract = "EasyPrivateTokenContract"
+}
+export type BotConfig = {
+    /** The URL to the Aztec node to check for tx pool status. */
+    nodeUrl: string | undefined;
+    /** URL to the PXE for sending txs, or undefined if an in-proc PXE is used. */
+    pxeUrl: string | undefined;
+    /** Url of the ethereum host. */
+    l1RpcUrls: string[] | undefined;
+    /** The mnemonic for the account to bridge fee juice from L1. */
+    l1Mnemonic: string | undefined;
+    /** The private key for the account to bridge fee juice from L1. */
+    l1PrivateKey: string | undefined;
+    /** Signing private key for the sender account. */
+    senderPrivateKey: Fr | undefined;
+    /** Encryption secret for a recipient account. */
+    recipientEncryptionSecret: Fr;
+    /** Salt for the token contract deployment. */
+    tokenSalt: Fr;
+    /** Every how many seconds should a new tx be sent. */
+    txIntervalSeconds: number;
+    /** How many private token transfers are executed per tx. */
+    privateTransfersPerTx: number;
+    /** How many public token transfers are executed per tx. */
+    publicTransfersPerTx: number;
+    /** How to handle fee payments. */
+    feePaymentMethod: 'fee_juice';
+    /** True to not automatically setup or start the bot on initialization. */
+    noStart: boolean;
+    /** How long to wait for a tx to be mined before reporting an error. */
+    txMinedWaitSeconds: number;
+    /** Whether to wait for txs to be proven, to be mined, or no wait at all. */
+    followChain: BotFollowChain;
+    /** Do not send a tx if the node's tx pool already has this many pending txs. */
+    maxPendingTxs: number;
+    /** Whether to flush after sending each 'setup' transaction */
+    flushSetupTransactions: boolean;
+    /** Whether to skip public simulation of txs before sending them. */
+    skipPublicSimulation: boolean;
+    /** L2 gas limit for the tx (empty to have the bot trigger an estimate gas). */
+    l2GasLimit: number | undefined;
+    /** DA gas limit for the tx (empty to have the bot trigger an estimate gas). */
+    daGasLimit: number | undefined;
+    /** Token contract to use */
+    contract: SupportedTokenContracts;
+    /** The maximum number of consecutive errors before the bot shuts down */
+    maxConsecutiveErrors: number;
+    /** Stops the bot if service becomes unhealthy */
+    stopWhenUnhealthy: boolean;
+};
+export declare const BotConfigSchema: z.ZodEffects<z.ZodObject<{
+    nodeUrl: z.ZodOptional<z.ZodString>;
+    pxeUrl: z.ZodOptional<z.ZodString>;
+    l1RpcUrls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    l1Mnemonic: z.ZodOptional<z.ZodString>;
+    l1PrivateKey: z.ZodOptional<z.ZodString>;
+    senderPrivateKey: z.ZodOptional<ZodFor<Fr>>;
+    recipientEncryptionSecret: ZodFor<Fr>;
+    tokenSalt: ZodFor<Fr>;
+    txIntervalSeconds: z.ZodNumber;
+    privateTransfersPerTx: z.ZodNumber;
+    publicTransfersPerTx: z.ZodNumber;
+    feePaymentMethod: z.ZodLiteral<"fee_juice">;
+    noStart: z.ZodBoolean;
+    txMinedWaitSeconds: z.ZodNumber;
+    followChain: z.ZodEnum<["NONE", "PENDING", "PROVEN"]>;
+    maxPendingTxs: z.ZodNumber;
+    flushSetupTransactions: z.ZodBoolean;
+    skipPublicSimulation: z.ZodBoolean;
+    l2GasLimit: z.ZodOptional<z.ZodNumber>;
+    daGasLimit: z.ZodOptional<z.ZodNumber>;
+    contract: z.ZodNativeEnum<typeof SupportedTokenContracts>;
+    maxConsecutiveErrors: z.ZodNumber;
+    stopWhenUnhealthy: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    recipientEncryptionSecret: Fr;
+    tokenSalt: Fr;
+    txIntervalSeconds: number;
+    privateTransfersPerTx: number;
+    publicTransfersPerTx: number;
+    feePaymentMethod: "fee_juice";
+    noStart: boolean;
+    txMinedWaitSeconds: number;
+    followChain: "NONE" | "PENDING" | "PROVEN";
+    maxPendingTxs: number;
+    flushSetupTransactions: boolean;
+    skipPublicSimulation: boolean;
+    contract: SupportedTokenContracts;
+    maxConsecutiveErrors: number;
+    stopWhenUnhealthy: boolean;
+    nodeUrl?: string | undefined;
+    pxeUrl?: string | undefined;
+    l1RpcUrls?: string[] | undefined;
+    l1Mnemonic?: string | undefined;
+    l1PrivateKey?: string | undefined;
+    senderPrivateKey?: Fr | undefined;
+    l2GasLimit?: number | undefined;
+    daGasLimit?: number | undefined;
+}, {
+    txIntervalSeconds: number;
+    privateTransfersPerTx: number;
+    publicTransfersPerTx: number;
+    feePaymentMethod: "fee_juice";
+    noStart: boolean;
+    txMinedWaitSeconds: number;
+    followChain: "NONE" | "PENDING" | "PROVEN";
+    maxPendingTxs: number;
+    flushSetupTransactions: boolean;
+    skipPublicSimulation: boolean;
+    contract: SupportedTokenContracts;
+    maxConsecutiveErrors: number;
+    stopWhenUnhealthy: boolean;
+    nodeUrl?: string | undefined;
+    pxeUrl?: string | undefined;
+    l1RpcUrls?: string[] | undefined;
+    l1Mnemonic?: string | undefined;
+    l1PrivateKey?: string | undefined;
+    senderPrivateKey?: any;
+    recipientEncryptionSecret?: any;
+    tokenSalt?: any;
+    l2GasLimit?: number | undefined;
+    daGasLimit?: number | undefined;
+}>, {
+    recipientEncryptionSecret: Fr;
+    tokenSalt: Fr;
+    txIntervalSeconds: number;
+    privateTransfersPerTx: number;
+    publicTransfersPerTx: number;
+    feePaymentMethod: "fee_juice";
+    noStart: boolean;
+    txMinedWaitSeconds: number;
+    followChain: "NONE" | "PENDING" | "PROVEN";
+    maxPendingTxs: number;
+    flushSetupTransactions: boolean;
+    skipPublicSimulation: boolean;
+    contract: SupportedTokenContracts;
+    maxConsecutiveErrors: number;
+    stopWhenUnhealthy: boolean;
+    nodeUrl: string | undefined;
+    pxeUrl: string | undefined;
+    l1RpcUrls: string[] | undefined;
+    l1Mnemonic: string | undefined;
+    l1PrivateKey: string | undefined;
+    senderPrivateKey: Fr | undefined;
+    l2GasLimit: number | undefined;
+    daGasLimit: number | undefined;
+}, {
+    txIntervalSeconds: number;
+    privateTransfersPerTx: number;
+    publicTransfersPerTx: number;
+    feePaymentMethod: "fee_juice";
+    noStart: boolean;
+    txMinedWaitSeconds: number;
+    followChain: "NONE" | "PENDING" | "PROVEN";
+    maxPendingTxs: number;
+    flushSetupTransactions: boolean;
+    skipPublicSimulation: boolean;
+    contract: SupportedTokenContracts;
+    maxConsecutiveErrors: number;
+    stopWhenUnhealthy: boolean;
+    nodeUrl?: string | undefined;
+    pxeUrl?: string | undefined;
+    l1RpcUrls?: string[] | undefined;
+    l1Mnemonic?: string | undefined;
+    l1PrivateKey?: string | undefined;
+    senderPrivateKey?: any;
+    recipientEncryptionSecret?: any;
+    tokenSalt?: any;
+    l2GasLimit?: number | undefined;
+    daGasLimit?: number | undefined;
+}>;
+export declare const botConfigMappings: ConfigMappingsType<BotConfig>;
+export declare function getBotConfigFromEnv(): BotConfig;
+export declare function getBotDefaultConfig(): BotConfig;
+export declare function getVersions(): Partial<ComponentsVersions>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,cAAc,wCAAyC,CAAC;AAC9D,KAAK,cAAc,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtD,oBAAY,uBAAuB;IACjC,aAAa,kBAAkB;IAC/B,wBAAwB,6BAA6B;CACtD;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,8EAA8E;IAC9E,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,gCAAgC;IAChC,SAAS,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAChC,gEAAgE;IAChE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,mEAAmE;IACnE,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,kDAAkD;IAClD,gBAAgB,EAAE,EAAE,GAAG,SAAS,CAAC;IACjC,iDAAiD;IACjD,yBAAyB,EAAE,EAAE,CAAC;IAC9B,8CAA8C;IAC9C,SAAS,EAAE,EAAE,CAAC;IACd,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,kCAAkC;IAClC,gBAAgB,EAAE,WAAW,CAAC;IAC9B,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,uEAAuE;IACvE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,WAAW,EAAE,cAAc,CAAC;IAC5B,gFAAgF;IAChF,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,sBAAsB,EAAE,OAAO,CAAC;IAChC,oEAAoE;IACpE,oBAAoB,EAAE,OAAO,CAAC;IAC9B,+EAA+E;IAC/E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,+EAA+E;IAC/E,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,4BAA4B;IAC5B,QAAQ,EAAE,uBAAuB,CAAC;IAClC,yEAAyE;IACzE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iDAAiD;IACjD,iBAAiB,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCK,CAAC;AAElC,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,SAAS,CAmI3D,CAAC;AAEF,wBAAgB,mBAAmB,IAAI,SAAS,CAE/C;AAED,wBAAgB,mBAAmB,IAAI,SAAS,CAE/C;AAED,wBAAgB,WAAW,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAKzD"}

package/dest/config.js

@@ -0,0 +1,191 @@
+import { booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper } from '@aztec/foundation/config';
+import { Fr } from '@aztec/foundation/fields';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { schemas } from '@aztec/stdlib/schemas';
+import { z } from 'zod';
+const BotFollowChain = [
+    'NONE',
+    'PENDING',
+    'PROVEN'
+];
+export var SupportedTokenContracts = /*#__PURE__*/ function(SupportedTokenContracts) {
+    SupportedTokenContracts["TokenContract"] = "TokenContract";
+    SupportedTokenContracts["EasyPrivateTokenContract"] = "EasyPrivateTokenContract";
+    return SupportedTokenContracts;
+}({});
+export const BotConfigSchema = z.object({
+    nodeUrl: z.string().optional(),
+    pxeUrl: z.string().optional(),
+    l1RpcUrls: z.array(z.string()).optional(),
+    l1Mnemonic: z.string().optional(),
+    l1PrivateKey: z.string().optional(),
+    senderPrivateKey: schemas.Fr.optional(),
+    recipientEncryptionSecret: schemas.Fr,
+    tokenSalt: schemas.Fr,
+    txIntervalSeconds: z.number(),
+    privateTransfersPerTx: z.number().int().nonnegative(),
+    publicTransfersPerTx: z.number().int().nonnegative(),
+    feePaymentMethod: z.literal('fee_juice'),
+    noStart: z.boolean(),
+    txMinedWaitSeconds: z.number(),
+    followChain: z.enum(BotFollowChain),
+    maxPendingTxs: z.number().int().nonnegative(),
+    flushSetupTransactions: z.boolean(),
+    skipPublicSimulation: z.boolean(),
+    l2GasLimit: z.number().int().nonnegative().optional(),
+    daGasLimit: z.number().int().nonnegative().optional(),
+    contract: z.nativeEnum(SupportedTokenContracts),
+    maxConsecutiveErrors: z.number().int().nonnegative(),
+    stopWhenUnhealthy: z.boolean()
+}).transform((config)=>({
+        nodeUrl: undefined,
+        pxeUrl: undefined,
+        l1RpcUrls: undefined,
+        l1Mnemonic: undefined,
+        l1PrivateKey: undefined,
+        senderPrivateKey: undefined,
+        l2GasLimit: undefined,
+        daGasLimit: undefined,
+        ...config
+    }));
+export const botConfigMappings = {
+    nodeUrl: {
+        env: 'AZTEC_NODE_URL',
+        description: 'The URL to the Aztec node to check for tx pool status.'
+    },
+    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.',
+        parseEnv: (val)=>val.split(',').map((url)=>url.trim())
+    },
+    l1Mnemonic: {
+        env: 'BOT_L1_MNEMONIC',
+        description: 'The mnemonic for the account to bridge fee juice from L1.'
+    },
+    l1PrivateKey: {
+        env: 'BOT_L1_PRIVATE_KEY',
+        description: 'The private key for the account to bridge fee juice from L1.'
+    },
+    senderPrivateKey: {
+        env: 'BOT_PRIVATE_KEY',
+        description: 'Signing private key for the sender account.',
+        parseEnv: (val)=>val ? Fr.fromHexString(val) : undefined
+    },
+    recipientEncryptionSecret: {
+        env: 'BOT_RECIPIENT_ENCRYPTION_SECRET',
+        description: 'Encryption secret for a recipient account.',
+        parseEnv: (val)=>Fr.fromHexString(val),
+        defaultValue: Fr.fromHexString('0xcafecafe')
+    },
+    tokenSalt: {
+        env: 'BOT_TOKEN_SALT',
+        description: 'Salt for the token contract deployment.',
+        parseEnv: (val)=>Fr.fromHexString(val),
+        defaultValue: Fr.fromHexString('1')
+    },
+    txIntervalSeconds: {
+        env: 'BOT_TX_INTERVAL_SECONDS',
+        description: 'Every how many seconds should a new tx be sent.',
+        ...numberConfigHelper(60)
+    },
+    privateTransfersPerTx: {
+        env: 'BOT_PRIVATE_TRANSFERS_PER_TX',
+        description: 'How many private token transfers are executed per tx.',
+        ...numberConfigHelper(1)
+    },
+    publicTransfersPerTx: {
+        env: 'BOT_PUBLIC_TRANSFERS_PER_TX',
+        description: 'How many public token transfers are executed per tx.',
+        ...numberConfigHelper(1)
+    },
+    feePaymentMethod: {
+        env: 'BOT_FEE_PAYMENT_METHOD',
+        description: 'How to handle fee payments. (Options: fee_juice)',
+        parseEnv: (val)=>val || undefined,
+        defaultValue: 'fee_juice'
+    },
+    noStart: {
+        env: 'BOT_NO_START',
+        description: 'True to not automatically setup or start the bot on initialization.',
+        ...booleanConfigHelper()
+    },
+    txMinedWaitSeconds: {
+        env: 'BOT_TX_MINED_WAIT_SECONDS',
+        description: 'How long to wait for a tx to be mined before reporting an error.',
+        ...numberConfigHelper(180)
+    },
+    followChain: {
+        env: 'BOT_FOLLOW_CHAIN',
+        description: 'Which chain the bot follows',
+        defaultValue: 'NONE',
+        parseEnv (val) {
+            if (!BotFollowChain.includes(val.toUpperCase())) {
+                throw new Error(`Invalid value for BOT_FOLLOW_CHAIN: ${val}`);
+            }
+            return val;
+        }
+    },
+    maxPendingTxs: {
+        env: 'BOT_MAX_PENDING_TXS',
+        description: "Do not send a tx if the node's tx pool already has this many pending txs.",
+        ...numberConfigHelper(128)
+    },
+    flushSetupTransactions: {
+        env: 'BOT_FLUSH_SETUP_TRANSACTIONS',
+        description: 'Make a request for the sequencer to build a block after each setup transaction.',
+        ...booleanConfigHelper(false)
+    },
+    skipPublicSimulation: {
+        env: 'BOT_SKIP_PUBLIC_SIMULATION',
+        description: 'Whether to skip public simulation of txs before sending them.',
+        ...booleanConfigHelper(false)
+    },
+    l2GasLimit: {
+        env: 'BOT_L2_GAS_LIMIT',
+        description: 'L2 gas limit for the tx (empty to have the bot trigger an estimate gas).',
+        ...optionalNumberConfigHelper()
+    },
+    daGasLimit: {
+        env: 'BOT_DA_GAS_LIMIT',
+        description: 'DA gas limit for the tx (empty to have the bot trigger an estimate gas).',
+        ...optionalNumberConfigHelper()
+    },
+    contract: {
+        env: 'BOT_TOKEN_CONTRACT',
+        description: 'Token contract to use',
+        defaultValue: "TokenContract",
+        parseEnv (val) {
+            if (!Object.values(SupportedTokenContracts).includes(val)) {
+                throw new Error(`Invalid value for BOT_TOKEN_CONTRACT: ${val}. Valid values: ${Object.values(SupportedTokenContracts).join(', ')}`);
+            }
+            return val;
+        }
+    },
+    maxConsecutiveErrors: {
+        env: 'BOT_MAX_CONSECUTIVE_ERRORS',
+        description: 'The maximum number of consecutive errors before the bot shuts down',
+        ...numberConfigHelper(0)
+    },
+    stopWhenUnhealthy: {
+        env: 'BOT_STOP_WHEN_UNHEALTHY',
+        description: 'Stops the bot if service becomes unhealthy',
+        ...booleanConfigHelper(false)
+    }
+};
+export function getBotConfigFromEnv() {
+    return getConfigFromMappings(botConfigMappings);
+}
+export function getBotDefaultConfig() {
+    return getDefaultConfig(botConfigMappings);
+}
+export function getVersions() {
+    return {
+        l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+        l2CircuitsVkTreeRoot: getVKTreeRoot().toString()
+    };
+}

package/dest/factory.d.ts

@@ -0,0 +1,50 @@
+import { AztecAddress, type AztecNode, type PXE } from '@aztec/aztec.js';
+import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { type BotConfig } from './config.js';
+export declare class BotFactory {
+    private readonly config;
+    private pxe;
+    private node?;
+    private log;
+    constructor(config: BotConfig, dependencies?: {
+        pxe?: PXE;
+        node?: AztecNode;
+    });
+    /**
+     * 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;
+        token: TokenContract | EasyPrivateTokenContract;
+        pxe: PXE;
+        recipient: AztecAddress;
+    }>;
+    /**
+     * 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;
+    /**
+     * Mints private and public tokens for the sender if their balance is below the minimum.
+     * @param token - Token contract.
+     */
+    private mintTokens;
+    private bridgeL1FeeJuice;
+    private advanceL2Block;
+    private tryFlushTxs;
+}
+//# sourceMappingURL=factory.d.ts.map

package/dest/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,YAAY,EACZ,KAAK,SAAS,EAMd,KAAK,GAAG,EAIT,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAK/D,OAAO,EAAE,KAAK,SAAS,EAAwC,MAAM,aAAa,CAAC;AAMnF,qBAAa,UAAU;IAKT,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJnC,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,IAAI,CAAC,CAAY;IACzB,OAAO,CAAC,GAAG,CAAuB;gBAEL,MAAM,EAAE,SAAS,EAAE,YAAY,GAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAO;IAwBlG;;;OAGG;IACU,KAAK;;;;;;IAQlB;;;OAGG;YACW,YAAY;YAQZ,0BAA0B;YA4B1B,gBAAgB;IAc9B;;OAEG;YACW,iBAAiB;IAK/B;;;;OAIG;YACW,UAAU;IA8BxB;;;OAGG;YACW,UAAU;YAuCV,gBAAgB;YA+BhB,cAAc;YAMd,WAAW;CAU1B"}