@aztec/bot 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/factory.js

@@ -1,229 +1,374 @@
-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 { 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 { createLogger } from '@aztec/aztec.js/log';
+import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
 import { Fr } from '@aztec/foundation/fields';
-import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+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;
+    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.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);
+        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 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: this.wallet,
+            defaultAccountAddress,
+            amm,
+            token0,
+            token1,
+            node: this.aztecNode
+        };
+    }
     /**
    * 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);
+        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) {
-        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;
+    async setupAccountWithPrivateKey(secret) {
+        const salt = this.config.senderSalt ?? Fr.ONE;
+        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`);
-            const wallet = await account.register();
-            return wallet;
+            this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
+            const timer = new Timer();
+            const address = accountManager.address;
+            this.log.info(`Account at ${address} registered. duration=${timer.ms()}`);
+            await this.store.deleteBridgeClaim(address);
+            return address;
         } else {
-            const address = account.getAddress();
+            const address = accountManager.address;
             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({
+            const claim = await this.getOrCreateBridgeClaim(address);
+            const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
+            const deployMethod = await accountManager.getDeployMethod();
+            const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.config.baseFeePadding);
+            const gasSettings = GasSettings.default({
+                maxFeesPerGas
+            });
+            const sentTx = deployMethod.send({
+                from: AztecAddress.ZERO,
                 fee: {
+                    gasSettings,
                     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(`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, 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) {
+   */ async setupToken(sender) {
         let deploy;
         const deployOpts = {
+            from: sender,
             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;
+            deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
+        } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
+            deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender);
+            deployOpts.skipInstancePublication = true;
+            deployOpts.skipClassPublication = 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) {
+        if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
             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
-            });
+            this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
+            return this.withNoMinTxsPerBlock(()=>sentTx.deployed({
+                    timeout: this.config.txMinedWaitSeconds
+                }));
+        }
+    }
+    /**
+   * 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(deployer, contractAddressSalt, name, ticker, decimals = 18) {
+        const deployOpts = {
+            from: deployer,
+            contractAddressSalt,
+            universalDeploy: true
+        };
+        const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
+        return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+    }
+    async setupAmmContract(deployer, contractAddressSalt, token0, token1, lpToken) {
+        const deployOpts = {
+            from: deployer,
+            contractAddressSalt,
+            universalDeploy: true
+        };
+        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({
+            from: deployer
+        });
+        this.log.info(`Set LP token minter to AMM txHash=${(await minterTx.getTxHash()).toString()}`);
+        await minterTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+        this.log.info(`Liquidity token initialized`);
+        return amm;
+    }
+    async fundAmm(defaultAccountAddress, liquidityProvider, amm, token0, token1, lpToken) {
+        const getPrivateBalances = ()=>Promise.all([
+                token0.methods.balance_of_private(liquidityProvider).simulate({
+                    from: liquidityProvider
+                }),
+                token1.methods.balance_of_private(liquidityProvider).simulate({
+                    from: liquidityProvider
+                }),
+                lpToken.methods.balance_of_private(liquidityProvider).simulate({
+                    from: liquidityProvider
+                })
+            ]);
+        const authwitNonce = Fr.random();
+        // keep some tokens for swapping
+        const amount0Max = MINT_BALANCE / 2;
+        const amount0Min = MINT_BALANCE / 4;
+        const amount1Max = MINT_BALANCE / 2;
+        const amount1Min = MINT_BALANCE / 4;
+        const [t0Bal, t1Bal, lpBal] = await getPrivateBalances();
+        this.log.info(`Minting ${MINT_BALANCE} tokens of each BotToken0 and BotToken1. Current private balances of ${liquidityProvider}: token0=${t0Bal}, token1=${t1Bal}, lp=${lpBal}`);
+        // Add authwitnesses for the transfers in AMM::add_liquidity function
+        const token0Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
+            caller: amm.address,
+            call: await token0.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount0Max, authwitNonce).getFunctionCall()
+        });
+        const token1Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
+            caller: amm.address,
+            call: await token1.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount1Max, authwitNonce).getFunctionCall()
+        });
+        const mintTx = new BatchCall(this.wallet, [
+            token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
+            token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE)
+        ]).send({
+            from: liquidityProvider
+        });
+        this.log.info(`Sent mint tx: ${(await mintTx.getTxHash()).toString()}`);
+        await mintTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+        const addLiquidityTx = amm.methods.add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce).send({
+            from: liquidityProvider,
+            authWitnesses: [
+                token0Authwit,
+                token1Authwit
+            ]
+        });
+        this.log.info(`Sent tx to add liquidity to the AMM: ${(await addLiquidityTx.getTxHash()).toString()}`);
+        await addLiquidityTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+        this.log.info(`Liquidity added`);
+        const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
+        this.log.info(`Updated private balances of ${defaultAccountAddress} after minting and funding AMM: token0=${newT0Bal}, token1=${newT1Bal}, lp=${newLPBal}`);
+    }
+    async registerOrDeployContract(name, deploy, deployOpts) {
+        const address = (await deploy.getInstance(deployOpts)).address;
+        if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
+            this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
+            return deploy.register();
+        } else {
+            this.log.info(`Deploying contract ${name} at ${address.toString()}`);
+            const sentTx = deploy.send(deployOpts);
+            const txHash = await sentTx.getTxHash();
+            this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
+            return this.withNoMinTxsPerBlock(()=>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();
+   */ async mintTokens(token, minter) {
         const isStandardToken = isStandardTokenContract(token);
         let privateBalance = 0n;
         let publicBalance = 0n;
         if (isStandardToken) {
-            ({ privateBalance, publicBalance } = await getBalances(token, sender));
+            ({ privateBalance, publicBalance } = await getBalances(token, minter));
         } else {
-            privateBalance = await getPrivateBalance(token, sender);
+            privateBalance = await getPrivateBalance(token, minter);
         }
         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());
