@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.
- package/dest/amm_bot.d.ts +6 -7
- package/dest/amm_bot.d.ts.map +1 -1
- package/dest/amm_bot.js +27 -16
- package/dest/base_bot.d.ts +6 -6
- package/dest/base_bot.d.ts.map +1 -1
- package/dest/base_bot.js +14 -15
- package/dest/bot.d.ts +6 -6
- package/dest/bot.d.ts.map +1 -1
- package/dest/bot.js +8 -4
- package/dest/config.d.ts +73 -58
- package/dest/config.d.ts.map +1 -1
- package/dest/config.js +44 -17
- package/dest/cross_chain_bot.d.ts +54 -0
- package/dest/cross_chain_bot.d.ts.map +1 -0
- package/dest/cross_chain_bot.js +134 -0
- package/dest/factory.d.ts +18 -26
- package/dest/factory.d.ts.map +1 -1
- package/dest/factory.js +178 -82
- package/dest/index.d.ts +2 -1
- package/dest/index.d.ts.map +1 -1
- package/dest/index.js +1 -0
- package/dest/interface.d.ts +1 -1
- package/dest/l1_to_l2_seeding.d.ts +8 -0
- package/dest/l1_to_l2_seeding.d.ts.map +1 -0
- package/dest/l1_to_l2_seeding.js +63 -0
- package/dest/rpc.d.ts +1 -1
- package/dest/runner.d.ts +3 -3
- package/dest/runner.d.ts.map +1 -1
- package/dest/runner.js +429 -31
- package/dest/store/bot_store.d.ts +30 -5
- package/dest/store/bot_store.d.ts.map +1 -1
- package/dest/store/bot_store.js +38 -7
- package/dest/store/index.d.ts +2 -2
- package/dest/store/index.d.ts.map +1 -1
- package/dest/utils.d.ts +1 -1
- package/dest/utils.js +3 -3
- package/package.json +19 -15
- package/src/amm_bot.ts +26 -21
- package/src/base_bot.ts +13 -27
- package/src/bot.ts +10 -8
- package/src/config.ts +90 -60
- package/src/cross_chain_bot.ts +203 -0
- package/src/factory.ts +214 -66
- package/src/index.ts +1 -0
- package/src/l1_to_l2_seeding.ts +79 -0
- package/src/runner.ts +18 -5
- package/src/store/bot_store.ts +61 -6
- package/src/store/index.ts +1 -1
- 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 {
|
|
17
|
-
import {
|
|
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 {
|
|
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:
|
|
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
|
-
|
|
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
|
|
100
|
-
|
|
101
|
-
|
|
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.
|
|
225
|
+
const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1 + this.config.minFeePadding);
|
|
122
226
|
const gasSettings = GasSettings.default({ maxFeesPerGas });
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
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
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
297
|
+
await deploy.register();
|
|
174
298
|
} else {
|
|
175
299
|
this.log.info(`Deploying token contract at ${address.toString()}`);
|
|
176
|
-
const
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
213
|
-
|
|
214
|
-
|
|
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
|
|
231
|
-
|
|
232
|
-
|
|
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
|
|
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: ${
|
|
279
|
-
await mintTx.wait({ timeout: this.config.txMinedWaitSeconds });
|
|
417
|
+
this.log.info(`Sent mint tx: ${mintReceipt.txHash.toString()}`);
|
|
280
418
|
|
|
281
|
-
const
|
|
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: ${
|
|
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<
|
|
303
|
-
const
|
|
304
|
-
|
|
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
|
-
|
|
446
|
+
await deploy.register();
|
|
307
447
|
} else {
|
|
308
448
|
this.log.info(`Deploying contract ${name} at ${address.toString()}`);
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
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
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
await this.withNoMinTxsPerBlock(() =>
|
|
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
|
|