@aztec/cli 0.0.0-test.0

package/dest/cmds/devnet/bootstrap_network.js

@@ -0,0 +1,196 @@
+import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import { BatchCall, Fr, L1FeeJuicePortalManager, createCompatibleClient, retryUntil } from '@aztec/aztec.js';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { getContract } from 'viem';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+const waitOpts = {
+    timeout: 120,
+    provenTimeout: 4800,
+    interval: 1
+};
+export async function bootstrapNetwork(pxeUrl, l1Urls, l1ChainId, l1PrivateKey, l1Mnemonic, addressIndex, json, log, debugLog) {
+    const pxe = await createCompatibleClient(pxeUrl, debugLog);
+    const [wallet] = await getDeployedTestAccountsWallets(pxe);
+    const l1Clients = createL1Clients(l1Urls, l1PrivateKey ? privateKeyToAccount(l1PrivateKey) : // Note that this account needs to be funded on L1 !
+    mnemonicToAccount(l1Mnemonic, {
+        addressIndex
+    }), createEthereumChain(l1Urls, +l1ChainId).chainInfo);
+    const { erc20Address, portalAddress } = await deployERC20(l1Clients);
+    const { token, bridge } = await deployToken(wallet, portalAddress);
+    await initPortal(pxe, l1Clients, erc20Address, portalAddress, bridge.address);
+    const fpcAdmin = wallet.getAddress();
+    const fpc = await deployFPC(wallet, token.address, fpcAdmin);
+    const counter = await deployCounter(wallet);
+    await fundFPC(counter.address, wallet, l1Clients, fpc.address, debugLog);
+    if (json) {
+        log(JSON.stringify({
+            devCoinL1: erc20Address.toString(),
+            devCoinPortalL1: portalAddress.toString(),
+            devCoin: {
+                address: token.address.toString(),
+                initHash: token.initHash.toString(),
+                salt: token.salt.toString()
+            },
+            devCoinBridge: {
+                address: bridge.address.toString(),
+                initHash: bridge.initHash.toString(),
+                salt: bridge.salt.toString()
+            },
+            devCoinFpc: {
+                address: fpc.address.toString(),
+                initHash: fpc.initHash.toString(),
+                salt: fpc.salt.toString()
+            },
+            counter: {
+                address: counter.address.toString(),
+                initHash: counter.initHash.toString(),
+                salt: counter.salt.toString()
+            }
+        }, null, 2));
+    } else {
+        log(`DevCoin L1: ${erc20Address}`);
+        log(`DevCoin L1 Portal: ${portalAddress}`);
+        log(`DevCoin L2: ${token.address}`);
+        log(`DevCoin L2 init hash: ${token.initHash}`);
+        log(`DevCoin L2 salt: ${token.salt}`);
+        log(`DevCoin L2 Bridge: ${bridge.address}`);
+        log(`DevCoin L2 Bridge init hash: ${bridge.initHash}`);
+        log(`DevCoin L2 Bridge salt: ${bridge.salt}`);
+        log(`DevCoin FPC: ${fpc.address}`);
+        log(`DevCoin FPC init hash: ${fpc.initHash}`);
+        log(`DevCoin FPC salt: ${fpc.salt}`);
+        log(`Counter: ${counter.address}`);
+        log(`Counter init hash: ${counter.initHash}`);
+        log(`Counter salt: ${counter.salt}`);
+    }
+}
+/**
+ * Step 1. Deploy the L1 contracts, but don't initialize
+ */ async function deployERC20({ walletClient, publicClient }) {
+    const { TestERC20Abi, TestERC20Bytecode, TokenPortalAbi, TokenPortalBytecode } = await import('@aztec/l1-artifacts');
+    const erc20 = {
+        contractAbi: TestERC20Abi,
+        contractBytecode: TestERC20Bytecode
+    };
+    const portal = {
+        contractAbi: TokenPortalAbi,
+        contractBytecode: TokenPortalBytecode
+    };
+    const { address: erc20Address } = await deployL1Contract(walletClient, publicClient, erc20.contractAbi, erc20.contractBytecode, [
+        'DevCoin',
+        'DEV',
+        walletClient.account.address
+    ]);
+    const { address: portalAddress } = await deployL1Contract(walletClient, publicClient, portal.contractAbi, portal.contractBytecode);
+    return {
+        erc20Address,
+        portalAddress
+    };
+}
+/**
+ * Step 2. Deploy the L2 contracts
+ */ async function deployToken(wallet, l1Portal) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { TokenContract } = await import('@aztec/noir-contracts.js/Token');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { TokenBridgeContract } = await import('@aztec/noir-contracts.js/TokenBridge');
+    const devCoin = await TokenContract.deploy(wallet, wallet.getAddress(), 'DevCoin', 'DEV', 18).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    const bridge = await TokenBridgeContract.deploy(wallet, devCoin.address, l1Portal).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    await new BatchCall(wallet, [
+        await devCoin.methods.set_minter(bridge.address, true).request(),
+        await devCoin.methods.set_admin(bridge.address).request()
+    ]).send().wait(waitOpts);
+    return {
+        token: {
+            address: devCoin.address,
+            initHash: devCoin.instance.initializationHash,
+            salt: devCoin.instance.salt
+        },
+        bridge: {
+            address: bridge.address,
+            initHash: bridge.instance.initializationHash,
+            salt: bridge.instance.salt
+        }
+    };
+}
+/**
+ * Step 3. Initialize DevCoin's L1 portal
+ */ async function initPortal(pxe, { walletClient, publicClient }, erc20, portal, bridge) {
+    const { TokenPortalAbi } = await import('@aztec/l1-artifacts');
+    const { l1ContractAddresses: { registryAddress } } = await pxe.getNodeInfo();
+    const contract = getContract({
+        abi: TokenPortalAbi,
+        address: portal.toString(),
+        client: walletClient
+    });
+    const hash = await contract.write.initialize([
+        registryAddress.toString(),
+        erc20.toString(),
+        bridge.toString()
+    ]);
+    await publicClient.waitForTransactionReceipt({
+        hash
+    });
+}
+async function deployFPC(wallet, tokenAddress, admin) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { FPCContract } = await import('@aztec/noir-contracts.js/FPC');
+    const fpc = await FPCContract.deploy(wallet, tokenAddress, admin).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    const info = {
+        address: fpc.address,
+        initHash: fpc.instance.initializationHash,
+        salt: fpc.instance.salt
+    };
+    return info;
+}
+async function deployCounter(wallet) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+    const counter = await CounterContract.deploy(wallet, 1, wallet.getAddress()).send({
+        universalDeploy: true
+    }).deployed(waitOpts);
+    const info = {
+        address: counter.address,
+        initHash: counter.instance.initializationHash,
+        salt: counter.instance.salt
+    };
+    return info;
+}
+// NOTE: Disabling for now in order to get devnet running
+async function fundFPC(counterAddress, wallet, l1Clients, fpcAddress, debugLog) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { FeeJuiceContract } = await import('@aztec/noir-contracts.js/FeeJuice');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+    const { protocolContractAddresses: { feeJuice } } = await wallet.getPXEInfo();
+    const feeJuiceContract = await FeeJuiceContract.at(feeJuice, wallet);
+    const feeJuicePortal = await L1FeeJuicePortalManager.new(wallet, l1Clients.publicClient, l1Clients.walletClient, debugLog);
+    const amount = FEE_FUNDING_FOR_TESTER_ACCOUNT;
+    const { claimAmount, claimSecret, messageLeafIndex, messageHash } = await feeJuicePortal.bridgeTokensPublic(fpcAddress, amount, true);
+    await retryUntil(async ()=>await wallet.isL1ToL2MessageSynced(Fr.fromHexString(messageHash)), 'message sync', 600, 1);
+    const counter = await CounterContract.at(counterAddress, wallet);
+    debugLog.info('Incrementing Counter');
+    // TODO (alexg) remove this once sequencer builds blocks continuously
+    // advance the chain
+    await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+    await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+    debugLog.info('Claiming FPC');
+    await feeJuiceContract.methods.claim(fpcAddress, claimAmount, claimSecret, messageLeafIndex).send().wait({
+        ...waitOpts,
+        proven: true
+    });
+    debugLog.info('Finished claiming FPC');
+}

