@aztec/bot 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/config.js

@@ -1,4 +1,4 @@
-import { booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper } from '@aztec/foundation/config';
+import { booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper, secretFrConfigHelper, secretStringConfigHelper } 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';
@@ -11,17 +11,20 @@ const BotFollowChain = [
 ];
 export var SupportedTokenContracts = /*#__PURE__*/ function(SupportedTokenContracts) {
     SupportedTokenContracts["TokenContract"] = "TokenContract";
-    SupportedTokenContracts["EasyPrivateTokenContract"] = "EasyPrivateTokenContract";
+    SupportedTokenContracts["PrivateTokenContract"] = "PrivateTokenContract";
     return SupportedTokenContracts;
 }({});
 export const BotConfigSchema = z.object({
     nodeUrl: z.string().optional(),
+    nodeAdminUrl: 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,
+    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(),
@@ -32,21 +35,23 @@ export const BotConfigSchema = z.object({
     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()
+    stopWhenUnhealthy: z.boolean(),
+    ammTxs: z.boolean().default(false)
 }).transform((config)=>({
         nodeUrl: undefined,
+        nodeAdminUrl: undefined,
         pxeUrl: undefined,
         l1RpcUrls: undefined,
+        senderSalt: undefined,
+        l2GasLimit: undefined,
+        daGasLimit: undefined,
         l1Mnemonic: undefined,
         l1PrivateKey: undefined,
         senderPrivateKey: undefined,
-        l2GasLimit: undefined,
-        daGasLimit: undefined,
         ...config
     }));
 export const botConfigMappings = {
@@ -54,6 +59,10 @@ export const botConfigMappings = {
         env: 'AZTEC_NODE_URL',
         description: 'The URL to the Aztec node to check for tx pool status.'
     },
+    nodeAdminUrl: {
+        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.'
@@ -65,22 +74,34 @@ export const botConfigMappings = {
     },
     l1Mnemonic: {
         env: 'BOT_L1_MNEMONIC',
-        description: 'The mnemonic for the account to bridge fee juice from L1.'
+        description: 'The mnemonic for the account to bridge fee juice from L1.',
+        ...secretStringConfigHelper()
     },
     l1PrivateKey: {
         env: 'BOT_L1_PRIVATE_KEY',
-        description: 'The private key for the account to bridge fee juice from L1.'
+        description: 'The private key for the account to bridge fee juice from L1.',
+        ...secretStringConfigHelper()
+    },
+    l1ToL2MessageTimeoutSeconds: {
+        env: 'BOT_L1_TO_L2_TIMEOUT_SECONDS',
+        description: 'How long to wait for L1 to L2 messages to become available on L2',
+        ...numberConfigHelper(3600)
     },
     senderPrivateKey: {
         env: 'BOT_PRIVATE_KEY',
         description: 'Signing private key for the sender account.',
+        ...secretFrConfigHelper()
+    },
+    senderSalt: {
+        env: 'BOT_ACCOUNT_SALT',
+        description: 'The salt to use to deploys 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')
+        printDefault: (sv)=>sv?.getValue(),
+        ...secretFrConfigHelper(Fr.fromHexString('0xcafecafe'))
     },
     tokenSalt: {
         env: 'BOT_TOKEN_SALT',
@@ -140,11 +161,6 @@ export const botConfigMappings = {
         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).',
@@ -175,6 +191,11 @@ export const botConfigMappings = {
         env: 'BOT_STOP_WHEN_UNHEALTHY',
         description: 'Stops the bot if service becomes unhealthy',
         ...booleanConfigHelper(false)
+    },
+    ammTxs: {
+        env: 'BOT_AMM_TXS',
+        description: 'Deploy an AMM and send swaps to it',
+        ...booleanConfigHelper(false)
     }
 };
 export function getBotConfigFromEnv() {

package/dest/factory.d.ts

@@ -1,14 +1,18 @@
-import { AztecAddress, type AztecNode, type PXE } from '@aztec/aztec.js';
-import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import { AztecAddress, type PXE } from '@aztec/aztec.js';
+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 { type BotConfig } from './config.js';
 export declare class BotFactory {
     private readonly config;
     private pxe;
     private node?;
+    private nodeAdmin?;
     private log;
-    constructor(config: BotConfig, dependencies?: {
+    constructor(config: BotConfig, dependencies: {
         pxe?: PXE;
+        nodeAdmin?: AztecNodeAdmin;
         node?: AztecNode;
     });
     /**
@@ -17,10 +21,19 @@ export declare class BotFactory {
      */
     setup(): Promise<{
         wallet: import("@aztec/aztec.js").AccountWalletWithSecretKey;
-        token: TokenContract | EasyPrivateTokenContract;
+        defaultAccountAddress: AztecAddress;
+        token: TokenContract | PrivateTokenContract;
         pxe: PXE;
         recipient: AztecAddress;
     }>;
+    setupAmm(): Promise<{
+        wallet: import("@aztec/aztec.js").AccountWalletWithSecretKey;
+        defaultAccountAddress: AztecAddress;
+        amm: AMMContract;
+        token0: TokenContract;
+        token1: TokenContract;
+        pxe: PXE;
+    }>;
     /**
      * Checks if the sender account contract is initialized, and initializes it if necessary.
      * @returns The sender wallet.
@@ -38,13 +51,21 @@ export declare class BotFactory {
      * @returns The TokenContract instance.
      */
     private setupToken;
+    /**
+     * 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 setupTokenContract;
+    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 bridgeL1FeeJuice;
-    private advanceL2Block;
-    private tryFlushTxs;
+    private withNoMinTxsPerBlock;
 }
 //# sourceMappingURL=factory.d.ts.map

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,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"}
+{"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;CAYnC"}

package/dest/factory.js

@@ -1,9 +1,11 @@
 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 { BatchCall, FeeJuicePaymentMethodWithClaim, L1FeeJuicePortalManager, createLogger, createPXEClient, waitForL1ToL2MessageReady } from '@aztec/aztec.js';
+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 { deriveSigningKey } from '@aztec/stdlib/keys';
 import { makeTracedFetch } from '@aztec/telemetry-client';
@@ -15,20 +17,22 @@ export class BotFactory {
     config;
     pxe;
     node;
+    nodeAdmin;
     log;
-    constructor(config, dependencies = {}){
+    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.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 && !dependencies.node) {
+        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;
@@ -47,38 +51,62 @@ export class BotFactory {
    */ async setup() {
         const recipient = await this.registerRecipient();
         const wallet = await this.setupAccount();
-        const token = await this.setupToken(wallet);
-        await this.mintTokens(token);
+        const defaultAccountAddress = wallet.getAddress();
+        const token = await this.setupToken(wallet, defaultAccountAddress);
+        await this.mintTokens(token, defaultAccountAddress);
         return {
             wallet,
+            defaultAccountAddress,
             token,
             pxe: this.pxe,
             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);
+        this.log.info(`AMM initialized and funded`);
+        return {
+            wallet,
+            defaultAccountAddress,
+            amm,
+            token0,
+            token1,
+            pxe: this.pxe
+        };
+    }
     /**
    * 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) {
+            return await this.setupAccountWithPrivateKey(privateKey);
         } else {
             return await this.setupTestAccount();
         }
     }
     async setupAccountWithPrivateKey(privateKey) {
-        const salt = Fr.ONE;
+        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;
         if (isInit) {
             this.log.info(`Account at ${account.getAddress().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;
         } else {
             const address = account.getAddress();
             this.log.info(`Deploying account at ${address}`);
-            const claim = await this.bridgeL1FeeJuice(address, 10n ** 22n);
+            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({
@@ -87,12 +115,11 @@ export class BotFactory {
                 }
             });
             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
-            });
+            // 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;
         }
@@ -113,117 +140,215 @@ export class BotFactory {
     /**
    * Registers the recipient for txs in the pxe.
    */ async registerRecipient() {
-        const recipient = await this.pxe.registerAccount(this.config.recipientEncryptionSecret, Fr.ONE);
+        const recipient = await this.pxe.registerAccount(this.config.recipientEncryptionSecret.getValue(), 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) {
+   */ async setupToken(wallet, 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(wallet, sender, 'BotToken', 'BOT', 18);
+        } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
+            deploy = PrivateTokenContract.deploy(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.pxe.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(wallet, deployer, contractAddressSalt, name, ticker, decimals = 18) {
+        const deployOpts = {
+            from: deployer,
+            contractAddressSalt,
+            universalDeploy: true
+        };
+        const deploy = TokenContract.deploy(wallet, deployer, name, ticker, decimals);
+        return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+    }
+    async setupAmmContract(wallet, deployer, contractAddressSalt, token0, token1, lpToken) {
+        const deployOpts = {
+            from: deployer,
+            contractAddressSalt,
+            universalDeploy: true
+        };
+        const deploy = AMMContract.deploy(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(wallet, 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 wallet.createAuthWit({
+            caller: amm.address,
+            action: token0.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount0Max, authwitNonce)
+        });
+        const token1Authwit = await wallet.createAuthWit({
+            caller: amm.address,
+            action: token1.methods.transfer_to_public_and_prepare_private_balance_increase(liquidityProvider, amm.address, amount1Max, authwitNonce)
+        });
+        const mintTx = new BatchCall(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 ${wallet.getAddress()} 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) {
+            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) {
+    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 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.pxe, extendedClient, this.log);
+        const mintAmount = await portal.getTokenManager().getMintAmount();
+        const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true);
+        await this.withNoMinTxsPerBlock(()=>waitForL1ToL2MessageReady(this.pxe, 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.nodeAdmin || !this.config.flushSetupTransactions) {
+            return fn();
+        }
+        const { minTxsPerBlock } = await this.nodeAdmin.getConfig();
+        await this.nodeAdmin.setConfig({
+            minTxsPerBlock: 0
+        });
+        try {
+            return await fn();
+        } finally{
+            await this.nodeAdmin.setConfig({
+                minTxsPerBlock
+            });
         }
     }
 }

package/dest/index.d.ts

@@ -1,6 +1,7 @@
 export { Bot } from './bot.js';
+export { AmmBot } from './amm_bot.js';
 export { BotRunner } from './runner.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,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,6 @@
 export { Bot } from './bot.js';
+export { AmmBot } from './amm_bot.js';
 export { BotRunner } from './runner.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';
 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>;