@aztec/bot 0.80.0 → 0.82.0

package/dest/factory.js

@@ -3,6 +3,7 @@ import { getDeployedTestAccountsWallets, getInitialTestAccounts } from '@aztec/a
 import { BatchCall, FeeJuicePaymentMethodWithClaim, L1FeeJuicePortalManager, createLogger, createPXEClient, retryUntil } from '@aztec/aztec.js';
 import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
 import { Fr } from '@aztec/foundation/fields';
+import { AMMContract } from '@aztec/noir-contracts.js/AMM';
 import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
@@ -15,12 +16,13 @@ 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) {
             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`);
@@ -29,6 +31,7 @@ export class BotFactory {
             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;
@@ -56,6 +59,22 @@ export class BotFactory {
             recipient
         };
     }
+    async setupAmm() {
+        const wallet = await this.setupAccount();
+        const token0 = await this.setupTokenContract(wallet, this.config.tokenSalt, 'BotToken0', 'BOT0');
+        const token1 = await this.setupTokenContract(wallet, this.config.tokenSalt, 'BotToken1', 'BOT1');
+        const liquidityToken = await this.setupTokenContract(wallet, this.config.tokenSalt, 'BotLPToken', 'BOTLP');
+        const amm = await this.setupAmmContract(wallet, this.config.tokenSalt, token0, token1, liquidityToken);
+        await this.fundAmm(wallet, amm, token0, token1);
+        this.log.info(`AMM initialized and funded`);
+        return {
+            wallet,
+            amm,
+            token0,
+            token1,
+            pxe: this.pxe
+        };
+    }
     /**
    * Checks if the sender account contract is initialized, and initializes it if necessary.
    * @returns The sender wallet.
@@ -67,7 +86,7 @@ export class BotFactory {
         }
     }
     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;
@@ -78,7 +97,8 @@ export class BotFactory {
         } 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,6 +107,7 @@ export class BotFactory {
                 }
             });
             const txHash = await sentTx.getTxHash();
+            // docs:end:claim_and_deploy
             this.log.info(`Sent tx with hash ${txHash.toString()}`);
             await this.tryFlushTxs();
             this.log.verbose('Waiting for account deployment to settle');
@@ -154,6 +175,87 @@ export class BotFactory {
         }
     }
     /**
+   * Checks if the token contract is deployed and deploys it if necessary.
+   * @param wallet - Wallet to deploy the token contract from.
+   * @returns The TokenContract instance.
+   */ setupTokenContract(wallet, contractAddressSalt, name, ticker, decimals = 18) {
+        const deployOpts = {
+            contractAddressSalt,
+            universalDeploy: true
+        };
+        const deploy = TokenContract.deploy(wallet, wallet.getAddress(), name, ticker, decimals);
+        return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+    }
+    async setupAmmContract(wallet, contractAddressSalt, token0, token1, lpToken) {
+        const deployOpts = {
+            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();
+        this.log.info(`Set LP token minter to AMM txHash=${await minterTx.getTxHash()}`);
+        await minterTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+        this.log.info(`Liquidity token initialized`);
+        return amm;
+    }
+    async fundAmm(wallet, amm, token0, token1) {
+        const nonce = 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 token0Authwit = await wallet.createAuthWit({
+            caller: amm.address,
+            action: token0.methods.transfer_to_public(wallet.getAddress(), amm.address, amount0Max, nonce)
+        });
+        const token1Authwit = await wallet.createAuthWit({
+            caller: amm.address,
+            action: token1.methods.transfer_to_public(wallet.getAddress(), amm.address, amount1Max, nonce)
+        });
+        this.log.info(`Minting tokens`);
+        const mintTx = new BatchCall(wallet, [
+            token0.methods.mint_to_private(wallet.getAddress(), wallet.getAddress(), MINT_BALANCE),
+            token1.methods.mint_to_private(wallet.getAddress(), wallet.getAddress(), MINT_BALANCE)
+        ]).send();
+        this.log.info(`Sent mint tx: ${await mintTx.getTxHash()}`);
+        await mintTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+        this.log.info(`Funding AMM`);
+        const addLiquidityTx = amm.methods.add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, nonce).send({
+            authWitnesses: [
+                token0Authwit,
+                token1Authwit
+            ]
+        });
+        this.log.info(`Sent tx to add liquidity to the AMM: ${await addLiquidityTx.getTxHash()}`);
+        await addLiquidityTx.wait({
+            timeout: this.config.txMinedWaitSeconds
+        });
+    }
+    async registerOrDeployContract(name, deploy, deployOpts) {
+        const address = (await deploy.getInstance(deployOpts)).address;
+        if ((await this.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
+            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 tx with hash ${txHash.toString()}`);
+            await this.tryFlushTxs();
+            this.log.verbose(`Waiting for contract ${name} 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) {
@@ -189,7 +291,7 @@ export class BotFactory {
             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.');
@@ -202,10 +304,11 @@ export class BotFactory {
         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 mintAmount = await portal.getTokenManager().getMintAmount();
+        const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true);
         const isSynced = async ()=>await this.pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
         await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
-        this.log.info(`Created a claim for ${amount} L1 fee juice to ${recipient}.`, claim);
+        this.log.info(`Created a claim for ${mintAmount} L1 fee juice to ${recipient}.`, claim);
         // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
         await this.advanceL2Block();
         await this.advanceL2Block();
@@ -220,7 +323,7 @@ export class BotFactory {
         if (this.config.flushSetupTransactions) {
             this.log.verbose('Flushing transactions');
             try {
-                await this.node.flushTxs();
+                await this.nodeAdmin.flushTxs();
             } catch (err) {
                 this.log.error(`Failed to flush transactions: ${err}`);
             }

package/dest/index.d.ts

@@ -1,4 +1,5 @@
 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';

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,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAC5E,cAAc,gBAAgB,CAAC"}

package/dest/index.js

@@ -1,4 +1,5 @@
 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';

package/dest/runner.d.ts

@@ -1,4 +1,5 @@
 import { type AztecNode, type PXE } from '@aztec/aztec.js';
+import { type AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { type TelemetryClient, type Traceable, type Tracer } from '@aztec/telemetry-client';
 import { type BotConfig } from './config.js';
 import type { BotRunnerApi } from './interface.js';
@@ -9,6 +10,7 @@ export declare class BotRunner implements BotRunnerApi, Traceable {
     private bot?;
     private pxe?;
     private node;
+    private nodeAdmin?;
     private runningPromise;
     private consecutiveErrors;
     private healthy;
@@ -16,6 +18,7 @@ export declare class BotRunner implements BotRunnerApi, Traceable {
     constructor(config: BotConfig, dependencies: {
         pxe?: PXE;
         node?: AztecNode;
+        nodeAdmin?: AztecNodeAdmin;
         telemetry: TelemetryClient;
     });
     /** Initializes the bot if needed. Blocks until the bot setup is finished. */

package/dest/runner.d.ts.map

@@ -1 +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"}
+{"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,cAAc,EAA8B,MAAM,iCAAiC,CAAC;AAClG,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAA8B,MAAM,yBAAyB,CAAC;AAKxH,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,qBAAa,SAAU,YAAW,YAAY,EAAE,SAAS;;IAarD,OAAO,CAAC,MAAM;IAZhB,OAAO,CAAC,GAAG,CAAuB;IAClC,OAAO,CAAC,GAAG,CAAC,CAAmB;IAC/B,OAAO,CAAC,GAAG,CAAC,CAAM;IAClB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,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,CAAC,EAAE,cAAc,CAAC;QAAC,SAAS,EAAE,eAAe,CAAA;KAAE;IAgBvG,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;CAyCjB"}

package/dest/runner.js

@@ -6,7 +6,9 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 import { createAztecNodeClient, createLogger } from '@aztec/aztec.js';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
 import { makeTracedFetch, trackSpan } from '@aztec/telemetry-client';
+import { AmmBot } from './amm_bot.js';
 import { Bot } from './bot.js';
 import { getVersions } from './config.js';
 export class BotRunner {
@@ -15,6 +17,7 @@ export class BotRunner {
     bot;
     pxe;
     node;
+    nodeAdmin;
     runningPromise;
     consecutiveErrors;
     healthy;
@@ -29,11 +32,14 @@ export class BotRunner {
         if (!dependencies.node && !config.nodeUrl) {
             throw new Error(`Missing node URL in config or dependencies`);
         }
-        this.node = dependencies.node ?? createAztecNodeClient(config.nodeUrl, getVersions(), makeTracedFetch([
+        const versions = getVersions();
+        const fetch = makeTracedFetch([
             1,
             2,
             3
-        ], true));
+        ], true);
+        this.node = dependencies.node ?? createAztecNodeClient(config.nodeUrl, versions, fetch);
+        this.nodeAdmin = dependencies.nodeAdmin ?? (config.nodeAdminUrl ? createAztecNodeAdminClient(config.nodeAdminUrl, versions, fetch) : undefined);
         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() {
@@ -120,9 +126,14 @@ export class BotRunner {
     }
     async #createBot() {
         try {
-            this.bot = Bot.create(this.config, {
+            this.bot = this.config.ammTxs ? AmmBot.create(this.config, {
                 pxe: this.pxe,
-                node: this.node
+                node: this.node,
+                nodeAdmin: this.nodeAdmin
+            }) : Bot.create(this.config, {
+                pxe: this.pxe,
+                node: this.node,
+                nodeAdmin: this.nodeAdmin
             });
             await this.bot;
         } catch (err) {

package/dest/utils.d.ts

@@ -1,3 +1,5 @@
+import type { ContractBase } from '@aztec/aztec.js';
+import type { AMMContract } from '@aztec/noir-contracts.js/AMM';
 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';
@@ -12,5 +14,6 @@ export declare function getBalances(token: TokenContract, who: AztecAddress): Pr
     publicBalance: bigint;
 }>;
 export declare function getPrivateBalance(token: EasyPrivateTokenContract, who: AztecAddress): Promise<bigint>;
-export declare function isStandardTokenContract(token: TokenContract | EasyPrivateTokenContract): token is TokenContract;
+export declare function isStandardTokenContract(token: ContractBase): token is TokenContract;
+export declare function isAMMContract(contract: ContractBase): contract is AMMContract;
 //# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,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,YAAY,GAAG,KAAK,IAAI,aAAa,CAEnF;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,QAAQ,IAAI,WAAW,CAE7E"}

package/dest/utils.js

@@ -18,3 +18,6 @@ export async function getPrivateBalance(token, who) {
 export function isStandardTokenContract(token) {
     return 'mint_to_public' in token.methods;
 }
+export function isAMMContract(contract) {
+    return 'add_liquidity' in contract.methods;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/bot",
-  "version": "0.80.0",
+  "version": "0.82.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -52,16 +52,16 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.80.0",
-    "@aztec/aztec.js": "0.80.0",
-    "@aztec/entrypoints": "0.80.0",
-    "@aztec/ethereum": "0.80.0",
-    "@aztec/foundation": "0.80.0",
-    "@aztec/noir-contracts.js": "0.80.0",
-    "@aztec/noir-protocol-circuits-types": "0.80.0",
-    "@aztec/protocol-contracts": "0.80.0",
-    "@aztec/stdlib": "0.80.0",
-    "@aztec/telemetry-client": "0.80.0",
+    "@aztec/accounts": "0.82.0",
+    "@aztec/aztec.js": "0.82.0",
+    "@aztec/entrypoints": "0.82.0",
+    "@aztec/ethereum": "0.82.0",
+    "@aztec/foundation": "0.82.0",
+    "@aztec/noir-contracts.js": "0.82.0",
+    "@aztec/noir-protocol-circuits-types": "0.82.0",
+    "@aztec/protocol-contracts": "0.82.0",
+    "@aztec/stdlib": "0.82.0",
+    "@aztec/telemetry-client": "0.82.0",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "zod": "^3.23.8"

package/src/amm_bot.ts

@@ -0,0 +1,93 @@
+import { AztecAddress, Fr, SentTx, type Wallet } from '@aztec/aztec.js';
+import type { AMMContract } from '@aztec/noir-contracts.js/AMM';
+import type { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { AztecNode, AztecNodeAdmin, PXE } from '@aztec/stdlib/interfaces/client';
+
+import { BaseBot } from './base_bot.js';
+import type { BotConfig } from './config.js';
+import { BotFactory } from './factory.js';
+
+const TRANSFER_AMOUNT = 1_000;
+
+type Balances = { token0: bigint; token1: bigint };
+
+export class AmmBot extends BaseBot {
+  protected constructor(
+    pxe: PXE,
+    wallet: Wallet,
+    public readonly amm: AMMContract,
+    public readonly token0: TokenContract,
+    public readonly token1: TokenContract,
+    config: BotConfig,
+  ) {
+    super(pxe, wallet, config);
+  }
+
+  static async create(
+    config: BotConfig,
+    dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin },
+  ): Promise<AmmBot> {
+    const { pxe, wallet, token0, token1, amm } = await new BotFactory(config, dependencies).setupAmm();
+    return new AmmBot(pxe, wallet, amm, token0, token1, config);
+  }
+
+  protected async createAndSendTx(logCtx: object): Promise<SentTx> {
+    const { feePaymentMethod } = this.config;
+    const { wallet, amm, token0, token1 } = this;
+
+    this.log.verbose(`Preparing tx with ${feePaymentMethod} fee to swap tokens`, logCtx);
+
+    const ammBalances = await this.getAmmBalances();
+    const amountIn = TRANSFER_AMOUNT;
+    const nonce = Fr.random();
+
+    const swapAuthwit = await wallet.createAuthWit({
+      caller: amm.address,
+      action: token0.methods.transfer_to_public(wallet.getAddress(), amm.address, amountIn, nonce),
+    });
+
+    const amountOutMin = await amm.methods
+      .get_amount_out_for_exact_in(ammBalances.token0, ammBalances.token1, amountIn)
+      .simulate();
+
+    const swapExactTokensInteraction = amm.methods.swap_exact_tokens_for_tokens(
+      token0.address,
+      token1.address,
+      amountIn,
+      amountOutMin,
+      nonce,
+    );
+
+    const opts = this.getSendMethodOpts(swapAuthwit);
+
+    this.log.verbose(`Proving transaction`, logCtx);
+    const tx = await swapExactTokensInteraction.prove(opts);
+
+    return tx.send();
+  }
+
+  public getAmmBalances(): Promise<Balances> {
+    return this.getPublicBalanceFor(this.amm.address);
+  }
+
+  public async getBalances(): Promise<{ senderPublic: Balances; senderPrivate: Balances; amm: Balances }> {
+    return {
+      senderPublic: await this.getPublicBalanceFor(this.wallet.getAddress()),
+      senderPrivate: await this.getPrivateBalanceFor(this.wallet.getAddress()),
+      amm: await this.getPublicBalanceFor(this.amm.address),
+    };
+  }
+
+  private async getPublicBalanceFor(address: AztecAddress): Promise<Balances> {
+    return {
+      token0: await this.token0.methods.balance_of_public(address).simulate(),
+      token1: await this.token1.methods.balance_of_public(address).simulate(),
+    };
+  }
+  private async getPrivateBalanceFor(address: AztecAddress): Promise<Balances> {
+    return {
+      token0: await this.token0.methods.balance_of_private(address).simulate(),
+      token1: await this.token1.methods.balance_of_private(address).simulate(),
+    };
+  }
+}

package/src/base_bot.ts

@@ -0,0 +1,75 @@
+import {
+  AuthWitness,
+  FeeJuicePaymentMethod,
+  type SendMethodOptions,
+  SentTx,
+  type Wallet,
+  createLogger,
+  waitForProven,
+} from '@aztec/aztec.js';
+import { Gas } from '@aztec/stdlib/gas';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+import type { BotConfig } from './config.js';
+
+export abstract class BaseBot {
+  protected log = createLogger('bot');
+
+  protected attempts: number = 0;
+  protected successes: number = 0;
+
+  protected constructor(public readonly pxe: PXE, public readonly wallet: Wallet, public config: BotConfig) {}
+
+  public async run() {
+    this.attempts++;
+    const logCtx = { runId: Date.now() * 1000 + Math.floor(Math.random() * 1000) };
+    const { followChain, txMinedWaitSeconds } = this.config;
+
+    this.log.verbose(`Creating tx`, logCtx);
+    const tx = await this.createAndSendTx(logCtx);
+
+    const txHash = await tx.getTxHash();
+
+    if (followChain === 'NONE') {
+      this.log.info(`Transaction ${txHash} sent, not waiting for it to be mined`);
+      return;
+    }
+
+    this.log.verbose(
+      `Awaiting tx ${txHash} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
+      logCtx,
+    );
+    const receipt = await tx.wait({
+      timeout: txMinedWaitSeconds,
+    });
+    if (followChain === 'PROVEN') {
+      await waitForProven(this.pxe, receipt, { provenTimeout: txMinedWaitSeconds });
+    }
+    this.successes++;
+    this.log.info(
+      `Tx #${this.attempts} ${receipt.txHash} successfully mined in block ${receipt.blockNumber} (stats: ${this.successes}/${this.attempts} success)`,
+      logCtx,
+    );
+  }
+
+  protected abstract createAndSendTx(logCtx: object): Promise<SentTx>;
+
+  protected getSendMethodOpts(...authWitnesses: AuthWitness[]): SendMethodOptions {
+    const sender = this.wallet.getAddress();
+    const { l2GasLimit, daGasLimit, skipPublicSimulation } = this.config;
+    const paymentMethod = new FeeJuicePaymentMethod(sender);
+
+    let gasSettings, estimateGas;
+    if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
+      gasSettings = { gasLimits: Gas.from({ l2Gas: l2GasLimit, daGas: daGasLimit }) };
+      estimateGas = false;
+      this.log.verbose(`Using gas limits ${l2GasLimit} L2 gas ${daGasLimit} DA gas`);
+    } else {
+      estimateGas = true;
+      this.log.verbose(`Estimating gas for transaction`);
+    }
+    const baseFeePadding = 2; // Send 3x the current base fee
+    this.log.verbose(skipPublicSimulation ? `Skipping public simulation` : `Simulating public transfers`);
+    return { fee: { estimateGas, paymentMethod, gasSettings, baseFeePadding }, skipPublicSimulation, authWitnesses };
+  }
+}

