@aztec/bot 0.0.1-fake-c83136db25 → 0.0.1-private.d0bedffd

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. package/dest/amm_bot.d.ts +6 -7
  2. package/dest/amm_bot.d.ts.map +1 -1
  3. package/dest/amm_bot.js +27 -16
  4. package/dest/base_bot.d.ts +6 -6
  5. package/dest/base_bot.d.ts.map +1 -1
  6. package/dest/base_bot.js +14 -15
  7. package/dest/bot.d.ts +6 -6
  8. package/dest/bot.d.ts.map +1 -1
  9. package/dest/bot.js +8 -4
  10. package/dest/config.d.ts +73 -58
  11. package/dest/config.d.ts.map +1 -1
  12. package/dest/config.js +44 -17
  13. package/dest/cross_chain_bot.d.ts +54 -0
  14. package/dest/cross_chain_bot.d.ts.map +1 -0
  15. package/dest/cross_chain_bot.js +134 -0
  16. package/dest/factory.d.ts +18 -26
  17. package/dest/factory.d.ts.map +1 -1
  18. package/dest/factory.js +178 -82
  19. package/dest/index.d.ts +2 -1
  20. package/dest/index.d.ts.map +1 -1
  21. package/dest/index.js +1 -0
  22. package/dest/interface.d.ts +1 -1
  23. package/dest/l1_to_l2_seeding.d.ts +8 -0
  24. package/dest/l1_to_l2_seeding.d.ts.map +1 -0
  25. package/dest/l1_to_l2_seeding.js +63 -0
  26. package/dest/rpc.d.ts +1 -1
  27. package/dest/runner.d.ts +3 -3
  28. package/dest/runner.d.ts.map +1 -1
  29. package/dest/runner.js +429 -31
  30. package/dest/store/bot_store.d.ts +30 -5
  31. package/dest/store/bot_store.d.ts.map +1 -1
  32. package/dest/store/bot_store.js +38 -7
  33. package/dest/store/index.d.ts +2 -2
  34. package/dest/store/index.d.ts.map +1 -1
  35. package/dest/utils.d.ts +1 -1
  36. package/dest/utils.js +3 -3
  37. package/package.json +19 -15
  38. package/src/amm_bot.ts +26 -21
  39. package/src/base_bot.ts +13 -27
  40. package/src/bot.ts +10 -8
  41. package/src/config.ts +90 -60
  42. package/src/cross_chain_bot.ts +203 -0
  43. package/src/factory.ts +214 -66
  44. package/src/index.ts +1 -0
  45. package/src/l1_to_l2_seeding.ts +79 -0
  46. package/src/runner.ts +18 -5
  47. package/src/store/bot_store.ts +61 -6
  48. package/src/store/index.ts +1 -1
  49. package/src/utils.ts +3 -3
