@aztec/bot 1.2.0 → 2.0.0-nightly.20250813

package/dest/amm_bot.d.ts

@@ -1,4 +1,4 @@
-import { SentTx, TxReceipt, type Wallet } from '@aztec/aztec.js';
+import { AztecAddress, SentTx, TxReceipt, 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';
@@ -12,7 +12,7 @@ export declare class AmmBot extends BaseBot {
     readonly amm: AMMContract;
     readonly token0: TokenContract;
     readonly token1: TokenContract;
-    protected constructor(pxe: PXE, wallet: Wallet, amm: AMMContract, token0: TokenContract, token1: TokenContract, config: BotConfig);
+    protected constructor(pxe: PXE, wallet: Wallet, defaultAccountAddress: AztecAddress, amm: AMMContract, token0: TokenContract, token1: TokenContract, config: BotConfig);
     static create(config: BotConfig, dependencies: {
         pxe?: PXE;
         node?: AztecNode;

package/dest/amm_bot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"amm_bot.d.ts","sourceRoot":"","sources":["../src/amm_bot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAEtF,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,KAAK,QAAQ,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnD,qBAAa,MAAO,SAAQ,OAAO;aAIf,GAAG,EAAE,WAAW;aAChB,MAAM,EAAE,aAAa;aACrB,MAAM,EAAE,aAAa;IALvC,SAAS,aACP,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACE,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa,EACrC,MAAM,EAAE,SAAS;WAKN,MAAM,CACjB,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAA;KAAE,GACxE,OAAO,CAAC,MAAM,CAAC;cAKF,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;cA+CvC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK9E,cAAc,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI7B,WAAW,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,QAAQ,CAAC;QAAC,aAAa,EAAE,QAAQ,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC;YAQzF,mBAAmB;YAMnB,oBAAoB;CAMnC"}
+{"version":3,"file":"amm_bot.d.ts","sourceRoot":"","sources":["../src/amm_bot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAM,MAAM,EAAE,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAEtF,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,KAAK,QAAQ,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnD,qBAAa,MAAO,SAAQ,OAAO;aAKf,GAAG,EAAE,WAAW;aAChB,MAAM,EAAE,aAAa;aACrB,MAAM,EAAE,aAAa;IANvC,SAAS,aACP,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,qBAAqB,EAAE,YAAY,EACnB,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa,EACrC,MAAM,EAAE,SAAS;WAKN,MAAM,CACjB,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAA;KAAE,GACxE,OAAO,CAAC,MAAM,CAAC;cAQF,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;cA+CvC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK9E,cAAc,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI7B,WAAW,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,QAAQ,CAAC;QAAC,aAAa,EAAE,QAAQ,CAAC;QAAC,GAAG,EAAE,QAAQ,CAAA;KAAE,CAAC;YAQzF,mBAAmB;YAMnB,oBAAoB;CAMnC"}

package/dest/amm_bot.js

@@ -8,12 +8,12 @@ export class AmmBot extends BaseBot {
     amm;
     token0;
     token1;
-    constructor(pxe, wallet, amm, token0, token1, config){
-        super(pxe, wallet, config), this.amm = amm, this.token0 = token0, this.token1 = token1;
+    constructor(pxe, wallet, defaultAccountAddress, amm, token0, token1, config){
+        super(pxe, wallet, defaultAccountAddress, config), this.amm = amm, this.token0 = token0, this.token1 = token1;
     }
     static async create(config, dependencies) {
-        const { pxe, wallet, token0, token1, amm } = await new BotFactory(config, dependencies).setupAmm();
-        return new AmmBot(pxe, wallet, amm, token0, token1, config);
+        const { pxe, wallet, defaultAccountAddress, token0, token1, amm } = await new BotFactory(config, dependencies).setupAmm();
+        return new AmmBot(pxe, wallet, defaultAccountAddress, amm, token0, token1, config);
     }
     async createAndSendTx(logCtx) {
         const { feePaymentMethod } = this.config;
@@ -35,9 +35,15 @@ export class AmmBot extends BaseBot {
         ];
         const swapAuthwit = await wallet.createAuthWit({
             caller: amm.address,
-            action: tokenIn.methods.transfer_to_public(wallet.getAddress(), amm.address, amountIn, authwitNonce)
+            action: tokenIn.methods.transfer_to_public(this.defaultAccountAddress, amm.address, amountIn, authwitNonce)
+        });
+        const amountOutMin = await amm.methods.get_amount_out_for_exact_in(await tokenIn.methods.balance_of_public(amm.address).simulate({
+            from: this.defaultAccountAddress
+        }), await tokenOut.methods.balance_of_public(amm.address).simulate({
+            from: this.defaultAccountAddress
+        }), amountIn).simulate({
+            from: this.defaultAccountAddress
         });
-        const amountOutMin = await amm.methods.get_amount_out_for_exact_in(await tokenIn.methods.balance_of_public(amm.address).simulate(), await tokenOut.methods.balance_of_public(amm.address).simulate(), amountIn).simulate();
         const swapExactTokensInteraction = amm.methods.swap_exact_tokens_for_tokens(tokenIn.address, tokenOut.address, amountIn, amountOutMin, authwitNonce);
         const opts = this.getSendMethodOpts(swapAuthwit);
         this.log.verbose(`Proving transaction`, logCtx);
@@ -60,21 +66,29 @@ export class AmmBot extends BaseBot {
     }
     async getBalances() {
         return {
-            senderPublic: await this.getPublicBalanceFor(this.wallet.getAddress()),
-            senderPrivate: await this.getPrivateBalanceFor(this.wallet.getAddress()),
+            senderPublic: await this.getPublicBalanceFor(this.defaultAccountAddress),
+            senderPrivate: await this.getPrivateBalanceFor(this.defaultAccountAddress),
             amm: await this.getPublicBalanceFor(this.amm.address)
         };
     }
     async getPublicBalanceFor(address) {
         return {
-            token0: await this.token0.methods.balance_of_public(address).simulate(),
-            token1: await this.token1.methods.balance_of_public(address).simulate()
+            token0: await this.token0.methods.balance_of_public(address).simulate({
+                from: address
+            }),
+            token1: await this.token1.methods.balance_of_public(address).simulate({
+                from: address
+            })
         };
     }
     async getPrivateBalanceFor(address) {
         return {
-            token0: await this.token0.methods.balance_of_private(address).simulate(),
-            token1: await this.token1.methods.balance_of_private(address).simulate()
+            token0: await this.token0.methods.balance_of_private(address).simulate({
+                from: address
+            }),
+            token1: await this.token1.methods.balance_of_private(address).simulate({
+                from: address
+            })
         };
     }
 }

package/dest/base_bot.d.ts

@@ -1,14 +1,15 @@
-import { AuthWitness, type SendMethodOptions, SentTx, TxHash, TxReceipt, type Wallet } from '@aztec/aztec.js';
+import { AuthWitness, AztecAddress, type SendMethodOptions, SentTx, TxHash, TxReceipt, type Wallet } from '@aztec/aztec.js';
 import type { PXE } from '@aztec/stdlib/interfaces/client';
 import type { BotConfig } from './config.js';
 export declare abstract class BaseBot {
     readonly pxe: PXE;
     readonly wallet: Wallet;
+    readonly defaultAccountAddress: AztecAddress;
     config: BotConfig;
     protected log: import("@aztec/aztec.js").Logger;
     protected attempts: number;
     protected successes: number;
-    protected constructor(pxe: PXE, wallet: Wallet, config: BotConfig);
+    protected constructor(pxe: PXE, wallet: Wallet, defaultAccountAddress: AztecAddress, config: BotConfig);
     run(): Promise<TxReceipt | TxHash>;
     protected abstract createAndSendTx(logCtx: object): Promise<SentTx>;
     protected onTxMined(_receipt: TxReceipt, _logCtx: object): Promise<void>;

package/dest/base_bot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base_bot.d.ts","sourceRoot":"","sources":["../src/base_bot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAEX,KAAK,iBAAiB,EACtB,MAAM,EACN,MAAM,EACN,SAAS,EACT,KAAK,MAAM,EAGZ,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,8BAAsB,OAAO;aAOT,GAAG,EAAE,GAAG;aACR,MAAM,EAAE,MAAM;IACvB,MAAM,EAAE,SAAS;IAR1B,SAAS,CAAC,GAAG,mCAAuB;IAEpC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAK;IAC/B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAK;IAEhC,SAAS,aACS,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACvB,MAAM,EAAE,SAAS;IAGb,GAAG,IAAI,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC;IAoC/C,SAAS,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAEnE,SAAS,CAAC,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxE,SAAS,CAAC,iBAAiB,CAAC,GAAG,aAAa,EAAE,WAAW,EAAE,GAAG,iBAAiB;CAiBhF"}
+{"version":3,"file":"base_bot.d.ts","sourceRoot":"","sources":["../src/base_bot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,YAAY,EAEZ,KAAK,iBAAiB,EACtB,MAAM,EACN,MAAM,EACN,SAAS,EACT,KAAK,MAAM,EAGZ,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,8BAAsB,OAAO;aAOT,GAAG,EAAE,GAAG;aACR,MAAM,EAAE,MAAM;aACd,qBAAqB,EAAE,YAAY;IAC5C,MAAM,EAAE,SAAS;IAT1B,SAAS,CAAC,GAAG,mCAAuB;IAEpC,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAK;IAC/B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAK;IAEhC,SAAS,aACS,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,qBAAqB,EAAE,YAAY,EAC5C,MAAM,EAAE,SAAS;IAGb,GAAG,IAAI,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC;IAoC/C,SAAS,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAEnE,SAAS,CAAC,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxE,SAAS,CAAC,iBAAiB,CAAC,GAAG,aAAa,EAAE,WAAW,EAAE,GAAG,iBAAiB;CAoBhF"}

package/dest/base_bot.js

@@ -3,13 +3,15 @@ import { Gas } from '@aztec/stdlib/gas';
 export class BaseBot {
     pxe;
     wallet;
+    defaultAccountAddress;
     config;
     log;
     attempts;
     successes;
-    constructor(pxe, wallet, config){
+    constructor(pxe, wallet, defaultAccountAddress, config){
         this.pxe = pxe;
         this.wallet = wallet;
+        this.defaultAccountAddress = defaultAccountAddress;
         this.config = config;
         this.log = createLogger('bot');
         this.attempts = 0;
@@ -25,10 +27,10 @@ export class BaseBot {
         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`);
+            this.log.info(`Transaction ${txHash.toString()} sent, not waiting for it to be mined`);
             return txHash;
         }
-        this.log.verbose(`Awaiting tx ${txHash} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`, logCtx);
+        this.log.verbose(`Awaiting tx ${txHash.toString()} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`, logCtx);
         const receipt = await tx.wait({
             timeout: txMinedWaitSeconds
         });
@@ -47,9 +49,8 @@ export class BaseBot {
         return Promise.resolve();
     }
     getSendMethodOpts(...authWitnesses) {
-        const sender = this.wallet.getAddress();
         const { l2GasLimit, daGasLimit } = this.config;
-        const paymentMethod = new FeeJuicePaymentMethod(sender);
+        const paymentMethod = new FeeJuicePaymentMethod(this.defaultAccountAddress);
         let gasSettings, estimateGas;
         if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
             gasSettings = {
@@ -66,6 +67,7 @@ export class BaseBot {
         }
         const baseFeePadding = 2; // Send 3x the current base fee
         return {
+            from: this.defaultAccountAddress,
             fee: {
                 estimateGas,
                 paymentMethod,

package/dest/bot.d.ts

@@ -7,7 +7,7 @@ import type { BotConfig } from './config.js';
 export declare class Bot extends BaseBot {
     readonly token: TokenContract | EasyPrivateTokenContract;
     readonly recipient: AztecAddress;
-    protected constructor(pxe: PXE, wallet: Wallet, token: TokenContract | EasyPrivateTokenContract, recipient: AztecAddress, config: BotConfig);
+    protected constructor(pxe: PXE, wallet: Wallet, defaultAccountAddress: AztecAddress, token: TokenContract | EasyPrivateTokenContract, recipient: AztecAddress, config: BotConfig);
     static create(config: BotConfig, dependencies: {
         pxe?: PXE;
         node?: AztecNode;

package/dest/bot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../src/bot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAEtF,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,qBAAa,GAAI,SAAQ,OAAO;aAIZ,KAAK,EAAE,aAAa,GAAG,wBAAwB;aAC/C,SAAS,EAAE,YAAY;IAJzC,SAAS,aACP,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACE,KAAK,EAAE,aAAa,GAAG,wBAAwB,EAC/C,SAAS,EAAE,YAAY,EACvC,MAAM,EAAE,SAAS;WAKN,MAAM,CACjB,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAA;KAAE,GACxE,OAAO,CAAC,GAAG,CAAC;IAKR,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC;cAK9B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BnD,WAAW;;;;;;;;;;CAmBzB"}
+{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../src/bot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAEtF,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,qBAAa,GAAI,SAAQ,OAAO;aAKZ,KAAK,EAAE,aAAa,GAAG,wBAAwB;aAC/C,SAAS,EAAE,YAAY;IALzC,SAAS,aACP,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,qBAAqB,EAAE,YAAY,EACnB,KAAK,EAAE,aAAa,GAAG,wBAAwB,EAC/C,SAAS,EAAE,YAAY,EACvC,MAAM,EAAE,SAAS;WAKN,MAAM,CACjB,MAAM,EAAE,SAAS,EACjB,YAAY,EAAE;QAAE,GAAG,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAA;KAAE,GACxE,OAAO,CAAC,GAAG,CAAC;IAKR,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC;cAK9B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA+BnD,WAAW;;;;;;;;;;CAmBzB"}

package/dest/bot.js

@@ -7,12 +7,12 @@ const TRANSFER_AMOUNT = 1;
 export class Bot extends BaseBot {
     token;
     recipient;
-    constructor(pxe, wallet, token, recipient, config){
-        super(pxe, wallet, config), this.token = token, this.recipient = recipient;
+    constructor(pxe, wallet, defaultAccountAddress, token, recipient, config){
+        super(pxe, wallet, defaultAccountAddress, config), this.token = token, this.recipient = recipient;
     }
     static async create(config, dependencies) {
-        const { pxe, wallet, token, recipient } = await new BotFactory(config, dependencies).setup();
-        return new Bot(pxe, wallet, token, recipient, config);
+        const { pxe, wallet, defaultAccountAddress, token, recipient } = await new BotFactory(config, dependencies).setup();
+        return new Bot(pxe, wallet, defaultAccountAddress, token, recipient, config);
     }
     updateConfig(config) {
         this.log.info(`Updating bot config ${Object.keys(config).join(', ')}`);
@@ -24,16 +24,17 @@ export class Bot extends BaseBot {
     async createAndSendTx(logCtx) {
         const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod } = this.config;
         const { token, recipient, wallet } = this;
-        const sender = wallet.getAddress();
         this.log.verbose(`Preparing tx with ${feePaymentMethod} fee with ${privateTransfersPerTx} private and ${publicTransfersPerTx} public transfers`, logCtx);
         const calls = isStandardTokenContract(token) ? [
             times(privateTransfersPerTx, ()=>token.methods.transfer(recipient, TRANSFER_AMOUNT)),
-            times(publicTransfersPerTx, ()=>token.methods.transfer_in_public(sender, recipient, TRANSFER_AMOUNT, 0))
-        ].flat() : times(privateTransfersPerTx, ()=>token.methods.transfer(TRANSFER_AMOUNT, sender, recipient));
+            times(publicTransfersPerTx, ()=>token.methods.transfer_in_public(this.defaultAccountAddress, recipient, TRANSFER_AMOUNT, 0))
+        ].flat() : times(privateTransfersPerTx, ()=>token.methods.transfer(TRANSFER_AMOUNT, this.defaultAccountAddress, recipient));
         const opts = this.getSendMethodOpts();
         const batch = new BatchCall(wallet, calls);
         this.log.verbose(`Simulating transaction with ${calls.length}`, logCtx);
-        await batch.simulate();
+        await batch.simulate({
+            from: this.defaultAccountAddress
+        });
         this.log.verbose(`Proving transaction`, logCtx);
         const provenTx = await batch.prove(opts);
         return provenTx.send();
@@ -41,13 +42,13 @@ export class Bot extends BaseBot {
     async getBalances() {
         if (isStandardTokenContract(this.token)) {
             return {
-                sender: await getBalances(this.token, this.wallet.getAddress()),
+                sender: await getBalances(this.token, this.defaultAccountAddress),
                 recipient: await getBalances(this.token, this.recipient)
             };
         } else {
             return {
                 sender: {
-                    privateBalance: await getPrivateBalance(this.token, this.wallet.getAddress()),
+                    privateBalance: await getPrivateBalance(this.token, this.defaultAccountAddress),
                     publicBalance: 0n
                 },
                 recipient: {

package/dest/config.d.ts

@@ -26,11 +26,11 @@ export type BotConfig = {
     l1ToL2MessageTimeoutSeconds: number;
     /** Signing private key for the sender account. */
     senderPrivateKey: SecretValue<Fr | undefined>;
-    /** Optional salt to use to deploy the sender account */
+    /** Optional salt to use to instantiate the sender account */
     senderSalt: Fr | undefined;
     /** Encryption secret for a recipient account. */
     recipientEncryptionSecret: SecretValue<Fr>;
-    /** Salt for the token contract deployment. */
+    /** Salt for the token contract instantiation. */
     tokenSalt: Fr;
     /** Every how many seconds should a new tx be sent. */
     txIntervalSeconds: number;

package/dest/config.d.ts.map

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

package/dest/factory.d.ts

@@ -21,12 +21,14 @@ export declare class BotFactory {
      */
     setup(): Promise<{
         wallet: import("@aztec/aztec.js").AccountWalletWithSecretKey;
+        defaultAccountAddress: AztecAddress;
         token: TokenContract | EasyPrivateTokenContract;
         pxe: PXE;
         recipient: AztecAddress;
     }>;
     setupAmm(): Promise<{
         wallet: import("@aztec/aztec.js").AccountWalletWithSecretKey;
+        defaultAccountAddress: AztecAddress;
         amm: AMMContract;
         token0: TokenContract;
         token1: TokenContract;
@@ -64,7 +66,7 @@ export declare class BotFactory {
      */
     private mintTokens;
     private bridgeL1FeeJuice;
+    private withNoMinTxsPerBlock;
     private advanceL2Block;
-    private tryFlushTxs;
 }
 //# 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,EAQZ,KAAK,GAAG,EAIT,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,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;;;;;;IAQL,QAAQ;;;;;;;IAarB;;;OAGG;YACW,YAAY;YASZ,0BAA0B;YAgC1B,gBAAgB;IAc9B;;OAEG;YACW,iBAAiB;IAK/B;;;;OAIG;YACW,UAAU;IA6BxB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;YAYZ,gBAAgB;YAoBhB,OAAO;YAwEP,wBAAwB;IAoBtC;;;OAGG;YACW,UAAU;YAuCV,gBAAgB;YAgChB,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,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,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;IAkCxB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;YAaZ,gBAAgB;YAqBhB,OAAO;YA0EP,wBAAwB;IAkBtC;;;OAGG;YACW,UAAU;YAmCV,gBAAgB;YAgChB,oBAAoB;YAapB,cAAc;CAM7B"}

package/dest/factory.js

@@ -51,10 +51,12 @@ 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
@@ -62,14 +64,16 @@ export class BotFactory {
     }
     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, liquidityToken);
+        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,
@@ -112,12 +116,10 @@ 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');
-            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;
         }
@@ -145,71 +147,80 @@ 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.
-   */ 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);
+            deploy = TokenContract.deploy(wallet, sender, '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 = EasyPrivateTokenContract.deploy(wallet, MINT_BALANCE, sender);
+            deployOpts.skipInstancePublication = true;
+            deployOpts.skipClassPublication = true;
             deployOpts.skipInitialization = false;
         } 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, contractAddressSalt, name, ticker, decimals = 18) {
+   */ setupTokenContract(wallet, deployer, contractAddressSalt, name, ticker, decimals = 18) {
         const deployOpts = {
+            from: deployer,
             contractAddressSalt,
             universalDeploy: true
         };
-        const deploy = TokenContract.deploy(wallet, wallet.getAddress(), name, ticker, decimals);
+        const deploy = TokenContract.deploy(wallet, deployer, name, ticker, decimals);
         return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
     }
-    async setupAmmContract(wallet, contractAddressSalt, token0, token1, lpToken) {
+    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();
-        this.log.info(`Set LP token minter to AMM txHash=${await minterTx.getTxHash()}`);
+        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, amm, token0, token1, lpToken) {
+    async fundAmm(wallet, liquidityProvider, amm, token0, token1, lpToken) {
         const getPrivateBalances = ()=>Promise.all([
-                token0.methods.balance_of_private(wallet.getAddress()).simulate(),
-                token1.methods.balance_of_private(wallet.getAddress()).simulate(),
-                lpToken.methods.balance_of_private(wallet.getAddress()).simulate()
+                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
@@ -218,31 +229,34 @@ export class BotFactory {
         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 ${wallet.getAddress()}: token0=${t0Bal}, token1=${t1Bal}, lp=${lpBal}`);
+        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(wallet.getAddress(), amm.address, amount0Max, authwitNonce)
+            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(wallet.getAddress(), amm.address, amount1Max, authwitNonce)
+            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(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()}`);
+            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()}`);
+        this.log.info(`Sent tx to add liquidity to the AMM: ${(await addLiquidityTx.getTxHash()).toString()}`);
         await addLiquidityTx.wait({
             timeout: this.config.txMinedWaitSeconds
         });
@@ -252,56 +266,52 @@ export class BotFactory {
     }
     async registerOrDeployContract(name, deploy, deployOpts) {
         const address = (await deploy.getInstance(deployOpts)).address;
-        if ((await this.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
+        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 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
-            });
+            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 ? token.methods.mint_to_private(from, sender, MINT_BALANCE) : token.methods.mint(MINT_BALANCE, sender));
+            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(token.methods.mint_to_public(sender, MINT_BALANCE));
+            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) {
         const l1RpcUrls = this.config.l1RpcUrls;
@@ -326,19 +336,26 @@ export class BotFactory {
         await this.advanceL2Block();
         return claim;
     }
-    async advanceL2Block() {
-        const initialBlockNumber = await this.node.getBlockNumber();
-        await this.tryFlushTxs();
-        await retryUntil(async ()=>await this.node.getBlockNumber() >= initialBlockNumber + 1);
-    }
-    async tryFlushTxs() {
-        if (this.config.flushSetupTransactions) {
-            this.log.verbose('Flushing transactions');
-            try {
-                await this.nodeAdmin.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
+            });
         }
     }
+    async advanceL2Block() {
+        await this.withNoMinTxsPerBlock(async ()=>{
+            const initialBlockNumber = await this.node.getBlockNumber();
+            await retryUntil(async ()=>await this.node.getBlockNumber() >= initialBlockNumber + 1);
+        });
+    }
 }

package/dest/utils.js

@@ -4,15 +4,21 @@
  * @param who - Address to get the balance for.
  * @returns - Private and public token balances as bigints.
  */ export async function getBalances(token, who) {
-    const privateBalance = await token.methods.balance_of_private(who).simulate();
-    const publicBalance = await token.methods.balance_of_public(who).simulate();
+    const privateBalance = await token.methods.balance_of_private(who).simulate({
+        from: who
+    });
+    const publicBalance = await token.methods.balance_of_public(who).simulate({
+        from: who
+    });
     return {
         privateBalance,
         publicBalance
     };
 }
 export async function getPrivateBalance(token, who) {
-    const privateBalance = await token.methods.get_balance(who).simulate();
+    const privateBalance = await token.methods.get_balance(who).simulate({
+        from: who
+    });
     return privateBalance;
 }
 export function isStandardTokenContract(token) {

package/package.json

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

package/src/amm_bot.ts

@@ -17,20 +17,24 @@ export class AmmBot extends BaseBot {
   protected constructor(
     pxe: PXE,
     wallet: Wallet,
+    defaultAccountAddress: AztecAddress,
     public readonly amm: AMMContract,
     public readonly token0: TokenContract,
     public readonly token1: TokenContract,
     config: BotConfig,
   ) {
-    super(pxe, wallet, config);
+    super(pxe, wallet, defaultAccountAddress, 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);
+    const { pxe, wallet, defaultAccountAddress, token0, token1, amm } = await new BotFactory(
+      config,
+      dependencies,
+    ).setupAmm();
+    return new AmmBot(pxe, wallet, defaultAccountAddress, amm, token0, token1, config);
   }
 
   protected async createAndSendTx(logCtx: object): Promise<SentTx> {
@@ -51,16 +55,16 @@ export class AmmBot extends BaseBot {
 
     const swapAuthwit = await wallet.createAuthWit({
       caller: amm.address,
-      action: tokenIn.methods.transfer_to_public(wallet.getAddress(), amm.address, amountIn, authwitNonce),
+      action: tokenIn.methods.transfer_to_public(this.defaultAccountAddress, amm.address, amountIn, authwitNonce),
     });
 
     const amountOutMin = await amm.methods
       .get_amount_out_for_exact_in(
-        await tokenIn.methods.balance_of_public(amm.address).simulate(),
-        await tokenOut.methods.balance_of_public(amm.address).simulate(),
+        await tokenIn.methods.balance_of_public(amm.address).simulate({ from: this.defaultAccountAddress }),
+        await tokenOut.methods.balance_of_public(amm.address).simulate({ from: this.defaultAccountAddress }),
         amountIn,
       )
-      .simulate();
+      .simulate({ from: this.defaultAccountAddress });
 
     const swapExactTokensInteraction = amm.methods.swap_exact_tokens_for_tokens(
       tokenIn.address,
@@ -91,22 +95,22 @@ export class AmmBot extends BaseBot {
 
   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()),
+      senderPublic: await this.getPublicBalanceFor(this.defaultAccountAddress),
+      senderPrivate: await this.getPrivateBalanceFor(this.defaultAccountAddress),
       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(),
+      token0: await this.token0.methods.balance_of_public(address).simulate({ from: address }),
+      token1: await this.token1.methods.balance_of_public(address).simulate({ from: address }),
     };
   }
   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(),
+      token0: await this.token0.methods.balance_of_private(address).simulate({ from: address }),
+      token1: await this.token1.methods.balance_of_private(address).simulate({ from: address }),
     };
   }
 }

package/src/base_bot.ts

@@ -1,5 +1,6 @@
 import {
   AuthWitness,
+  AztecAddress,
   FeeJuicePaymentMethod,
   type SendMethodOptions,
   SentTx,
@@ -23,6 +24,7 @@ export abstract class BaseBot {
   protected constructor(
     public readonly pxe: PXE,
     public readonly wallet: Wallet,
+    public readonly defaultAccountAddress: AztecAddress,
     public config: BotConfig,
   ) {}
 
@@ -37,12 +39,12 @@ export abstract class BaseBot {
     const txHash = await tx.getTxHash();
 
     if (followChain === 'NONE') {
-      this.log.info(`Transaction ${txHash} sent, not waiting for it to be mined`);
+      this.log.info(`Transaction ${txHash.toString()} sent, not waiting for it to be mined`);
       return txHash;
     }
 
     this.log.verbose(
-      `Awaiting tx ${txHash} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
+      `Awaiting tx ${txHash.toString()} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
       logCtx,
     );
     const receipt = await tx.wait({
@@ -70,9 +72,8 @@ export abstract class BaseBot {
   }
 
   protected getSendMethodOpts(...authWitnesses: AuthWitness[]): SendMethodOptions {
-    const sender = this.wallet.getAddress();
     const { l2GasLimit, daGasLimit } = this.config;
-    const paymentMethod = new FeeJuicePaymentMethod(sender);
+    const paymentMethod = new FeeJuicePaymentMethod(this.defaultAccountAddress);
 
     let gasSettings, estimateGas;
     if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
@@ -84,6 +85,10 @@ export abstract class BaseBot {
       this.log.verbose(`Estimating gas for transaction`);
     }
     const baseFeePadding = 2; // Send 3x the current base fee
-    return { fee: { estimateGas, paymentMethod, gasSettings, baseFeePadding }, authWitnesses };
+    return {
+      from: this.defaultAccountAddress,
+      fee: { estimateGas, paymentMethod, gasSettings, baseFeePadding },
+      authWitnesses,
+    };
   }
 }

package/src/bot.ts

@@ -15,19 +15,20 @@ export class Bot extends BaseBot {
   protected constructor(
     pxe: PXE,
     wallet: Wallet,
+    defaultAccountAddress: AztecAddress,
     public readonly token: TokenContract | EasyPrivateTokenContract,
     public readonly recipient: AztecAddress,
     config: BotConfig,
   ) {
-    super(pxe, wallet, config);
+    super(pxe, wallet, defaultAccountAddress, 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);
+    const { pxe, wallet, defaultAccountAddress, token, recipient } = await new BotFactory(config, dependencies).setup();
+    return new Bot(pxe, wallet, defaultAccountAddress, token, recipient, config);
   }
 
   public updateConfig(config: Partial<BotConfig>) {
@@ -38,7 +39,6 @@ export class Bot extends BaseBot {
   protected async createAndSendTx(logCtx: object): Promise<SentTx> {
     const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod } = this.config;
     const { token, recipient, wallet } = this;
-    const sender = wallet.getAddress();
 
     this.log.verbose(
       `Preparing tx with ${feePaymentMethod} fee with ${privateTransfersPerTx} private and ${publicTransfersPerTx} public transfers`,
@@ -48,15 +48,19 @@ export class Bot extends BaseBot {
     const calls = isStandardTokenContract(token)
       ? [
           times(privateTransfersPerTx, () => token.methods.transfer(recipient, TRANSFER_AMOUNT)),
-          times(publicTransfersPerTx, () => token.methods.transfer_in_public(sender, recipient, TRANSFER_AMOUNT, 0)),
+          times(publicTransfersPerTx, () =>
+            token.methods.transfer_in_public(this.defaultAccountAddress, recipient, TRANSFER_AMOUNT, 0),
+          ),
         ].flat()
-      : times(privateTransfersPerTx, () => token.methods.transfer(TRANSFER_AMOUNT, sender, recipient));
+      : times(privateTransfersPerTx, () =>
+          token.methods.transfer(TRANSFER_AMOUNT, this.defaultAccountAddress, recipient),
+        );
 
     const opts = this.getSendMethodOpts();
     const batch = new BatchCall(wallet, calls);
 
     this.log.verbose(`Simulating transaction with ${calls.length}`, logCtx);
-    await batch.simulate();
+    await batch.simulate({ from: this.defaultAccountAddress });
 
     this.log.verbose(`Proving transaction`, logCtx);
     const provenTx = await batch.prove(opts);
@@ -66,13 +70,13 @@ export class Bot extends BaseBot {
   public async getBalances() {
     if (isStandardTokenContract(this.token)) {
       return {
-        sender: await getBalances(this.token, this.wallet.getAddress()),
+        sender: await getBalances(this.token, this.defaultAccountAddress),
         recipient: await getBalances(this.token, this.recipient),
       };
     } else {
       return {
         sender: {
-          privateBalance: await getPrivateBalance(this.token, this.wallet.getAddress()),
+          privateBalance: await getPrivateBalance(this.token, this.defaultAccountAddress),
           publicBalance: 0n,
         },
         recipient: {

package/src/config.ts

@@ -42,11 +42,11 @@ export type BotConfig = {
   l1ToL2MessageTimeoutSeconds: number;
   /** Signing private key for the sender account. */
   senderPrivateKey: SecretValue<Fr | undefined>;
-  /** Optional salt to use to deploy the sender account */
+  /** Optional salt to use to instantiate the sender account */
   senderSalt: Fr | undefined;
   /** Encryption secret for a recipient account. */
   recipientEncryptionSecret: SecretValue<Fr>;
-  /** Salt for the token contract deployment. */
+  /** Salt for the token contract instantiation. */
   tokenSalt: Fr;
   /** Every how many seconds should a new tx be sent. */
   txIntervalSeconds: number;

package/src/factory.ts

@@ -74,22 +74,49 @@ export class BotFactory {
   public async setup() {
     const recipient = await this.registerRecipient();
     const wallet = await this.setupAccount();
-    const token = await this.setupToken(wallet);
-    await this.mintTokens(token);
-    return { wallet, token, pxe: this.pxe, recipient };
+    const defaultAccountAddress = wallet.getAddress();
+    const token = await this.setupToken(wallet, defaultAccountAddress);
+    await this.mintTokens(token, defaultAccountAddress);
+    return { wallet, defaultAccountAddress, token, pxe: this.pxe, recipient };
   }
 
   public 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);
+    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, amm, token0, token1, liquidityToken);
+    await this.fundAmm(wallet, wallet.getAddress(), amm, token0, token1, liquidityToken);
     this.log.info(`AMM initialized and funded`);
 
-    return { wallet, amm, token0, token1, pxe: this.pxe };
+    return { wallet, defaultAccountAddress, amm, token0, token1, pxe: this.pxe };
   }
 
   /**
@@ -128,10 +155,8 @@ export class BotFactory {
       const sentTx = account.deploy({ fee: { paymentMethod } });
       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');
-      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;
     }
@@ -164,32 +189,37 @@ export class BotFactory {
    * @param wallet - Wallet to deploy the token contract from.
    * @returns The TokenContract instance.
    */
-  private async setupToken(wallet: AccountWallet): Promise<TokenContract | EasyPrivateTokenContract> {
+  private async setupToken(
+    wallet: AccountWallet,
+    sender: AztecAddress,
+  ): Promise<TokenContract | EasyPrivateTokenContract> {
     let deploy: DeployMethod<TokenContract | EasyPrivateTokenContract>;
-    const deployOpts: DeployOptions = { contractAddressSalt: this.config.tokenSalt, universalDeploy: true };
+    const deployOpts: DeployOptions = {
+      from: sender,
+      contractAddressSalt: this.config.tokenSalt,
+      universalDeploy: true,
+    };
     if (this.config.contract === SupportedTokenContracts.TokenContract) {
-      deploy = TokenContract.deploy(wallet, wallet.getAddress(), 'BotToken', 'BOT', 18);
+      deploy = TokenContract.deploy(wallet, sender, '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 = EasyPrivateTokenContract.deploy(wallet, MINT_BALANCE, sender);
+      deployOpts.skipInstancePublication = true;
+      deployOpts.skipClassPublication = true;
       deployOpts.skipInitialization = false;
     } 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 }));
     }
   }
 
@@ -200,30 +230,32 @@ export class BotFactory {
    */
   private setupTokenContract(
     wallet: AccountWallet,
+    deployer: AztecAddress,
     contractAddressSalt: Fr,
     name: string,
     ticker: string,
     decimals = 18,
   ): Promise<TokenContract> {
-    const deployOpts: DeployOptions = { contractAddressSalt, universalDeploy: true };
-    const deploy = TokenContract.deploy(wallet, wallet.getAddress(), name, ticker, decimals);
+    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
+    const deploy = TokenContract.deploy(wallet, deployer, name, ticker, decimals);
     return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
   }
 
   private async setupAmmContract(
     wallet: AccountWallet,
+    deployer: AztecAddress,
     contractAddressSalt: Fr,
     token0: TokenContract,
     token1: TokenContract,
     lpToken: TokenContract,
   ): Promise<AMMContract> {
-    const deployOpts: DeployOptions = { contractAddressSalt, universalDeploy: true };
+    const deployOpts: DeployOptions = { 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();
-    this.log.info(`Set LP token minter to AMM txHash=${await minterTx.getTxHash()}`);
+    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`);
 
@@ -232,6 +264,7 @@ export class BotFactory {
 
   private async fundAmm(
     wallet: AccountWallet,
+    liquidityProvider: AztecAddress,
     amm: AMMContract,
     token0: TokenContract,
     token1: TokenContract,
@@ -239,9 +272,9 @@ export class BotFactory {
   ): Promise<void> {
     const getPrivateBalances = () =>
       Promise.all([
-        token0.methods.balance_of_private(wallet.getAddress()).simulate(),
-        token1.methods.balance_of_private(wallet.getAddress()).simulate(),
-        lpToken.methods.balance_of_private(wallet.getAddress()).simulate(),
+        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();
@@ -255,14 +288,14 @@ export class BotFactory {
     const [t0Bal, t1Bal, lpBal] = await getPrivateBalances();
 
     this.log.info(
-      `Minting ${MINT_BALANCE} tokens of each BotToken0 and BotToken1. Current private balances of ${wallet.getAddress()}: token0=${t0Bal}, token1=${t1Bal}, lp=${lpBal}`,
+      `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(
-        wallet.getAddress(),
+        liquidityProvider,
         amm.address,
         amount0Max,
         authwitNonce,
@@ -271,7 +304,7 @@ export class BotFactory {
     const token1Authwit = await wallet.createAuthWit({
       caller: amm.address,
       action: token1.methods.transfer_to_public_and_prepare_private_balance_increase(
-        wallet.getAddress(),
+        liquidityProvider,
         amm.address,
         amount1Max,
         authwitNonce,
@@ -279,20 +312,21 @@ export class BotFactory {
     });
 
     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();
+      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()}`);
+    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()}`);
+    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`);
 
@@ -308,17 +342,15 @@ export class BotFactory {
     deployOpts: DeployOptions,
   ): Promise<T> {
     const address = (await deploy.getInstance(deployOpts)).address;
-    if ((await this.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
+    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 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 });
+      this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
+      return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
     }
   }
 
@@ -326,43 +358,39 @@ export class BotFactory {
    * Mints private and public tokens for the sender if their balance is below the minimum.
    * @param token - Token contract.
    */
-  private async mintTokens(token: TokenContract | EasyPrivateTokenContract) {
-    const sender = token.wallet.getAddress();
+  private async mintTokens(token: TokenContract | EasyPrivateTokenContract, minter: AztecAddress) {
     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: ContractFunctionInteraction[] = [];
     if (privateBalance < MIN_BALANCE) {
-      this.log.info(`Minting private tokens for ${sender.toString()}`);
+      this.log.info(`Minting private tokens for ${minter.toString()}`);
 
-      const from = sender; // we are setting from to sender here because we need a sender to calculate the tag
       calls.push(
         isStandardToken
-          ? token.methods.mint_to_private(from, sender, MINT_BALANCE)
-          : token.methods.mint(MINT_BALANCE, sender),
+          ? 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(token.methods.mint_to_public(sender, MINT_BALANCE));
+      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 sentTx = new BatchCall(token.wallet, calls).send({ from: minter });
     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 });
+    this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
+    await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
   }
 
   private async bridgeL1FeeJuice(recipient: AztecAddress) {
@@ -397,20 +425,23 @@ export class BotFactory {
     return claim;
   }
 
-  private async advanceL2Block() {
-    const initialBlockNumber = await this.node!.getBlockNumber();
-    await this.tryFlushTxs();
-    await retryUntil(async () => (await this.node!.getBlockNumber()) >= initialBlockNumber + 1);
+  private async withNoMinTxsPerBlock<T>(fn: () => Promise<T>): Promise<T> {
+    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 });
+    }
   }
 
-  private async tryFlushTxs() {
-    if (this.config.flushSetupTransactions) {
-      this.log.verbose('Flushing transactions');
-      try {
-        await this.nodeAdmin!.flushTxs();
-      } catch (err) {
-        this.log.error(`Failed to flush transactions: ${err}`);
-      }
-    }
+  private async advanceL2Block() {
+    await this.withNoMinTxsPerBlock(async () => {
+      const initialBlockNumber = await this.node!.getBlockNumber();
+      await retryUntil(async () => (await this.node!.getBlockNumber()) >= initialBlockNumber + 1);
+    });
   }
 }

package/src/utils.ts

@@ -14,13 +14,13 @@ export async function getBalances(
   token: TokenContract,
   who: AztecAddress,
 ): Promise<{ privateBalance: bigint; publicBalance: bigint }> {
-  const privateBalance = await token.methods.balance_of_private(who).simulate();
-  const publicBalance = await token.methods.balance_of_public(who).simulate();
+  const privateBalance = await token.methods.balance_of_private(who).simulate({ from: who });
+  const publicBalance = await token.methods.balance_of_public(who).simulate({ from: who });
   return { privateBalance, publicBalance };
 }
 
 export async function getPrivateBalance(token: EasyPrivateTokenContract, who: AztecAddress): Promise<bigint> {
-  const privateBalance = await token.methods.get_balance(who).simulate();
+  const privateBalance = await token.methods.get_balance(who).simulate({ from: who });
   return privateBalance;
 }