package/src/bot.ts

@@ -1,39 +1,33 @@
-import {
-  type AztecAddress,
-  BatchCall,
-  FeeJuicePaymentMethod,
-  type SendMethodOptions,
-  type Wallet,
-  createLogger,
-} from '@aztec/aztec.js';
+import { type AztecAddress, BatchCall, SentTx, type Wallet } from '@aztec/aztec.js';
 import { times } from '@aztec/foundation/collection';
 import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { Gas } from '@aztec/stdlib/gas';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, AztecNodeAdmin, PXE } from '@aztec/stdlib/interfaces/client';
 
+import { BaseBot } from './base_bot.js';
 import type { BotConfig } from './config.js';
 import { BotFactory } from './factory.js';
 import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
 
 const TRANSFER_AMOUNT = 1;
 
-export class Bot {
-  private log = createLogger('bot');
-
-  private attempts: number = 0;
-  private successes: number = 0;
-
+export class Bot extends BaseBot {
   protected constructor(
-    public readonly wallet: Wallet,
+    pxe: PXE,
+    wallet: Wallet,
     public readonly token: TokenContract | EasyPrivateTokenContract,
     public readonly recipient: AztecAddress,
-    public config: BotConfig,
-  ) {}
+    config: BotConfig,
+  ) {
+    super(pxe, wallet, config);
+  }
 
-  static async create(config: BotConfig, dependencies: { pxe?: PXE; node?: AztecNode } = {}): Promise<Bot> {
-    const { wallet, token, recipient } = await new BotFactory(config, dependencies).setup();
-    return new Bot(wallet, token, recipient, config);
+  static async create(
+    config: BotConfig,
+    dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin },
+  ): Promise<Bot> {
+    const { pxe, wallet, token, recipient } = await new BotFactory(config, dependencies).setup();
+    return new Bot(pxe, wallet, token, recipient, config);
   }
 
   public updateConfig(config: Partial<BotConfig>) {
@@ -41,11 +35,8 @@ export class Bot {
     this.config = { ...this.config, ...config };
   }
 
-  public async run() {
-    this.attempts++;
-    const logCtx = { runId: Date.now() * 1000 + Math.floor(Math.random() * 1000) };
-    const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod, followChain, txMinedWaitSeconds } =
-      this.config;
+  protected async createAndSendTx(logCtx: object): Promise<SentTx> {
+    const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod } = this.config;
     const { token, recipient, wallet } = this;
     const sender = wallet.getAddress();
 
@@ -69,31 +60,7 @@ export class Bot {
 
     this.log.verbose(`Proving transaction`, logCtx);
     const provenTx = await batch.prove(opts);
-
-    this.log.verbose(`Sending tx`, logCtx);
-    const tx = provenTx.send();
-
-    const txHash = await tx.getTxHash();
-
-    if (followChain === 'NONE') {
-      this.log.info(`Transaction ${txHash} sent, not waiting for it to be mined`);
-      return;
-    }
-
-    this.log.verbose(
-      `Awaiting tx ${txHash} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
-      logCtx,
-    );
-    const receipt = await tx.wait({
-      timeout: txMinedWaitSeconds,
-      provenTimeout: txMinedWaitSeconds,
-      proven: followChain === 'PROVEN',
-    });
-    this.log.info(
-      `Tx #${this.attempts} ${receipt.txHash} successfully mined in block ${receipt.blockNumber} (stats: ${this.successes}/${this.attempts} success)`,
-      logCtx,
-    );
-    this.successes++;
+    return provenTx.send();
   }
 
   public async getBalances() {
@@ -115,23 +82,4 @@ export class Bot {
       };
     }
   }
-
-  private getSendMethodOpts(): SendMethodOptions {
-    const sender = this.wallet.getAddress();
-    const { l2GasLimit, daGasLimit, skipPublicSimulation } = this.config;
-    const paymentMethod = new FeeJuicePaymentMethod(sender);
-
-    let gasSettings, estimateGas;
-    if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
-      gasSettings = { gasLimits: Gas.from({ l2Gas: l2GasLimit, daGas: daGasLimit }) };
-      estimateGas = false;
-      this.log.verbose(`Using gas limits ${l2GasLimit} L2 gas ${daGasLimit} DA gas`);
-    } else {
-      estimateGas = true;
-      this.log.verbose(`Estimating gas for transaction`);
-    }
-    const baseFeePadding = 2; // Send 3x the current base fee
-    this.log.verbose(skipPublicSimulation ? `Skipping public simulation` : `Simulating public transfers`);
-    return { fee: { estimateGas, paymentMethod, gasSettings, baseFeePadding }, skipPublicSimulation };
-  }
 }