@aztec/bot 0.0.0-test.0

package/dest/factory.js

@@ -0,0 +1,229 @@
+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, createL1Clients } from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+import { SupportedTokenContracts, getVersions } from './config.js';
+import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
+const MINT_BALANCE = 1e12;
+const MIN_BALANCE = 1e3;
+export class BotFactory {
+    config;
+    pxe;
+    node;
+    log;
+    constructor(config, dependencies = {}){
+        this.config = config;
+        this.log = createLogger('bot');
+        if (config.flushSetupTransactions && !dependencies.node) {
+            throw new Error(`Either a node client or node url must be provided if transaction flushing is requested`);
+        }
+        if (config.senderPrivateKey && !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;
+        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 token = await this.setupToken(wallet);
+        await this.mintTokens(token);
+        return {
+            wallet,
+            token,
+            pxe: this.pxe,
+            recipient
+        };
+    }
+    /**
+   * Checks if the sender account contract is initialized, and initializes it if necessary.
+   * @returns The sender wallet.
+   */ async setupAccount() {
+        if (this.config.senderPrivateKey) {
+            return await this.setupAccountWithPrivateKey(this.config.senderPrivateKey);
+        } else {
+            return await this.setupTestAccount();
+        }
+    }
+    async setupAccountWithPrivateKey(privateKey) {
+        const salt = Fr.ONE;
+        const signingKey = deriveSigningKey(privateKey);
+        const account = await getSchnorrAccount(this.pxe, privateKey, signingKey, salt);
+        const isInit = (await this.pxe.getContractMetadata(account.getAddress())).isContractInitialized;
+        if (isInit) {
+            this.log.info(`Account at ${account.getAddress().toString()} already initialized`);
+            const wallet = await account.register();
+            return wallet;
+        } else {
+            const address = account.getAddress();
+            this.log.info(`Deploying account at ${address}`);
+            const claim = await this.bridgeL1FeeJuice(address, 10n ** 22n);
+            const wallet = await account.getWallet();
+            const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claim);
+            const sentTx = account.deploy({
+                fee: {
+                    paymentMethod
+                }
+            });
+            const txHash = await sentTx.getTxHash();
+            this.log.info(`Sent tx with hash ${txHash.toString()}`);
+            await this.tryFlushTxs();
+            this.log.verbose('Waiting for account deployment to settle');
+            await sentTx.wait({
+                timeout: this.config.txMinedWaitSeconds
+            });
+            this.log.info(`Account deployed at ${address}`);
+            return wallet;
+        }
+    }
+    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, Fr.ONE);
+        return recipient.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) {
+        let deploy;
+        const deployOpts = {
+            contractAddressSalt: this.config.tokenSalt,
+            universalDeploy: true
+        };
+        if (this.config.contract === SupportedTokenContracts.TokenContract) {
+            deploy = TokenContract.deploy(wallet, wallet.getAddress(), 'BotToken', 'BOT', 18);
+        } else if (this.config.contract === SupportedTokenContracts.EasyPrivateTokenContract) {
+            deploy = EasyPrivateTokenContract.deploy(wallet, MINT_BALANCE, wallet.getAddress());
+            deployOpts.skipPublicDeployment = true;
+            deployOpts.skipClassRegistration = true;
+            deployOpts.skipInitialization = false;
+            deployOpts.skipPublicSimulation = true;
+        } else {
+            throw new Error(`Unsupported token contract type: ${this.config.contract}`);
+        }
+        const address = (await deploy.getInstance(deployOpts)).address;
+        if ((await this.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
+            this.log.info(`Token at ${address.toString()} already deployed`);
+            return deploy.register();
+        } else {
+            this.log.info(`Deploying token contract at ${address.toString()}`);
+            const sentTx = deploy.send(deployOpts);
+            const txHash = await sentTx.getTxHash();
+            this.log.info(`Sent tx with hash ${txHash.toString()}`);
+            await this.tryFlushTxs();
+            this.log.verbose('Waiting for token setup to settle');
+            return sentTx.deployed({
+                timeout: this.config.txMinedWaitSeconds
+            });
+        }
+    }
+    /**
+   * Mints private and public tokens for the sender if their balance is below the minimum.
+   * @param token - Token contract.
+   */ async mintTokens(token) {
+        const sender = token.wallet.getAddress();
+        const isStandardToken = isStandardTokenContract(token);
+        let privateBalance = 0n;
+        let publicBalance = 0n;
+        if (isStandardToken) {
+            ({ privateBalance, publicBalance } = await getBalances(token, sender));
+        } else {
+            privateBalance = await getPrivateBalance(token, sender);
+        }
+        const calls = [];
+        if (privateBalance < MIN_BALANCE) {
+            this.log.info(`Minting private tokens for ${sender.toString()}`);
+            const from = sender; // we are setting from to sender here because we need a sender to calculate the tag
+            calls.push(isStandardToken ? await token.methods.mint_to_private(from, sender, MINT_BALANCE).request() : await token.methods.mint(MINT_BALANCE, sender).request());
+        }
+        if (isStandardToken && publicBalance < MIN_BALANCE) {
+            this.log.info(`Minting public tokens for ${sender.toString()}`);
+            calls.push(await token.methods.mint_to_public(sender, MINT_BALANCE).request());
+        }
+        if (calls.length === 0) {
+            this.log.info(`Skipping minting as ${sender.toString()} has enough tokens`);
+            return;
+        }
+        const sentTx = new BatchCall(token.wallet, calls).send();
+        const txHash = await sentTx.getTxHash();
+        this.log.info(`Sent tx with hash ${txHash.toString()}`);
+        await this.tryFlushTxs();
+        this.log.verbose('Waiting for token mint to settle');
+        await sentTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+    }
+    async bridgeL1FeeJuice(recipient, amount) {
+        const l1RpcUrls = this.config.l1RpcUrls;
+        if (!l1RpcUrls?.length) {
+            throw new Error('L1 Rpc url is required to bridge the fee juice to fund the deployment of the account.');
+        }
+        const mnemonicOrPrivateKey = this.config.l1PrivateKey || this.config.l1Mnemonic;
+        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 chain = createEthereumChain(l1RpcUrls, l1ChainId);
+        const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+        const portal = await L1FeeJuicePortalManager.new(this.pxe, publicClient, walletClient, this.log);
+        const claim = await portal.bridgeTokensPublic(recipient, amount, true);
+        const isSynced = async ()=>await this.pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
+        await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
+        this.log.info(`Created a claim for ${amount} 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 advanceL2Block() {
+        const initialBlockNumber = await this.node.getBlockNumber();
+        await this.tryFlushTxs();
+        await retryUntil(async ()=>await this.node.getBlockNumber() >= initialBlockNumber + 1);
+    }
+    async tryFlushTxs() {
+        if (this.config.flushSetupTransactions) {
+            this.log.verbose('Flushing transactions');
+            try {
+                await this.node.flushTxs();
+            } catch (err) {
+                this.log.error(`Failed to flush transactions: ${err}`);
+            }
+        }
+    }
+}

package/dest/index.d.ts

@@ -0,0 +1,6 @@
+export { Bot } from './bot.js';
+export { BotRunner } from './runner.js';
+export { type BotConfig, getBotConfigFromEnv, getBotDefaultConfig, botConfigMappings, SupportedTokenContracts, } from './config.js';
+export { createBotRunnerRpcServer, getBotRunnerApiHandler } from './rpc.js';
+export * from './interface.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EACL,KAAK,SAAS,EACd,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAC5E,cAAc,gBAAgB,CAAC"}

package/dest/index.js

@@ -0,0 +1,5 @@
+export { Bot } from './bot.js';
+export { BotRunner } from './runner.js';
+export { getBotConfigFromEnv, getBotDefaultConfig, botConfigMappings, SupportedTokenContracts } from './config.js';
+export { createBotRunnerRpcServer, getBotRunnerApiHandler } from './rpc.js';
+export * from './interface.js';

package/dest/interface.d.ts

@@ -0,0 +1,12 @@
+import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
+import { type BotConfig } from './config.js';
+export interface BotRunnerApi {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    run(): Promise<void>;
+    setup(): Promise<void>;
+    getConfig(): Promise<BotConfig>;
+    update(config: BotConfig): Promise<void>;
+}
+export declare const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi>;
+//# sourceMappingURL=interface.d.ts.map

package/dest/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,aAAa,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,YAAY,CAOzD,CAAC"}

package/dest/interface.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { BotConfigSchema } from './config.js';
+export const BotRunnerApiSchema = {
+    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()),
+    getConfig: z.function().args().returns(BotConfigSchema),
+    update: z.function().args(BotConfigSchema).returns(z.void())
+};

package/dest/rpc.d.ts

@@ -0,0 +1,10 @@
+import type { ApiHandler } from '@aztec/foundation/json-rpc/server';
+import type { BotRunner } from './runner.js';
+/**
+ * Wraps a bot runner with a JSON RPC HTTP server.
+ * @param botRunner - The BotRunner.
+ * @returns An JSON-RPC HTTP server
+ */
+export declare function createBotRunnerRpcServer(botRunner: BotRunner): void;
+export declare function getBotRunnerApiHandler(botRunner: BotRunner): ApiHandler;
+//# sourceMappingURL=rpc.d.ts.map

package/dest/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAIpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,QAK5D;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU,CAEvE"}

package/dest/rpc.js

@@ -0,0 +1,19 @@
+import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
+import { BotRunnerApiSchema } from './interface.js';
+/**
+ * Wraps a bot runner with a JSON RPC HTTP server.
+ * @param botRunner - The BotRunner.
+ * @returns An JSON-RPC HTTP server
+ */ export function createBotRunnerRpcServer(botRunner) {
+    createTracedJsonRpcServer(botRunner, BotRunnerApiSchema, {
+        http200OnError: false,
+        healthCheck: botRunner.isHealthy.bind(botRunner)
+    });
+}
+export function getBotRunnerApiHandler(botRunner) {
+    return [
+        botRunner,
+        BotRunnerApiSchema,
+        botRunner.isHealthy.bind(botRunner)
+    ];
+}

package/dest/runner.d.ts

@@ -0,0 +1,49 @@
+import { type AztecNode, type PXE } from '@aztec/aztec.js';
+import { type TelemetryClient, type Traceable, type Tracer } from '@aztec/telemetry-client';
+import { type BotConfig } from './config.js';
+import type { BotRunnerApi } from './interface.js';
+export declare class BotRunner implements BotRunnerApi, Traceable {
+    #private;
+    private config;
+    private log;
+    private bot?;
+    private pxe?;
+    private node;
+    private runningPromise;
+    private consecutiveErrors;
+    private healthy;
+    readonly tracer: Tracer;
+    constructor(config: BotConfig, dependencies: {
+        pxe?: PXE;
+        node?: AztecNode;
+        telemetry: TelemetryClient;
+    });
+    /** Initializes the bot if needed. Blocks until the bot setup is finished. */
+    setup(): Promise<void>;
+    private doSetup;
+    /**
+     * Initializes the bot if needed and starts sending txs at regular intervals.
+     * Blocks until the bot setup is finished.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops sending txs. Returns once all ongoing txs are finished.
+     */
+    stop(): Promise<void>;
+    isHealthy(): boolean;
+    /** Returns whether the bot is running. */
+    isRunning(): boolean;
+    /**
+     * Updates the bot config and recreates the bot. Will stop and restart the bot automatically if it was
+     * running when this method was called. Blocks until the new bot is set up.
+     */
+    update(config: BotConfig): Promise<void>;
+    /**
+     * Triggers a single iteration of the bot. Requires the bot to be initialized.
+     * Blocks until the run is finished.
+     */
+    run(): Promise<void>;
+    /** Returns the current configuration for the bot. */
+    getConfig(): Promise<BotConfig>;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dest/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,GAAG,EAAuC,MAAM,iBAAiB,CAAC;AAEhG,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAA8B,MAAM,yBAAyB,CAAC;AAGxH,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,qBAAa,SAAU,YAAW,YAAY,EAAE,SAAS;;IAYrD,OAAO,CAAC,MAAM;IAXhB,OAAO,CAAC,GAAG,CAAuB;IAClC,OAAO,CAAC,GAAG,CAAC,CAAe;IAC3B,OAAO,CAAC,GAAG,CAAC,CAAM;IAClB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,OAAO,CAAQ;IAEvB,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAGrB,MAAM,EAAE,SAAS,EACzB,YAAY,EAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,SAAS,EAAE,eAAe,CAAA;KAAE;IAY3E,6EAA6E;IAChE,KAAK;YAOJ,OAAO;IAMrB;;;OAGG;IACU,KAAK;IAQlB;;OAEG;IACU,IAAI;IAQV,SAAS;IAIhB,0CAA0C;IACnC,SAAS;IAIhB;;;OAGG;IACU,MAAM,CAAC,MAAM,EAAE,SAAS;IAerC;;;OAGG;IACU,GAAG;IAwBhB,qDAAqD;IAC9C,SAAS;CAuCjB"}

package/dest/runner.js

@@ -0,0 +1,158 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createAztecNodeClient, createLogger } from '@aztec/aztec.js';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { makeTracedFetch, trackSpan } from '@aztec/telemetry-client';
+import { Bot } from './bot.js';
+import { getVersions } from './config.js';
+export class BotRunner {
+    config;
+    log;
+    bot;
+    pxe;
+    node;
+    runningPromise;
+    consecutiveErrors;
+    healthy;
+    tracer;
+    constructor(config, dependencies){
+        this.config = config;
+        this.log = createLogger('bot');
+        this.consecutiveErrors = 0;
+        this.healthy = true;
+        this.tracer = dependencies.telemetry.getTracer('Bot');
+        this.pxe = dependencies.pxe;
+        if (!dependencies.node && !config.nodeUrl) {
+            throw new Error(`Missing node URL in config or dependencies`);
+        }
+        this.node = dependencies.node ?? createAztecNodeClient(config.nodeUrl, getVersions(), makeTracedFetch([
+            1,
+            2,
+            3
+        ], true));
+        this.runningPromise = new RunningPromise(()=>this.#work(), this.log, config.txIntervalSeconds * 1000);
+    }
+    /** Initializes the bot if needed. Blocks until the bot setup is finished. */ async setup() {
+        if (!this.bot) {
+            await this.doSetup();
+        }
+    }
+    async doSetup() {
+        this.log.verbose(`Setting up bot`);
+        await this.#createBot();
+        this.log.info(`Bot set up completed`);
+    }
+    /**
+   * Initializes the bot if needed and starts sending txs at regular intervals.
+   * Blocks until the bot setup is finished.
+   */ async start() {
+        await this.setup();
+        if (!this.runningPromise.isRunning()) {
+            this.log.info(`Starting bot with interval of ${this.config.txIntervalSeconds}s`);
+            this.runningPromise.start();
+        }
+    }
+    /**
+   * Stops sending txs. Returns once all ongoing txs are finished.
+   */ async stop() {
+        if (this.runningPromise.isRunning()) {
+            this.log.verbose(`Stopping bot`);
+            await this.runningPromise.stop();
+        }
+        this.log.info(`Stopped bot`);
+    }
+    isHealthy() {
+        return this.runningPromise.isRunning() && this.healthy;
+    }
+    /** Returns whether the bot is running. */ isRunning() {
+        return this.runningPromise.isRunning();
+    }
+    /**
+   * Updates the bot config and recreates the bot. Will stop and restart the bot automatically if it was
+   * running when this method was called. Blocks until the new bot is set up.
+   */ async update(config) {
+        this.log.verbose(`Updating bot config`);
+        const wasRunning = this.isRunning();
+        if (wasRunning) {
+            await this.stop();
+        }
+        this.config = {
+            ...this.config,
+            ...config
+        };
+        this.runningPromise.setPollingIntervalMS(this.config.txIntervalSeconds * 1000);
+        await this.#createBot();
+        this.log.info(`Bot config updated`);
+        if (wasRunning) {
+            await this.start();
+        }
+    }
+    /**
+   * Triggers a single iteration of the bot. Requires the bot to be initialized.
+   * Blocks until the run is finished.
+   */ async run() {
+        if (!this.bot) {
+            this.log.error(`Trying to run with uninitialized bot`);
+            throw new Error(`Bot is not initialized`);
+        }
+        let bot;
+        try {
+            bot = await this.bot;
+        } catch (err) {
+            this.log.error(`Error awaiting bot set up: ${err}`);
+            throw err;
+        }
+        try {
+            await bot.run();
+            this.consecutiveErrors = 0;
+        } catch (err) {
+            this.consecutiveErrors += 1;
+            this.log.error(`Error running bot consecutiveCount=${this.consecutiveErrors}: ${err}`);
+            throw err;
+        }
+    }
+    /** Returns the current configuration for the bot. */ getConfig() {
+        return Promise.resolve(this.config);
+    }
+    async #createBot() {
+        try {
+            this.bot = Bot.create(this.config, {
+                pxe: this.pxe,
+                node: this.node
+            });
+            await this.bot;
+        } catch (err) {
+            this.log.error(`Error setting up bot: ${err}`);
+            throw err;
+        }
+    }
+    async #work() {
+        if (this.config.maxPendingTxs > 0) {
+            const pendingTxs = await this.node.getPendingTxs();
+            if (pendingTxs.length >= this.config.maxPendingTxs) {
+                this.log.verbose(`Not sending bot tx since node has ${pendingTxs.length} pending txs`);
+                return;
+            }
+        }
+        try {
+            await this.run();
+        } catch (err) {
+            // Already logged in run()
+            if (this.config.maxConsecutiveErrors > 0 && this.consecutiveErrors >= this.config.maxConsecutiveErrors) {
+                this.log.error(`Too many errors bot is unhealthy`);
+                this.healthy = false;
+            }
+        }
+        if (!this.healthy && this.config.stopWhenUnhealthy) {
+            this.log.fatal(`Stopping bot due to errors`);
+            process.exit(1); // workaround docker not restarting the container if its unhealthy. We have to exit instead
+        }
+    }
+}
+_ts_decorate([
+    trackSpan('Bot.setup')
+], BotRunner.prototype, "doSetup", null);

package/dest/utils.d.ts

@@ -0,0 +1,16 @@
+import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import type { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Gets the private and public balance of the given token for the given address.
+ * @param token - Token contract.
+ * @param who - Address to get the balance for.
+ * @returns - Private and public token balances as bigints.
+ */
+export declare function getBalances(token: TokenContract, who: AztecAddress): Promise<{
+    privateBalance: bigint;
+    publicBalance: bigint;
+}>;
+export declare function getPrivateBalance(token: EasyPrivateTokenContract, who: AztecAddress): Promise<bigint>;
+export declare function isStandardTokenContract(token: TokenContract | EasyPrivateTokenContract): token is TokenContract;
+//# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,YAAY,GAChB,OAAO,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAI5D;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,wBAAwB,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAG3G;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa,GAAG,wBAAwB,GAAG,KAAK,IAAI,aAAa,CAE/G"}

package/dest/utils.js

@@ -0,0 +1,20 @@
+/**
+ * Gets the private and public balance of the given token for the given address.
+ * @param token - Token contract.
+ * @param who - Address to get the balance for.
+ * @returns - Private and public token balances as bigints.
+ */ export async function getBalances(token, who) {
+    const privateBalance = await token.methods.balance_of_private(who).simulate();
+    const publicBalance = await token.methods.balance_of_public(who).simulate();
+    return {
+        privateBalance,
+        publicBalance
+    };
+}
+export async function getPrivateBalance(token, who) {
+    const privateBalance = await token.methods.get_balance(who).simulate();
+    return privateBalance;
+}
+export function isStandardTokenContract(token) {
+    return 'mint_to_public' in token.methods;
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@aztec/bot",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./config": "./dest/config.js"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "bb": "node --no-warnings ./dest/bb/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/accounts": "0.0.0-test.0",
+    "@aztec/aztec.js": "0.0.0-test.0",
+    "@aztec/entrypoints": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/telemetry-client": "0.0.0-test.0",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/memdown": "^3.0.0",
+    "@types/node": "^18.7.23",
+    "@types/source-map-support": "^0.5.10",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}