@@ -0,0 +1,203 @@
1
+ /**
2
+ * CrossChainBot exercises L2->L1 and L1->L2 messaging.
3
+ *
4
+ * createAndSendTx onTxMined
5
+ * ────────────────────────────────────── ──────────────────────────────
6
+ *
7
+ * 1. SEED (fire-and-forget) 3. VERIFY L2->L1
8
+ * if store has fewer pending messages Query getTxEffect, confirm
9
+ * than seedCount and no seed is the expected L2->L1 messages
10
+ * in-flight: appeared in tx effects.
11
+ * * kick off L1 inbox tx
12
+ * * store msg on completion
13
+ *
14
+ * 2. BUILD & SEND BATCH
15
+ * Always:
16
+ * N x create_l2_to_l1_message
17
+ * (random content, fixed
18
+ * L1 recipient)
19
+ * If a ready L1->L2 msg exists:
20
+ * 1 x consume_message_from_
21
+ * arbitrary_sender_public
22
+ * delete consumed msg from store
23
+ * Send batch tx (no wait)
24
+ *
25
+ */
26
+ import { AztecAddress } from '@aztec/aztec.js/addresses';
27
+ import { BatchCall, NO_WAIT } from '@aztec/aztec.js/contracts';
28
+ import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
29
+ import { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
30
+ import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
31
+ import { Fr } from '@aztec/foundation/curves/bn254';
32
+ import { EthAddress } from '@aztec/foundation/eth-address';
33
+ import type { TestContract } from '@aztec/noir-test-contracts.js/Test';
34
+ import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
35
+ import type { EmbeddedWallet } from '@aztec/wallets/embedded';
36
+
37
+ import { BaseBot } from './base_bot.js';
38
+ import type { BotConfig } from './config.js';
39
+ import { BotFactory } from './factory.js';
40
+ import { seedL1ToL2Message } from './l1_to_l2_seeding.js';
41
+ import type { BotStore, PendingL1ToL2Message } from './store/index.js';
42
+
43
+ /** Stale message threshold: messages older than this are removed. */
44
+ const STALE_MESSAGE_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
45
+
46
+ /** Bot that exercises both L2→L1 and L1→L2 cross-chain messaging. */
47
+ export class CrossChainBot extends BaseBot {
48
+ private l2ToL1Sent = 0;
49
+ private l1ToL2Consumed = 0;
50
+ private pendingSeedPromise: Promise<void> | undefined;
51
+
52
+ protected constructor(
53
+ node: AztecNode,
54
+ wallet: EmbeddedWallet,
55
+ defaultAccountAddress: AztecAddress,
56
+ private readonly contract: TestContract,
57
+ private readonly l1Client: ExtendedViemWalletClient,
58
+ private readonly l1Recipient: EthAddress,
59
+ private readonly inboxAddress: EthAddress,
60
+ private readonly rollupVersion: bigint,
61
+ private readonly store: BotStore,
62
+ config: BotConfig,
63
+ ) {
64
+ super(node, wallet, defaultAccountAddress, config);
65
+ }
66
+
67
+ static async create(
68
+ config: BotConfig,
69
+ wallet: EmbeddedWallet,
70
+ aztecNode: AztecNode,
71
+ aztecNodeAdmin: AztecNodeAdmin | undefined,
72
+ store: BotStore,
73
+ ): Promise<CrossChainBot> {
74
+ if (config.followChain === 'NONE') {
75
+ throw new Error(`CrossChainBot requires followChain to be set (got NONE)`);
76
+ }
77
+ const factory = new BotFactory(config, wallet, store, aztecNode, aztecNodeAdmin);
78
+ const { defaultAccountAddress, contract, l1Client, rollupVersion } = await factory.setupCrossChain();
79
+ const l1Recipient = EthAddress.fromString(l1Client.account!.address);
80
+ const { l1ContractAddresses } = await aztecNode.getNodeInfo();
81
+ const inboxAddress = EthAddress.fromString(l1ContractAddresses.inboxAddress.toString());
82
+ return new CrossChainBot(
83
+ aztecNode,
84
+ wallet,
85
+ defaultAccountAddress,
86
+ contract,
87
+ l1Client,
88
+ l1Recipient,
89
+ inboxAddress,
90
+ rollupVersion,
91
+ store,
92
+ config,
93
+ );
94
+ }
95
+
96
+ protected async createAndSendTx(logCtx: object): Promise<TxHash> {
97
+ const pendingMessages = await this.store.getUnconsumedL1ToL2Messages();
98
+
99
+ // Send an L1→L2 message if we're below the threshold and not already seeding one
100
+ if (pendingMessages.length < this.config.l1ToL2SeedCount && !this.pendingSeedPromise) {
101
+ this.pendingSeedPromise = this.seedNewL1ToL2Message()
102
+ .catch(err => this.log.warn(`Failed to seed L1→L2 message: ${err}`, logCtx))
103
+ .finally(() => {
104
+ this.pendingSeedPromise = undefined;
105
+ });
106
+ }
107
+
108
+ // Build batch: always L2→L1, optionally consume L1→L2
109
+ const calls = [];
110
+
111
+ // L2→L1: create messages with random content
112
+ for (let i = 0; i < this.config.l2ToL1MessagesPerTx; i++) {
113
+ calls.push(
114
+ this.contract.methods.create_l2_to_l1_message_arbitrary_recipient_public(Fr.random(), this.l1Recipient),
115
+ );
116
+ }
117
+
118
+ // L1→L2: consume oldest ready message if available
119
+ const readyMsg = await this.getReadyL1ToL2Message(pendingMessages);
120
+ if (readyMsg) {
121
+ calls.push(
122
+ this.contract.methods.consume_message_from_arbitrary_sender_public(
123
+ Fr.fromHexString(readyMsg.content),
124
+ Fr.fromHexString(readyMsg.secret),
125
+ EthAddress.fromString(readyMsg.sender),
126
+ new Fr(BigInt(readyMsg.globalLeafIndex)),
127
+ ),
128
+ );
129
+ // Delete consumed message immediately so it works with FOLLOW_CHAIN=NONE
130
+ await this.store.deleteL1ToL2Message(readyMsg.msgHash);
131
+ this.l1ToL2Consumed++;
132
+ } else {
133
+ this.log.warn(`No ready L1→L2 message to consume`, {
134
+ ...logCtx,
135
+ pendingCount: pendingMessages.length,
136
+ });
137
+ }
138
+
139
+ const batch = new BatchCall(this.wallet, calls);
140
+ const opts = await this.getSendMethodOpts(batch);
141
+
142
+ this.log.verbose(`Sending cross-chain batch with ${calls.length} calls`, logCtx);
143
+ const { txHash } = await batch.send({ ...opts, wait: NO_WAIT });
144
+ return txHash;
145
+ }
146
+
147
+ protected override async onTxMined(receipt: TxReceipt, logCtx: object): Promise<void> {
148
+ // Verify L2→L1 messages appeared in this tx's effects
149
+ const indexed = await this.node.getTxEffect(receipt.txHash);
150
+ if (indexed) {
151
+ const l2ToL1Msgs = indexed.data.l2ToL1Msgs.filter(m => !m.isZero());
152
+ if (l2ToL1Msgs.length >= this.config.l2ToL1MessagesPerTx) {
153
+ this.l2ToL1Sent += l2ToL1Msgs.length;
154
+ } else {
155
+ this.log.error(`Expected ${this.config.l2ToL1MessagesPerTx} L2→L1 messages but found ${l2ToL1Msgs.length}`, {
156
+ ...logCtx,
157
+ blockNumber: receipt.blockNumber,
158
+ txHash: receipt.txHash.toString(),
159
+ });
160
+ }
161
+ }
162
+
163
+ const pendingCount = (await this.store.getUnconsumedL1ToL2Messages()).length;
164
+ this.log.info(`CrossChainBot txs mined`, {
165
+ ...logCtx,
166
+ l2ToL1Sent: this.l2ToL1Sent,
167
+ l1ToL2Consumed: this.l1ToL2Consumed,
168
+ l1ToL2Pending: pendingCount,
169
+ });
170
+ }
171
+
172
+ /** Finds the oldest pending message that is ready for consumption. */
173
+ private async getReadyL1ToL2Message(
174
+ pendingMessages: PendingL1ToL2Message[],
175
+ ): Promise<PendingL1ToL2Message | undefined> {
176
+ const now = Date.now();
177
+ for (const msg of pendingMessages) {
178
+ const ready = await isL1ToL2MessageReady(this.node, Fr.fromHexString(msg.msgHash));
179
+ if (ready) {
180
+ return msg;
181
+ }
182
+
183
+ // Time-based stale detection: if the message is old and still not ready, remove it
184
+ if (now - msg.timestamp > STALE_MESSAGE_THRESHOLD_MS) {
185
+ await this.store.deleteL1ToL2Message(msg.msgHash);
186
+ this.log.warn(`Removed stale L1→L2 message ${msg.msgHash}`);
187
+ }
188
+ }
189
+ return undefined;
190
+ }
191
+
192
+ /** Seeds a new L1→L2 message on L1 and stores it. */
193
+ private async seedNewL1ToL2Message(): Promise<void> {
194
+ await seedL1ToL2Message(
195
+ this.l1Client,
196
+ this.inboxAddress,
197
+ this.contract.address,
198
+ this.rollupVersion,
199
+ this.store,
200
+ this.log,
201
+ );
202
+ }
203
+ }
package/src/factory.ts CHANGED
@@ -1,4 +1,3 @@
1
- import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
2
1
  import { getInitialTestAccountsData } from '@aztec/accounts/testing';
3
2
  import { AztecAddress } from '@aztec/aztec.js/addresses';
4
3
  import {
@@ -7,24 +6,34 @@ import {
7
6
  ContractFunctionInteraction,
8
7
  type DeployMethod,
9
8
  type DeployOptions,
9
+ NO_WAIT,
10
10
  } from '@aztec/aztec.js/contracts';
11
- import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
12
11
  import type { L2AmountClaim } from '@aztec/aztec.js/ethereum';
12
+ import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
13
13
  import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
14
+ import { deriveKeys } from '@aztec/aztec.js/keys';
14
15
  import { createLogger } from '@aztec/aztec.js/log';
15
16
  import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
16
- import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
17
- import { Fr } from '@aztec/foundation/fields';
17
+ import { waitForTx } from '@aztec/aztec.js/node';
18
+ import { createEthereumChain } from '@aztec/ethereum/chain';
19
+ import { createExtendedL1Client } from '@aztec/ethereum/client';
20
+ import { RollupContract } from '@aztec/ethereum/contracts';
21
+ import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
22
+ import { Fr } from '@aztec/foundation/curves/bn254';
23
+ import { EthAddress } from '@aztec/foundation/eth-address';
18
24
  import { Timer } from '@aztec/foundation/timer';
19
25
  import { AMMContract } from '@aztec/noir-contracts.js/AMM';
20
26
  import { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
21
27
  import { TokenContract } from '@aztec/noir-contracts.js/Token';
28
+ import { TestContract } from '@aztec/noir-test-contracts.js/Test';
29
+ import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
22
30
  import { GasSettings } from '@aztec/stdlib/gas';
23
31
  import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
24
32
  import { deriveSigningKey } from '@aztec/stdlib/keys';
25
- import { TestWallet } from '@aztec/test-wallet/server';
33
+ import { EmbeddedWallet } from '@aztec/wallets/embedded';
26
34
 
27
35
  import { type BotConfig, SupportedTokenContracts } from './config.js';
36
+ import { seedL1ToL2Message } from './l1_to_l2_seeding.js';
28
37
  import type { BotStore } from './store/index.js';
29
38
  import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
30
39
 
@@ -36,25 +45,42 @@ export class BotFactory {
36
45
 
37
46
  constructor(
38
47
  private readonly config: BotConfig,
39
- private readonly wallet: TestWallet,
48
+ private readonly wallet: EmbeddedWallet,
40
49
  private readonly store: BotStore,
41
50
  private readonly aztecNode: AztecNode,
42
51
  private readonly aztecNodeAdmin?: AztecNodeAdmin,
43
- ) {}
52
+ ) {
53
+ // Set fee padding on the wallet so that all transactions during setup
54
+ // (token deploy, minting, etc.) use the configured padding, not the default.
55
+ this.wallet.setMinFeePadding(config.minFeePadding);
56
+ }
44
57
 
45
58
  /**
46
59
  * Initializes a new bot by setting up the sender account, registering the recipient,
47
60
  * deploying the token contract, and minting tokens if necessary.
48
61
  */
49
- public async setup() {
50
- const recipient = (await this.wallet.createAccount()).address;
62
+ public async setup(): Promise<{
63
+ wallet: EmbeddedWallet;
64
+ defaultAccountAddress: AztecAddress;
65
+ token: TokenContract | PrivateTokenContract;
66
+ node: AztecNode;
67
+ recipient: AztecAddress;
68
+ }> {
51
69
  const defaultAccountAddress = await this.setupAccount();
70
+ const recipient = (await this.wallet.createSchnorrAccount(Fr.random(), Fr.random())).address;
52
71
  const token = await this.setupToken(defaultAccountAddress);
53
72
  await this.mintTokens(token, defaultAccountAddress);
54
73
  return { wallet: this.wallet, defaultAccountAddress, token, node: this.aztecNode, recipient };
55
74
  }
56
75
 
57
- public async setupAmm() {
76
+ public async setupAmm(): Promise<{
77
+ wallet: EmbeddedWallet;
78
+ defaultAccountAddress: AztecAddress;
79
+ amm: AMMContract;
80
+ token0: TokenContract;
81
+ token1: TokenContract;
82
+ node: AztecNode;
83
+ }> {
58
84
  const defaultAccountAddress = await this.setupAccount();
59
85
  const token0 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken0', 'BOT0');
60
86
  const token1 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken1', 'BOT1');
@@ -78,6 +104,89 @@ export class BotFactory {
78
104
  return { wallet: this.wallet, defaultAccountAddress, amm, token0, token1, node: this.aztecNode };
79
105
  }
80
106
 
107
+ /**
108
+ * Initializes the cross-chain bot by deploying TestContract, creating an L1 client,
109
+ * seeding initial L1→L2 messages, and waiting for the first to be ready.
110
+ */
111
+ public async setupCrossChain(): Promise<{
112
+ wallet: EmbeddedWallet;
113
+ defaultAccountAddress: AztecAddress;
114
+ contract: TestContract;
115
+ node: AztecNode;
116
+ l1Client: ExtendedViemWalletClient;
117
+ rollupVersion: bigint;
118
+ }> {
119
+ const defaultAccountAddress = await this.setupAccount();
120
+
121
+ // Create L1 client (same pattern as bridgeL1FeeJuice)
122
+ const l1RpcUrls = this.config.l1RpcUrls;
123
+ if (!l1RpcUrls?.length) {
124
+ throw new Error('L1 RPC URLs required for cross-chain bot');
125
+ }
126
+ const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
127
+ if (!mnemonicOrPrivateKey) {
128
+ throw new Error('L1 mnemonic or private key required for cross-chain bot');
129
+ }
130
+ const { l1ChainId, l1ContractAddresses } = await this.aztecNode.getNodeInfo();
131
+ const chain = createEthereumChain(l1RpcUrls, l1ChainId);
132
+ const l1Client = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
133
+
134
+ // Fetch Rollup version (needed for Inbox L2Actor struct)
135
+ const rollupContract = new RollupContract(l1Client, l1ContractAddresses.rollupAddress.toString());
136
+ const rollupVersion = await rollupContract.getVersion();
137
+
138
+ // Deploy TestContract
139
+ const contract = await this.setupTestContract(defaultAccountAddress);
140
+
141
+ // Recover any pending messages from store (clean up stale ones first)
142
+ await this.store.cleanupOldPendingMessages();
143
+ const pendingMessages = await this.store.getUnconsumedL1ToL2Messages();
144
+
145
+ // Seed initial L1→L2 messages if pipeline is empty
146
+ const seedCount = Math.max(0, this.config.l1ToL2SeedCount - pendingMessages.length);
147
+ for (let i = 0; i < seedCount; i++) {
148
+ await seedL1ToL2Message(
149
+ l1Client,
150
+ EthAddress.fromString(l1ContractAddresses.inboxAddress.toString()),
151
+ contract.address,
152
+ rollupVersion,
153
+ this.store,
154
+ this.log,
155
+ );
156
+ }
157
+
158
+ // Block until at least one message is ready
159
+ const allMessages = await this.store.getUnconsumedL1ToL2Messages();
160
+ if (allMessages.length > 0) {
161
+ this.log.info(`Waiting for first L1→L2 message to be ready...`);
162
+ const firstMsg = allMessages[0];
163
+ await waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(firstMsg.msgHash), {
164
+ timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
165
+ });
166
+ this.log.info(`First L1→L2 message is ready`);
167
+ }
168
+
169
+ return {
170
+ wallet: this.wallet,
171
+ defaultAccountAddress,
172
+ contract,
173
+ node: this.aztecNode,
174
+ l1Client,
175
+ rollupVersion,
176
+ };
177
+ }
178
+
179
+ private async setupTestContract(deployer: AztecAddress): Promise<TestContract> {
180
+ const deployOpts: DeployOptions = {
181
+ from: deployer,
182
+ contractAddressSalt: this.config.tokenSalt,
183
+ universalDeploy: true,
184
+ };
185
+ const deploy = TestContract.deploy(this.wallet);
186
+ const instance = await this.registerOrDeployContract('TestContract', deploy, deployOpts);
187
+ return TestContract.at(instance.address, this.wallet);
188
+ }
189
+
81
190
  /**
82
191
  * Checks if the sender account contract is initialized, and initializes it if necessary.
83
192
  * @returns The sender wallet.
@@ -96,14 +205,9 @@ export class BotFactory {
96
205
  private async setupAccountWithPrivateKey(secret: Fr) {
97
206
  const salt = this.config.senderSalt ?? Fr.ONE;
98
207
  const signingKey = deriveSigningKey(secret);
99
- const accountData = {
100
- secret,
101
- salt,
102
- contract: new SchnorrAccountContract(signingKey!),
103
- };
104
- const accountManager = await this.wallet.createAccount(accountData);
105
- const isInit = (await this.wallet.getContractMetadata(accountManager.address)).isContractInitialized;
106
- if (isInit) {
208
+ const accountManager = await this.wallet.createSchnorrAccount(secret, salt, signingKey);
209
+ const metadata = await this.wallet.getContractMetadata(accountManager.address);
210
+ if (metadata.isContractInitialized) {
107
211
  this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
108
212
  const timer = new Timer();
109
213
  const address = accountManager.address;
@@ -118,12 +222,18 @@ export class BotFactory {
118
222
 
119
223
  const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
120
224
  const deployMethod = await accountManager.getDeployMethod();
121
- const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.config.baseFeePadding);
225
+ const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1 + this.config.minFeePadding);
122
226
  const gasSettings = GasSettings.default({ maxFeesPerGas });
123
- const sentTx = deployMethod.send({ from: AztecAddress.ZERO, fee: { gasSettings, paymentMethod } });
124
- const txHash = await sentTx.getTxHash();
125
- this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
126
- await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
227
+
228
+ await this.withNoMinTxsPerBlock(async () => {
229
+ const { txHash } = await deployMethod.send({
230
+ from: AztecAddress.ZERO,
231
+ fee: { gasSettings, paymentMethod },
232
+ wait: NO_WAIT,
233
+ });
234
+ this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
235
+ return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
236
+ });
127
237
  this.log.info(`Account deployed at ${address}`);
128
238
 
129
239
  // Clean up the consumed bridge claim
@@ -135,12 +245,11 @@ export class BotFactory {
135
245
 
136
246
  private async setupTestAccount() {
137
247
  const [initialAccountData] = await getInitialTestAccountsData();
138
- const accountData = {
139
- secret: initialAccountData.secret,
140
- salt: initialAccountData.salt,
141
- contract: new SchnorrAccountContract(initialAccountData.signingKey),
142
- };
143
- const accountManager = await this.wallet.createAccount(accountData);
248
+ const accountManager = await this.wallet.createSchnorrAccount(
249
+ initialAccountData.secret,
250
+ initialAccountData.salt,
251
+ initialAccountData.signingKey,
252
+ );
144
253
  return accountManager.address;
145
254
  }
146
255
 
@@ -151,33 +260,51 @@ export class BotFactory {
151
260
  */
152
261
  private async setupToken(sender: AztecAddress): Promise<TokenContract | PrivateTokenContract> {
153
262
  let deploy: DeployMethod<TokenContract | PrivateTokenContract>;
263
+ let tokenInstance: ContractInstanceWithAddress | undefined;
154
264
  const deployOpts: DeployOptions = {
155
265
  from: sender,
156
266
  contractAddressSalt: this.config.tokenSalt,
157
267
  universalDeploy: true,
158
268
  };
269
+ let token: TokenContract | PrivateTokenContract;
159
270
  if (this.config.contract === SupportedTokenContracts.TokenContract) {
160
271
  deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
272
+ tokenInstance = await deploy.getInstance(deployOpts);
273
+ token = TokenContract.at(tokenInstance.address, this.wallet);
161
274
  } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
162
- deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender);
275
+ // Generate keys for the contract since PrivateToken uses SinglePrivateMutable which requires keys
276
+ const tokenSecretKey = Fr.random();
277
+ const tokenPublicKeys = (await deriveKeys(tokenSecretKey)).publicKeys;
278
+ deploy = PrivateTokenContract.deployWithPublicKeys(tokenPublicKeys, this.wallet, MINT_BALANCE, sender);
163
279
  deployOpts.skipInstancePublication = true;
164
280
  deployOpts.skipClassPublication = true;
165
281
  deployOpts.skipInitialization = false;
282
+
283
+ // Register the contract with the secret key before deployment
284
+ tokenInstance = await deploy.getInstance(deployOpts);
285
+ token = PrivateTokenContract.at(tokenInstance.address, this.wallet);
286
+ await this.wallet.registerContract(tokenInstance, PrivateTokenContract.artifact, tokenSecretKey);
287
+ // The contract constructor initializes private storage vars that need the contract's own nullifier key.
288
+ deployOpts.additionalScopes = [tokenInstance.address];
166
289
  } else {
167
290
  throw new Error(`Unsupported token contract type: ${this.config.contract}`);
168
291
  }
169
292
 
170
- const address = (await deploy.getInstance(deployOpts)).address;
171
- if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
293
+ const address = tokenInstance?.address ?? (await deploy.getInstance(deployOpts)).address;
294
+ const metadata = await this.wallet.getContractMetadata(address);
295
+ if (metadata.isContractPublished) {
172
296
  this.log.info(`Token at ${address.toString()} already deployed`);
173
- return deploy.register();
297
+ await deploy.register();
174
298
  } else {
175
299
  this.log.info(`Deploying token contract at ${address.toString()}`);
176
- const sentTx = deploy.send(deployOpts);
177
- const txHash = await sentTx.getTxHash();
300
+ const { txHash } = await deploy.send({ ...deployOpts, wait: NO_WAIT });
178
301
  this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
179
- return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
302
+ await this.withNoMinTxsPerBlock(async () => {
303
+ await waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
304
+ return token;
305
+ });
180
306
  }
307
+ return token;
181
308
  }
182
309
 
183
310
  /**
@@ -185,7 +312,7 @@ export class BotFactory {
185
312
  * @param wallet - Wallet to deploy the token contract from.
186
313
  * @returns The TokenContract instance.
187
314
  */
188
- private setupTokenContract(
315
+ private async setupTokenContract(
189
316
  deployer: AztecAddress,
190
317
  contractAddressSalt: Fr,
191
318
  name: string,
@@ -194,7 +321,8 @@ export class BotFactory {
194
321
  ): Promise<TokenContract> {
195
322
  const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
196
323
  const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
197
- return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
324
+ const instance = await this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
325
+ return TokenContract.at(instance.address, this.wallet);
198
326
  }
199
327
 
200
328
  private async setupAmmContract(
@@ -206,12 +334,14 @@ export class BotFactory {
206
334
  ): Promise<AMMContract> {
207
335
  const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
208
336
  const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address);
209
- const amm = await this.registerOrDeployContract('AMM', deploy, deployOpts);
337
+ const instance = await this.registerOrDeployContract('AMM', deploy, deployOpts);
338
+ const amm = AMMContract.at(instance.address, this.wallet);
210
339
 
211
340
  this.log.info(`AMM deployed at ${amm.address}`);
212
- const minterTx = lpToken.methods.set_minter(amm.address, true).send({ from: deployer });
213
- this.log.info(`Set LP token minter to AMM txHash=${(await minterTx.getTxHash()).toString()}`);
214
- await minterTx.wait({ timeout: this.config.txMinedWaitSeconds });
341
+ const { receipt: minterReceipt } = await lpToken.methods
342
+ .set_minter(amm.address, true)
343
+ .send({ from: deployer, wait: { timeout: this.config.txMinedWaitSeconds } });
344
+ this.log.info(`Set LP token minter to AMM txHash=${minterReceipt.txHash.toString()}`);
215
345
  this.log.info(`Liquidity token initialized`);
216
346
 
217
347
  return amm;
@@ -227,9 +357,18 @@ export class BotFactory {
227
357
  ): Promise<void> {
228
358
  const getPrivateBalances = () =>
229
359
  Promise.all([
230
- token0.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
231
- token1.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
232
- lpToken.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
360
+ token0.methods
361
+ .balance_of_private(liquidityProvider)
362
+ .simulate({ from: liquidityProvider })
363
+ .then(r => r.result),
364
+ token1.methods
365
+ .balance_of_private(liquidityProvider)
366
+ .simulate({ from: liquidityProvider })
367
+ .then(r => r.result),
368
+ lpToken.methods
369
+ .balance_of_private(liquidityProvider)
370
+ .simulate({ from: liquidityProvider })
371
+ .then(r => r.result),
233
372
  ]);
234
373
 
235
374
  const authwitNonce = Fr.random();
@@ -270,23 +409,22 @@ export class BotFactory {
270
409
  .getFunctionCall(),
271
410
  });
272
411
 
273
- const mintTx = new BatchCall(this.wallet, [
412
+ const { receipt: mintReceipt } = await new BatchCall(this.wallet, [
274
413
  token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
275
414
  token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
276
- ]).send({ from: liquidityProvider });
415
+ ]).send({ from: liquidityProvider, wait: { timeout: this.config.txMinedWaitSeconds } });
277
416
 
278
- this.log.info(`Sent mint tx: ${(await mintTx.getTxHash()).toString()}`);
279
- await mintTx.wait({ timeout: this.config.txMinedWaitSeconds });
417
+ this.log.info(`Sent mint tx: ${mintReceipt.txHash.toString()}`);
280
418
 
281
- const addLiquidityTx = amm.methods
419
+ const { receipt: addLiquidityReceipt } = await amm.methods
282
420
  .add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce)
283
421
  .send({
284
422
  from: liquidityProvider,
285
423
  authWitnesses: [token0Authwit, token1Authwit],
424
+ wait: { timeout: this.config.txMinedWaitSeconds },
286
425
  });
287
426
 
288
- this.log.info(`Sent tx to add liquidity to the AMM: ${(await addLiquidityTx.getTxHash()).toString()}`);
289
- await addLiquidityTx.wait({ timeout: this.config.txMinedWaitSeconds });
427
+ this.log.info(`Sent tx to add liquidity to the AMM: ${addLiquidityReceipt.txHash.toString()}`);
290
428
  this.log.info(`Liquidity added`);
291
429
 
292
430
  const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
@@ -299,18 +437,22 @@ export class BotFactory {
299
437
  name: string,
300
438
  deploy: DeployMethod<T>,
301
439
  deployOpts: DeployOptions,
302
- ): Promise<T> {
303
- const address = (await deploy.getInstance(deployOpts)).address;
304
- if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
440
+ ): Promise<ContractInstanceWithAddress> {
441
+ const instance = await deploy.getInstance(deployOpts);
442
+ const address = instance.address;
443
+ const metadata = await this.wallet.getContractMetadata(address);
444
+ if (metadata.isContractPublished) {
305
445
  this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
306
- return deploy.register();
446
+ await deploy.register();
307
447
  } else {
308
448
  this.log.info(`Deploying contract ${name} at ${address.toString()}`);
309
- const sentTx = deploy.send(deployOpts);
310
- const txHash = await sentTx.getTxHash();
311
- this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
312
- return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
449
+ await this.withNoMinTxsPerBlock(async () => {
450
+ const { txHash } = await deploy.send({ ...deployOpts, wait: NO_WAIT });
451
+ this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
452
+ return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
453
+ });
313
454
  }
455
+ return instance;
314
456
  }
315
457
 
316
458
  /**
@@ -346,10 +488,18 @@ export class BotFactory {
346
488
  this.log.info(`Skipping minting as ${minter.toString()} has enough tokens`);
347
489
  return;
348
490
  }
349
- const sentTx = new BatchCall(token.wallet, calls).send({ from: minter });
350
- const txHash = await sentTx.getTxHash();
351
- this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
352
- await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
491
+
492
+ // PrivateToken's mint accesses contract-level private storage vars (admin, total_supply).
493
+ const additionalScopes = isStandardToken ? undefined : [token.address];
494
+ await this.withNoMinTxsPerBlock(async () => {
495
+ const { txHash } = await new BatchCall(token.wallet, calls).send({
496
+ from: minter,
497
+ additionalScopes,
498
+ wait: NO_WAIT,
499
+ });
500
+ this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
501
+ return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
502
+ });
353
503
  }
354
504
 
355
505
  /**
@@ -369,7 +519,6 @@ export class BotFactory {
369
519
  await this.withNoMinTxsPerBlock(() =>
370
520
  waitForL1ToL2MessageReady(this.aztecNode, messageHash, {
371
521
  timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
372
- forPublicConsumption: false,
373
522
  }),
374
523
  );
375
524
  return existingClaim.claim;
@@ -408,7 +557,6 @@ export class BotFactory {
408
557
  await this.withNoMinTxsPerBlock(() =>
409
558
  waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
410
559
  timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
411
- forPublicConsumption: false,
412
560
  }),
413
561
  );
414
562
 
package/src/index.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  export { Bot } from './bot.js';
2
2
  export { AmmBot } from './amm_bot.js';
3
+ export { CrossChainBot } from './cross_chain_bot.js';
3
4
  export { BotRunner } from './runner.js';
4
5
  export { BotStore } from './store/bot_store.js';
5
6
  export {