package/dest/cmds/devnet/faucet.d.ts

@@ -0,0 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+export declare function dripFaucet(faucetUrl: string, asset: string, account: EthAddress, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=faucet.d.ts.map

package/dest/cmds/devnet/faucet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faucet.d.ts","sourceRoot":"","sources":["../../../src/cmds/devnet/faucet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAsB,UAAU,CAC9B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,GACT,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/dest/cmds/devnet/faucet.js

@@ -0,0 +1,26 @@
+import { prettyPrintJSON } from '../../utils/commands.js';
+export async function dripFaucet(faucetUrl, asset, account, json, log) {
+    const url = new URL(`/drip/${account.toString()}`, faucetUrl);
+    url.searchParams.set('asset', asset);
+    const res = await fetch(url);
+    if (res.status === 200) {
+        if (json) {
+            log(prettyPrintJSON({
+                ok: true
+            }));
+        } else {
+            log(`Dripped ${asset} for ${account.toString()}`);
+        }
+    } else {
+        if (json) {
+            log(prettyPrintJSON({
+                ok: false
+            }));
+        } else if (res.status === 429) {
+            log(`Rate limited when dripping ${asset} for ${account.toString()}`);
+        } else {
+            log(`Failed to drip ${asset} for ${account.toString()}`);
+        }
+        process.exit(1);
+    }
+}

package/dest/cmds/devnet/index.d.ts

@@ -0,0 +1,4 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=index.d.ts.map

package/dest/cmds/devnet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/devnet/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAqD/E"}

package/dest/cmds/devnet/index.js

@@ -0,0 +1,14 @@
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseEthereumAddress, pxeOption } from '../../utils/commands.js';
+export function injectCommands(program, log, debugLogger) {
+    program.command('bootstrap-network').description('Bootstrap a new network').addOption(pxeOption).addOption(l1ChainIdOption).requiredOption('--l1-rpc-urls <string>', 'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)', (arg)=>arg.split(','), [
+        ETHEREUM_HOSTS
+    ]).option('--l1-private-key <string>', 'The private key to use for deployment', process.env.PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').option('-ai, --address-index <number>', 'The address index to use when calculating an address', (arg)=>BigInt(arg), 0n).option('--json', 'Output the result as JSON').action(async (options)=>{
+        const { bootstrapNetwork } = await import('./bootstrap_network.js');
+        await bootstrapNetwork(options[pxeOption.attributeName()], options.l1RpcUrls, options[l1ChainIdOption.attributeName()], options.l1PrivateKey, options.mnemonic, options.addressIndex, options.json, log, debugLogger);
+    });
+    program.command('drip-faucet').description('Drip the faucet').requiredOption('-u, --faucet-url <string>', 'Url of the faucet', 'http://localhost:8082').requiredOption('-t, --token <string>', 'The asset to drip', 'eth').requiredOption('-a, --address <string>', 'The Ethereum address to drip to', parseEthereumAddress).option('--json', 'Output the result as JSON').action(async (options)=>{
+        const { dripFaucet } = await import('./faucet.js');
+        await dripFaucet(options.faucetUrl, options.token, options.address, options.json, log);
+    });
+    return program;
+}