+            this.log.info(`Minting private tokens for ${minter.toString()}`);
+            calls.push(isStandardToken ? token.methods.mint_to_private(minter, MINT_BALANCE) : token.methods.mint(MINT_BALANCE, minter));
         }
         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());
+            this.log.info(`Minting public tokens for ${minter.toString()}`);
+            calls.push(token.methods.mint_to_public(minter, MINT_BALANCE));
         }
         if (calls.length === 0) {
-            this.log.info(`Skipping minting as ${sender.toString()} has enough tokens`);
+            this.log.info(`Skipping minting as ${minter.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
+        const sentTx = new BatchCall(token.wallet, calls).send({
+            from: minter
         });
+        const txHash = await sentTx.getTxHash();
+        this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
+        await this.withNoMinTxsPerBlock(()=>sentTx.wait({
+                timeout: this.config.txMinedWaitSeconds
+            }));
     }
-    async bridgeL1FeeJuice(recipient, amount) {
+    /**
+   * 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) {
             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;
+        const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
         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 { 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();
+        const extendedClient = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+        const portal = await L1FeeJuicePortalManager.new(this.aztecNode, extendedClient, this.log);
+        const mintAmount = await portal.getTokenManager().getMintAmount();
+        const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true);
+        await this.withNoMinTxsPerBlock(()=>waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
+                timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+                forPublicConsumption: false
+            }));
+        this.log.info(`Created a claim for ${mintAmount} L1 fee juice to ${recipient}.`, claim);
         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}`);
-            }
+    async withNoMinTxsPerBlock(fn) {
+        if (!this.aztecNodeAdmin || !this.config.flushSetupTransactions) {
+            this.log.verbose(`No node admin client or flushing not requested (not setting minTxsPerBlock to 0)`);
+            return fn();
+        }
+        const { minTxsPerBlock } = await this.aztecNodeAdmin.getConfig();
+        this.log.warn(`Setting sequencer minTxsPerBlock to 0 from ${minTxsPerBlock} to flush setup transactions`);
+        await this.aztecNodeAdmin.setConfig({
+            minTxsPerBlock: 0
+        });
+        try {
+            return await fn();
+        } finally{
+            this.log.warn(`Restoring sequencer minTxsPerBlock to ${minTxsPerBlock}`);
+            await this.aztecNodeAdmin.setConfig({
+                minTxsPerBlock
+            });
         }
     }
 }

package/dest/index.d.ts

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

package/dest/index.d.ts.map

@@ -1 +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"}
+{"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,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EACL,KAAK,SAAS,EACd,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAClD,cAAc,gBAAgB,CAAC"}

package/dest/index.js

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

package/dest/interface.d.ts

@@ -1,11 +1,22 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
+import { z } from 'zod';
 import { type BotConfig } from './config.js';
+export declare const BotInfoSchema: z.ZodObject<{
+    botAddress: import("@aztec/stdlib/schemas").ZodFor<AztecAddress>;
+}, "strip", z.ZodTypeAny, {
+    botAddress: AztecAddress;
+}, {
+    botAddress?: any;
+}>;
+export type BotInfo = z.infer<typeof BotInfoSchema>;
 export interface BotRunnerApi {
     start(): Promise<void>;
     stop(): Promise<void>;
     run(): Promise<void>;
     setup(): Promise<void>;
     getConfig(): Promise<BotConfig>;
+    getInfo(): Promise<BotInfo>;
     update(config: BotConfig): Promise<void>;
 }
 export declare const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi>;

package/dest/interface.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,aAAa,CAAC;AAE9D,eAAO,MAAM,aAAa;;;;;;EAExB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,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,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5B,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,YAAY,CAQzD,CAAC"}

package/dest/interface.js

@@ -1,10 +1,15 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { z } from 'zod';
 import { BotConfigSchema } from './config.js';
+export const BotInfoSchema = z.object({
+    botAddress: AztecAddress.schema
+});
 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()),
+    getInfo: z.function().args().returns(BotInfoSchema),
     getConfig: z.function().args().returns(BotConfigSchema),
     update: z.function().args(BotConfigSchema).returns(z.void())
 };

package/dest/rpc.d.ts

@@ -1,10 +1,4 @@
 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

@@ -1 +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"}
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU,CAEvE"}

package/dest/rpc.js

@@ -1,15 +1,4 @@
-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,