@aztec/ethereum 0.23.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -24,7 +24,7 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/foundation": "0.23.0",
+    "@aztec/foundation": "0.24.0",
     "dotenv": "^16.0.3",
     "tslib": "^2.4.0",
     "viem": "^1.2.5"

package/src/constants.ts

@@ -0,0 +1,3 @@
+import { Hex } from 'viem';
+
+export const NULL_KEY: Hex = `0x${'0000000000000000000000000000000000000000000000000000000000000000'}`;

package/src/deploy_l1_contracts.ts

@@ -0,0 +1,223 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { DebugLogger } from '@aztec/foundation/log';
+
+import type { Abi, Narrow } from 'abitype';
+import {
+  Account,
+  Chain,
+  Hex,
+  HttpTransport,
+  PublicClient,
+  WalletClient,
+  createPublicClient,
+  createWalletClient,
+  getAddress,
+  getContract,
+  http,
+} from 'viem';
+import { HDAccount, PrivateKeyAccount } from 'viem/accounts';
+
+import { L1ContractAddresses } from './l1_contract_addresses.js';
+
+/**
+ * Return type of the deployL1Contract function.
+ */
+export type DeployL1Contracts = {
+  /**
+   * Wallet Client Type.
+   */
+  walletClient: WalletClient<HttpTransport, Chain, Account>;
+  /**
+   * Public Client Type.
+   */
+  publicClient: PublicClient<HttpTransport, Chain>;
+
+  /**
+   * The currently deployed l1 contract addresses
+   */
+  l1ContractAddresses: L1ContractAddresses;
+};
+
+/**
+ * Contract artifacts
+ */
+export interface ContractArtifacts {
+  /**
+   * The contract abi.
+   */
+  contractAbi: Narrow<Abi | readonly unknown[]>;
+  /**
+   * The contract bytecode
+   */
+  contractBytecode: Hex;
+}
+
+/**
+ * All L1 Contract Artifacts for deployment
+ */
+export interface L1ContractArtifactsForDeployment {
+  /**
+   * Contract deployment emitter artifacts
+   */
+  contractDeploymentEmitter: ContractArtifacts;
+  /**
+   * Inbox contract artifacts
+   */
+  inbox: ContractArtifacts;
+  /**
+   * Outbox contract artifacts
+   */
+  outbox: ContractArtifacts;
+  /**
+   * Availability Oracle contract artifacts
+   */
+  availabilityOracle: ContractArtifacts;
+  /**
+   * Registry contract artifacts
+   */
+  registry: ContractArtifacts;
+  /**
+   * Rollup contract artifacts
+   */
+  rollup: ContractArtifacts;
+}
+
+/**
+ * Deploys the aztec L1 contracts; Rollup, Contract Deployment Emitter & (optionally) Decoder Helper.
+ * @param rpcUrl - URL of the ETH RPC to use for deployment.
+ * @param account - Private Key or HD Account that will deploy the contracts.
+ * @param chain - The chain instance to deploy to.
+ * @param logger - A logger object.
+ * @param contractsToDeploy - The set of L1 artifacts to be deployed
+ * @returns A list of ETH addresses of the deployed contracts.
+ */
+export const deployL1Contracts = async (
+  rpcUrl: string,
+  account: HDAccount | PrivateKeyAccount,
+  chain: Chain,
+  logger: DebugLogger,
+  contractsToDeploy: L1ContractArtifactsForDeployment,
+): Promise<DeployL1Contracts> => {
+  logger('Deploying contracts...');
+
+  const walletClient = createWalletClient({
+    account,
+    chain,
+    transport: http(rpcUrl),
+  });
+  const publicClient = createPublicClient({
+    chain,
+    transport: http(rpcUrl),
+  });
+
+  const registryAddress = await deployL1Contract(
+    walletClient,
+    publicClient,
+    contractsToDeploy.registry.contractAbi,
+    contractsToDeploy.registry.contractBytecode,
+  );
+  logger(`Deployed Registry at ${registryAddress}`);
+
+  const inboxAddress = await deployL1Contract(
+    walletClient,
+    publicClient,
+    contractsToDeploy.inbox.contractAbi,
+    contractsToDeploy.inbox.contractBytecode,
+    [getAddress(registryAddress.toString())],
+  );
+  logger(`Deployed Inbox at ${inboxAddress}`);
+
+  const outboxAddress = await deployL1Contract(
+    walletClient,
+    publicClient,
+    contractsToDeploy.outbox.contractAbi,
+    contractsToDeploy.outbox.contractBytecode,
+    [getAddress(registryAddress.toString())],
+  );
+  logger(`Deployed Outbox at ${outboxAddress}`);
+
+  const availabilityOracleAddress = await deployL1Contract(
+    walletClient,
+    publicClient,
+    contractsToDeploy.availabilityOracle.contractAbi,
+    contractsToDeploy.availabilityOracle.contractBytecode,
+  );
+  logger(`Deployed AvailabilityOracle at ${availabilityOracleAddress}`);
+
+  const rollupAddress = await deployL1Contract(
+    walletClient,
+    publicClient,
+    contractsToDeploy.rollup.contractAbi,
+    contractsToDeploy.rollup.contractBytecode,
+    [getAddress(registryAddress.toString()), getAddress(availabilityOracleAddress.toString())],
+  );
+  logger(`Deployed Rollup at ${rollupAddress}`);
+
+  // We need to call a function on the registry to set the various contract addresses.
+  const registryContract = getContract({
+    address: getAddress(registryAddress.toString()),
+    abi: contractsToDeploy.registry.contractAbi,
+    publicClient,
+    walletClient,
+  });
+  await registryContract.write.upgrade(
+    [getAddress(rollupAddress.toString()), getAddress(inboxAddress.toString()), getAddress(outboxAddress.toString())],
+    { account },
+  );
+
+  const contractDeploymentEmitterAddress = await deployL1Contract(
+    walletClient,
+    publicClient,
+    contractsToDeploy.contractDeploymentEmitter.contractAbi,
+    contractsToDeploy.contractDeploymentEmitter.contractBytecode,
+  );
+  logger(`Deployed contract deployment emitter at ${contractDeploymentEmitterAddress}`);
+
+  const l1Contracts: L1ContractAddresses = {
+    availabilityOracleAddress,
+    rollupAddress,
+    registryAddress,
+    inboxAddress,
+    outboxAddress,
+    contractDeploymentEmitterAddress,
+  };
+
+  return {
+    walletClient,
+    publicClient,
+    l1ContractAddresses: l1Contracts,
+  };
+};
+
+// docs:start:deployL1Contract
+/**
+ * Helper function to deploy ETH contracts.
+ * @param walletClient - A viem WalletClient.
+ * @param publicClient - A viem PublicClient.
+ * @param abi - The ETH contract's ABI (as abitype's Abi).
+ * @param bytecode  - The ETH contract's bytecode.
+ * @param args - Constructor arguments for the contract.
+ * @returns The ETH address the contract was deployed to.
+ */
+export async function deployL1Contract(
+  walletClient: WalletClient<HttpTransport, Chain, Account>,
+  publicClient: PublicClient<HttpTransport, Chain>,
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[] = [],
+): Promise<EthAddress> {
+  const hash = await walletClient.deployContract({
+    abi,
+    bytecode,
+    args,
+  });
+
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const contractAddress = receipt.contractAddress;
+  if (!contractAddress) {
+    throw new Error(`No contract address found in receipt: ${JSON.stringify(receipt)}`);
+  }
+
+  return EthAddress.fromString(receipt.contractAddress!);
+}
+// docs:end:deployL1Contract