package/dest/cmds/infrastructure/index.d.ts

@@ -0,0 +1,4 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=index.d.ts.map

package/dest/cmds/infrastructure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAgD/E"}

package/dest/cmds/infrastructure/index.js

@@ -0,0 +1,24 @@
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseOptionalInteger, pxeOption } from '../../utils/commands.js';
+export function injectCommands(program, log, debugLogger) {
+    program.command('setup-protocol-contracts').description('Bootstrap the blockchain by initializing all the protocol contracts').addOption(pxeOption).option('--testAccounts', 'Deploy funded test accounts.').option('--json', 'Output the contract addresses in JSON format').option('--skipProofWait', "Don't wait for proofs to land.").action(async (options)=>{
+        const { setupL2Contracts } = await import('./setup_l2_contract.js');
+        await setupL2Contracts(options.rpcUrl, options.testAccounts, options.json, options.skipProofWait, log);
+    });
+    program.command('sequencers').argument('<command>', 'Command to run: list, add, remove, who-next').argument('[who]', 'Who to add/remove').description('Manages or queries registered sequencers on the L1 rollup contract.').requiredOption('--l1-rpc-urls <string>', 'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)', (arg)=>arg.split(','), [
+        ETHEREUM_HOSTS
+    ]).option('-m, --mnemonic <string>', 'The mnemonic for the sender of the tx', 'test test test test test test test test test test test junk').option('--block-number <number>', 'Block number to query next sequencer for', parseOptionalInteger).addOption(pxeOption).addOption(l1ChainIdOption).action(async (command, who, options)=>{
+        const { sequencers } = await import('./sequencers.js');
+        await sequencers({
+            command: command,
+            who,
+            mnemonic: options.mnemonic,
+            rpcUrl: options.rpcUrl,
+            l1RpcUrls: options.l1RpcUrls.split(','),
+            chainId: options.l1ChainId,
+            blockNumber: options.blockNumber,
+            log,
+            debugLogger
+        });
+    });
+    return program;
+}

package/dest/cmds/infrastructure/sequencers.d.ts

@@ -0,0 +1,13 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function sequencers(opts: {
+    command: 'list' | 'add' | 'remove' | 'who-next';
+    who?: string;
+    mnemonic?: string;
+    rpcUrl: string;
+    l1RpcUrls: string[];
+    chainId: number;
+    blockNumber?: number;
+    log: LogFn;
+    debugLogger: Logger;
+}): Promise<void>;
+//# sourceMappingURL=sequencers.d.ts.map

package/dest/cmds/infrastructure/sequencers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencers.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/sequencers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAM3D,wBAAsB,UAAU,CAAC,IAAI,EAAE;IACrC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,CAAC;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,KAAK,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,iBAoFA"}

package/dest/cmds/infrastructure/sequencers.js

@@ -0,0 +1,93 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+export async function sequencers(opts) {
+    const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrls, chainId, log, debugLogger } = opts;
+    const client = await createCompatibleClient(rpcUrl, debugLogger);
+    const { l1ContractAddresses } = await client.getNodeInfo();
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+    const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+    });
+    const walletClient = mnemonic ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+    }) : undefined;
+    const rollup = getContract({
+        address: l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: publicClient
+    });
+    const writeableRollup = walletClient ? getContract({
+        address: l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient
+    }) : undefined;
+    const who = maybeWho ?? walletClient?.account.address.toString();
+    if (command === 'list') {
+        const sequencers = await rollup.read.getAttesters();
+        if (sequencers.length === 0) {
+            log(`No sequencers registered on rollup`);
+        } else {
+            log(`Registered sequencers on rollup:`);
+            for (const sequencer of sequencers){
+                log(' ' + sequencer.toString());
+            }
+        }
+    } else if (command === 'add') {
+        if (!who || !writeableRollup || !walletClient) {
+            throw new Error(`Missing sequencer address`);
+        }
+        log(`Adding ${who} as sequencer`);
+        const stakingAsset = getContract({
+            address: await rollup.read.getStakingAsset(),
+            abi: TestERC20Abi,
+            client: walletClient
+        });
+        const config = getL1ContractsConfigEnvVars();
+        await Promise.all([
+            await stakingAsset.write.mint([
+                walletClient.account.address,
+                config.minimumStake
+            ], {}),
+            await stakingAsset.write.approve([
+                rollup.address,
+                config.minimumStake
+            ], {})
+        ].map((txHash)=>publicClient.waitForTransactionReceipt({
+                hash: txHash
+            })));
+        const hash = await writeableRollup.write.deposit([
+            who,
+            who,
+            who,
+            config.minimumStake
+        ]);
+        await publicClient.waitForTransactionReceipt({
+            hash
+        });
+        log(`Added in tx ${hash}`);
+    } else if (command === 'remove') {
+        if (!who || !writeableRollup) {
+            throw new Error(`Missing sequencer address`);
+        }
+        log(`Removing ${who} as sequencer`);
+        const hash = await writeableRollup.write.initiateWithdraw([
+            who,
+            who
+        ]);
+        await publicClient.waitForTransactionReceipt({
+            hash
+        });
+        log(`Removed in tx ${hash}`);
+    } else if (command === 'who-next') {
+        const next = await rollup.read.getCurrentProposer();
+        log(`Sequencer expected to build is ${next}`);
+    } else {
+        throw new Error(`Unknown command ${command}`);
+    }
+}