package/src/ethereum_chain.ts

@@ -0,0 +1,16 @@
+import { Chain } from 'viem';
+
+/**
+ * Interface containing the connection and chain properties to interact with a blockchain.
+ */
+export interface EthereumChain {
+  /**
+   * An instance of the viem chain data.
+   */
+  chainInfo: Chain;
+
+  /**
+   * The actual url to be used.
+   */
+  rpcUrl: string;
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import { foundry } from 'viem/chains';
+
+import { EthereumChain } from './ethereum_chain.js';
+import { createTestnetChain } from './testnet.js';
+
+export * from './testnet.js';
+export * from './deploy_l1_contracts.js';
+export * from './l1_contract_addresses.js';
+export * from './constants.js';
+
+/**
+ * Helper function to create an instance of Aztec Chain from an rpc url and api key.
+ * @param rpcUrl - The rpc url of the chain or a chain identifier (e.g. 'testnet')
+ * @param apiKey - An optional API key for the chain client.
+ */
+export function createEthereumChain(rpcUrl: string, apiKey?: string) {
+  if (rpcUrl === 'testnet') {
+    if (apiKey === undefined || apiKey === '') {
+      throw new Error('API Key must be provided for aztec testnet');
+    }
+    return createTestnetChain(apiKey!);
+  }
+  return {
+    chainInfo: foundry,
+    rpcUrl,
+  } as EthereumChain;
+}

package/src/l1_contract_addresses.ts

@@ -0,0 +1,31 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+/**
+ * Provides the directory of current L1 contract addresses
+ */
+export interface L1ContractAddresses {
+  /**
+   * Availability Oracle Address.
+   */
+  availabilityOracleAddress: EthAddress;
+  /**
+   * Rollup Address.
+   */
+  rollupAddress: EthAddress;
+  /**
+   * Registry Address.
+   */
+  registryAddress: EthAddress;
+  /**
+   * Inbox Address.
+   */
+  inboxAddress: EthAddress;
+  /**
+   * Outbox Address.
+   */
+  outboxAddress: EthAddress;
+  /**
+   * Data Emitter Address.
+   */
+  contractDeploymentEmitterAddress: EthAddress;
+}

package/src/testnet.ts

@@ -0,0 +1,30 @@
+import { Chain } from 'viem';
+
+import { EthereumChain } from './ethereum_chain.js';
+
+const { DEPLOY_TAG = 'aztec-dev', CHAIN_ID = 31337 } = process.env;
+
+export const createTestnetChain = (apiKey: string) => {
+  const chain: Chain = {
+    id: +CHAIN_ID,
+    name: 'testnet',
+    network: 'aztec',
+    nativeCurrency: {
+      name: 'Ether',
+      symbol: 'ETH',
+      decimals: 18,
+    },
+    rpcUrls: {
+      default: {
+        http: [`https://${DEPLOY_TAG}-mainnet-fork.aztec.network:8545/${apiKey}`],
+      },
+      public: {
+        http: [`https://${DEPLOY_TAG}-mainnet-fork.aztec.network:8545/${apiKey}`],
+      },
+    },
+  };
+  return {
+    chainInfo: chain,
+    rpcUrl: chain.rpcUrls.default.http[0],
+  } as EthereumChain;
+};