package/dest/cmds/infrastructure/setup_l2_contract.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function setupL2Contracts(rpcUrl: string, testAccounts: boolean, json: boolean, skipProofWait: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=setup_l2_contract.d.ts.map

package/dest/cmds/infrastructure/setup_l2_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup_l2_contract.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/setup_l2_contract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAKnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,OAAO,EACrB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,OAAO,EACtB,GAAG,EAAE,KAAK,iBAiCX"}

package/dest/cmds/infrastructure/setup_l2_contract.js

@@ -0,0 +1,43 @@
+import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { SignerlessWallet, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { setupCanonicalL2FeeJuice } from '../misc/setup_contracts.js';
+export async function setupL2Contracts(rpcUrl, testAccounts, json, skipProofWait, log) {
+    const waitOpts = {
+        timeout: 180,
+        interval: 1,
+        proven: !skipProofWait,
+        provenTimeout: 600
+    };
+    log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
+    log('setupL2Contracts: Creating PXE client...');
+    const pxe = createPXEClient(rpcUrl, {}, makeFetch([
+        1,
+        1,
+        1,
+        1,
+        1
+    ], false));
+    const wallet = new SignerlessWallet(pxe);
+    log('setupL2Contracts: Getting fee juice portal address...');
+    // Deploy Fee Juice
+    const feeJuicePortalAddress = (await wallet.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
+    log('setupL2Contracts: Setting up fee juice portal...');
+    await setupCanonicalL2FeeJuice(wallet, feeJuicePortalAddress, waitOpts, log);
+    let deployedAccounts = [];
+    if (testAccounts) {
+        log('setupL2Contracts: Deploying test accounts...');
+        deployedAccounts = await getInitialTestAccounts();
+        await deployFundedSchnorrAccounts(pxe, deployedAccounts, waitOpts);
+    }
+    if (json) {
+        const toPrint = {
+            ...ProtocolContractAddress
+        };
+        deployedAccounts.forEach((a, i)=>{
+            toPrint[`testAccount${i}`] = a.address;
+        });
+        log(JSON.stringify(toPrint, null, 2));
+    }
+}

package/dest/cmds/l1/advance_epoch.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function advanceEpoch(l1RpcUrls: string[], rpcUrl: string, log: LogFn): Promise<void>;
+//# sourceMappingURL=advance_epoch.d.ts.map

package/dest/cmds/l1/advance_epoch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance_epoch.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/advance_epoch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAQjF"}

package/dest/cmds/l1/advance_epoch.js

@@ -0,0 +1,10 @@
+import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+export async function advanceEpoch(l1RpcUrls, rpcUrl, log) {
+    const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
+    const rollupAddress = await pxe.getNodeInfo().then((i)=>i.l1ContractAddresses.rollupAddress);
+    const cheat = CheatCodes.createRollup(l1RpcUrls, {
+        rollupAddress
+    });
+    await cheat.advanceToNextEpoch();
+    log(`Warped time to advance to next epoch`);
+}

package/dest/cmds/l1/assume_proven_through.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function assumeProvenThrough(blockNumberOrLatest: number | undefined, l1RpcUrls: string[], rpcUrl: string, log: LogFn): Promise<void>;
+//# sourceMappingURL=assume_proven_through.d.ts.map

package/dest/cmds/l1/assume_proven_through.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assume_proven_through.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/assume_proven_through.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,wBAAsB,mBAAmB,CACvC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,SAAS,EAAE,MAAM,EAAE,EACnB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,KAAK,iBAWX"}

package/dest/cmds/l1/assume_proven_through.js

@@ -0,0 +1,12 @@
+import { EthCheatCodes, RollupCheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+export async function assumeProvenThrough(blockNumberOrLatest, l1RpcUrls, rpcUrl, log) {
+    const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
+    const rollupAddress = await pxe.getNodeInfo().then((i)=>i.l1ContractAddresses.rollupAddress);
+    const blockNumber = blockNumberOrLatest ?? await pxe.getBlockNumber();
+    const ethCheatCode = new EthCheatCodes(l1RpcUrls);
+    const rollupCheatCodes = new RollupCheatCodes(ethCheatCode, {
+        rollupAddress
+    });
+    await rollupCheatCodes.markAsProven(blockNumber);
+    log(`Assumed proven through block ${blockNumber}`);
+}

package/dest/cmds/l1/bridge_erc20.d.ts

@@ -0,0 +1,4 @@
+import { type AztecAddress, type EthAddress } from '@aztec/aztec.js';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function bridgeERC20(amount: bigint, recipient: AztecAddress, l1RpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, tokenAddress: EthAddress, portalAddress: EthAddress, privateTransfer: boolean, mint: boolean, json: boolean, log: LogFn, debugLogger: Logger): Promise<void>;
+//# sourceMappingURL=bridge_erc20.d.ts.map

package/dest/cmds/l1/bridge_erc20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge_erc20.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/bridge_erc20.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAqC,MAAM,iBAAiB,CAAC;AAExG,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI3D,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,YAAY,EACvB,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,UAAU,EACxB,aAAa,EAAE,UAAU,EACzB,eAAe,EAAE,OAAO,EACxB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,iBAgCpB"}

package/dest/cmds/l1/bridge_erc20.js

@@ -0,0 +1,31 @@
+import { L1ToL2TokenPortalManager } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { prettyPrintJSON } from '../../utils/commands.js';
+export async function bridgeERC20(amount, recipient, l1RpcUrls, chainId, privateKey, mnemonic, tokenAddress, portalAddress, privateTransfer, mint, json, log, debugLogger) {
+    // Prepare L1 client
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+    const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+    // Setup portal manager
+    const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, publicClient, walletClient, debugLogger);
+    let claimSecret;
+    let messageHash;
+    if (privateTransfer) {
+        ({ claimSecret, messageHash } = await manager.bridgeTokensPrivate(recipient, amount, mint));
+    } else {
+        ({ claimSecret, messageHash } = await manager.bridgeTokensPublic(recipient, amount, mint));
+    }
+    if (json) {
+        log(prettyPrintJSON({
+            claimAmount: amount,
+            claimSecret: claimSecret
+        }));
+    } else {
+        if (mint) {
+            log(`Minted ${amount} tokens on L1 and pushed to L2 portal`);
+        } else {
+            log(`Bridged ${amount} tokens to L2 portal`);
+        }
+        log(`claimAmount=${amount},claimSecret=${claimSecret}\n,messageHash=${messageHash}`);
+        log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+    }
+}

package/dest/cmds/l1/create_l1_account.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function createL1Account(json: boolean, log: LogFn): void;
+//# sourceMappingURL=create_l1_account.d.ts.map

package/dest/cmds/l1/create_l1_account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_l1_account.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/create_l1_account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAMnD,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,QAUxD"}

package/dest/cmds/l1/create_l1_account.js

@@ -0,0 +1,15 @@
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { prettyPrintJSON } from '../../utils/commands.js';
+export function createL1Account(json, log) {
+    const privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    if (json) {
+        log(prettyPrintJSON({
+            privateKey,
+            address: account.address
+        }));
+    } else {
+        log(`Private Key: ${privateKey}`);
+        log(`Address: ${account.address}`);
+    }
+}

package/dest/cmds/l1/deploy_l1_contracts.d.ts

@@ -0,0 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function deployL1Contracts(rpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, mnemonicIndex: number, salt: number | undefined, testAccounts: boolean, acceleratedTestDeployments: boolean, json: boolean, initialValidators: EthAddress[], log: LogFn, debugLogger: Logger): Promise<void>;
+//# sourceMappingURL=deploy_l1_contracts.d.ts.map

package/dest/cmds/l1/deploy_l1_contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_l1_contracts.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/deploy_l1_contracts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAK3D,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,YAAY,EAAE,OAAO,EACrB,0BAA0B,EAAE,OAAO,EACnC,IAAI,EAAE,OAAO,EACb,iBAAiB,EAAE,UAAU,EAAE,EAC/B,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,iBA4CpB"}

package/dest/cmds/l1/deploy_l1_contracts.js

@@ -0,0 +1,29 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { getGenesisValues } from '@aztec/world-state/testing';
+import { deployAztecContracts } from '../../utils/aztec.js';
+export async function deployL1Contracts(rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, salt, testAccounts, acceleratedTestDeployments, json, initialValidators, log, debugLogger) {
+    const config = getL1ContractsConfigEnvVars();
+    const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
+    const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map((a)=>a.address));
+    const { l1ContractAddresses } = await deployAztecContracts(rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, salt, initialValidators, genesisArchiveRoot, genesisBlockHash, acceleratedTestDeployments, config, debugLogger);
+    if (json) {
+        log(JSON.stringify(Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v])=>[
+                k,
+                v.toString()
+            ])), null, 2));
+    } else {
+        log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+        log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+        log(`L1 -> L2 Inbox Address: ${l1ContractAddresses.inboxAddress.toString()}`);
+        log(`L2 -> L1 Outbox Address: ${l1ContractAddresses.outboxAddress.toString()}`);
+        log(`Fee Juice Address: ${l1ContractAddresses.feeJuiceAddress.toString()}`);
+        log(`Staking Asset Address: ${l1ContractAddresses.stakingAssetAddress.toString()}`);
+        log(`Fee Juice Portal Address: ${l1ContractAddresses.feeJuicePortalAddress.toString()}`);
+        log(`CoinIssuer Address: ${l1ContractAddresses.coinIssuerAddress.toString()}`);
+        log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
+        log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
+        log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
+        log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress?.toString()}`);
+    }
+}

package/dest/cmds/l1/deploy_l1_verifier.d.ts

@@ -0,0 +1,5 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { type Hex } from 'viem';
+export declare function deployUltraHonkVerifier(rollupAddress: Hex | undefined, ethRpcUrls: string[], l1ChainId: string, privateKey: string | undefined, mnemonic: string, pxeRpcUrl: string, bbBinaryPath: string, bbWorkingDirectory: string, log: LogFn, debugLogger: Logger): Promise<void>;
+export declare function deployMockVerifier(rollupAddress: Hex | undefined, ethRpcUrls: string[], l1ChainId: string, privateKey: string | undefined, mnemonic: string, pxeRpcUrl: string, log: LogFn, debugLogger: Logger): Promise<void>;
+//# sourceMappingURL=deploy_l1_verifier.d.ts.map

package/dest/cmds/l1/deploy_l1_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_l1_verifier.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/deploy_l1_verifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI3D,OAAO,EAAE,KAAK,GAAG,EAAe,MAAM,MAAM,CAAC;AAE7C,wBAAsB,uBAAuB,CAC3C,aAAa,EAAE,GAAG,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,iBAyCpB;AAED,wBAAsB,kBAAkB,CACtC,aAAa,EAAE,GAAG,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,iBAmCpB"}