feat!: Use new deployment flow in ContractDeployer

boxes/react/src/hooks/useContract.tsx

@@ -14,17 +14,17 @@ export function useContract() {
     e.preventDefault();
 
     setWait(true);
-    const contractDeployer = new ContractDeployer(artifact, deployerEnv.pxe);
     const wallet = await deployerEnv.getWallet();
+    const contractDeployer = new ContractDeployer(artifact, wallet);
 
     const salt = Fr.random();
     const tx = contractDeployer
       .deploy(Fr.random(), wallet.getCompleteAddress().address)
       .send({ contractAddressSalt: salt });
-    const { contractAddress } = await toast.promise(tx.wait(), {
+    const { address: contractAddress } = await toast.promise(tx.deployed(), {
       pending: 'Deploying contract...',
       success: {
-        render: ({ data }) => `Address: ${data.contractAddress}`,
+        render: ({ data }) => `Address: ${data.address}`,
       },
       error: 'Error deploying contract',
     });

boxes/react/src/index.tsx

@@ -1,11 +1,9 @@
-import { Home } from "./pages/home";
-import "react-toastify/dist/ReactToastify.css";
-import * as ReactDOM from "react-dom/client";
-import { ToastContainer } from "react-toastify";
+import { Home } from './pages/home';
+import 'react-toastify/dist/ReactToastify.css';
+import * as ReactDOM from 'react-dom/client';
+import { ToastContainer } from 'react-toastify';
 
-const root = ReactDOM.createRoot(
-  document.getElementById("root") as HTMLElement,
-);
+const root = ReactDOM.createRoot(document.getElementById('root') as HTMLElement);
 root.render(
   <>
     <Home />

boxes/react/src/pages/contract.tsx

@@ -1,7 +1,7 @@
-import { useState } from "react";
-import { Contract } from "@aztec/aztec.js";
-import { useNumber } from "../hooks/useNumber";
-import { filteredInterface } from "../config";
+import { useState } from 'react';
+import { Contract } from '@aztec/aztec.js';
+import { useNumber } from '../hooks/useNumber';
+import { filteredInterface } from '../config';
 
 export function ContractComponent({ contract }: { contract: Contract }) {
   const [showInput, setShowInput] = useState(true);
@@ -15,7 +15,7 @@ export function ContractComponent({ contract }: { contract: Contract }) {
         <select name="viewFunctions" id="viewFunctions">
           {filteredInterface.map(
             (fn, index) =>
-              fn.functionType === "unconstrained" && (
+              fn.functionType === 'unconstrained' && (
                 <option key={index} value={index}>
                   {fn.name}
                 </option>
@@ -29,26 +29,17 @@ export function ContractComponent({ contract }: { contract: Contract }) {
 
       <form onSubmit={setNumber}>
         <label htmlFor="functions">Functions:</label>
-        <select
-          name="functions"
-          id="functions"
-          onChange={() => setShowInput(true)}
-        >
+        <select name="functions" id="functions" onChange={() => setShowInput(true)}>
           {filteredInterface.map(
             (fn, index) =>
-              fn.functionType !== "unconstrained" && (
+              fn.functionType !== 'unconstrained' && (
                 <option key={index} value={index}>
                   {fn.name}
                 </option>
               ),
           )}
         </select>
-        <input
-          type="number"
-          name="numberToSet"
-          id="numberToSet"
-          hidden={!showInput}
-        />
+        <input type="number" name="numberToSet" id="numberToSet" hidden={!showInput} />
         <button type="submit" disabled={wait}>
           Write
         </button>

boxes/react/src/pages/home.tsx

@@ -1,5 +1,5 @@
-import { ContractComponent } from "./contract";
-import { useContract } from "../hooks/useContract";
+import { ContractComponent } from './contract';
+import { useContract } from '../hooks/useContract';
 
 export function Home() {
   const { contract, deploy, wait } = useContract();

boxes/react/tests/blank.contract.test.ts

@@ -13,11 +13,9 @@ describe('BoxReact Contract Tests', () => {
   beforeAll(async () => {
     wallet = await deployerEnv.getWallet();
     const pxe = deployerEnv.pxe;
-    const deployer = new ContractDeployer(artifact, pxe);
+    const deployer = new ContractDeployer(artifact, wallet);
     const salt = Fr.random();
-    const tx = deployer.deploy(Fr.random(), wallet.getCompleteAddress().address).send({ contractAddressSalt: salt });
-    await tx.wait();
-    const { contractAddress } = await tx.getReceipt();
+    const { address: contractAddress } = await deployer.deploy(Fr.random(), wallet.getCompleteAddress().address).send({ contractAddressSalt: salt }).deployed();
     contract = await BoxReactContract.at(contractAddress!, wallet);
 
     logger(`L2 contract deployed at ${contractAddress}`);

boxes/vanilla-js/src/index.ts

@@ -27,11 +27,11 @@ document.querySelector('#deploy').addEventListener('click', async ({ target }: a
   wallet = await account.register();
 
   const { artifact, at } = VanillaContract;
-  const contractDeployer = new ContractDeployer(artifact, pxe);
-  const { contractAddress } = await contractDeployer
+  const contractDeployer = new ContractDeployer(artifact, wallet);
+  const { address: contractAddress } = await contractDeployer
     .deploy(Fr.random(), wallet.getCompleteAddress().address)
     .send({ contractAddressSalt: Fr.random() })
-    .wait();
+    .deployed();
   contract = await at(contractAddress, wallet);
   alert(`Contract deployed at ${contractAddress}`);
 

l1-contracts/src/core/libraries/ConstantsGen.sol

@@ -72,7 +72,7 @@ library Constants {
   uint256 internal constant NUM_FIELDS_PER_SHA256 = 2;
   uint256 internal constant ARGS_HASH_CHUNK_LENGTH = 32;
   uint256 internal constant ARGS_HASH_CHUNK_COUNT = 32;
-  uint256 internal constant MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 1000;
+  uint256 internal constant MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 8000;
   uint256 internal constant MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS = 500;
   uint256 internal constant MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS = 500;
   uint256 internal constant REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE =

noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/capsule.nr

@@ -0,0 +1,10 @@
+// Copied from noir-contracts/contracts/slow_tree_contract/src/capsule.nr
+// We should extract this to a shared lib in aztec-nr once we settle on a design for capsules
+
+#[oracle(popCapsule)]
+fn pop_capsule_oracle<N>() -> [Field; N] {}
+
+// A capsule is a "blob" of data that is passed to the contract through an oracle.
+unconstrained pub fn pop_capsule<N>() -> [Field; N] {
+    pop_capsule_oracle()
+}

noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr

@@ -1,4 +1,5 @@
 mod events;
+mod capsule;
 
 contract ContractClassRegisterer {
     use dep::std::option::Option;
@@ -19,19 +20,18 @@ contract ContractClassRegisterer {
         unconstrained_function_broadcasted::{ClassUnconstrainedFunctionBroadcasted, UnconstrainedFunction}
     };
 
+    use crate::capsule::pop_capsule;
+
     #[aztec(private)]
     fn constructor() {}
 
     #[aztec(private)]
-    fn register(
-        artifact_hash: Field,
-        private_functions_root: Field,
-        public_bytecode_commitment: Field,
-        packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS]
-    ) {
+    fn register(artifact_hash: Field, private_functions_root: Field, public_bytecode_commitment: Field) {
         // TODO: Validate public_bytecode_commitment is the correct commitment of packed_public_bytecode
         // TODO: Validate packed_public_bytecode is legit public bytecode
 
+        let packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS] = pop_capsule();
+
         // Compute contract class id from preimage
         let contract_class_id = ContractClassId::compute(
             artifact_hash,
@@ -44,9 +44,16 @@ contract ContractClassRegisterer {
         context.push_new_nullifier(contract_class_id.to_field(), 0);
 
         // Broadcast class info including public bytecode
-        let event_payload = event.serialize();
-        dep::aztec::oracle::debug_log::debug_log_array_with_prefix("ContractClassRegistered", event_payload);
-        emit_unencrypted_log_from_private(&mut context, event_payload);
+        dep::aztec::oracle::debug_log::debug_log_array_with_prefix(
+            "ContractClassRegistered",
+            [
+            contract_class_id.to_field(),
+            artifact_hash,
+            private_functions_root,
+            public_bytecode_commitment
+        ]
+        );
+        emit_unencrypted_log_from_private(&mut context, event.serialize());
     }
 
     #[aztec(private)]
@@ -66,9 +73,18 @@ contract ContractClassRegisterer {
             artifact_function_tree_sibling_path,
             function: function_data
         };
-        let event_payload = event.serialize();
-        dep::aztec::oracle::debug_log::debug_log_array_with_prefix("ClassPrivateFunctionBroadcasted", event_payload);
-        emit_unencrypted_log_from_private(&mut context, event_payload);
+        dep::aztec::oracle::debug_log::debug_log_array_with_prefix(
+            "ClassPrivateFunctionBroadcasted",
+            [
+            contract_class_id.to_field(),
+            artifact_metadata_hash,
+            unconstrained_functions_artifact_tree_root,
+            function_data.selector.to_field(),
+            function_data.vk_hash,
+            function_data.metadata_hash
+        ]
+        );
+        emit_unencrypted_log_from_private(&mut context, event.serialize());
     }
 
     #[aztec(private)]
@@ -86,8 +102,16 @@ contract ContractClassRegisterer {
             artifact_function_tree_sibling_path,
             function: function_data
         };
-        let event_payload = event.serialize();
-        dep::aztec::oracle::debug_log::debug_log_array_with_prefix("ClassUnconstrainedFunctionBroadcasted", event_payload);
-        emit_unencrypted_log_from_private(&mut context, event_payload);
+        dep::aztec::oracle::debug_log::debug_log_array_with_prefix(
+            "ClassUnconstrainedFunctionBroadcasted",
+            [
+            contract_class_id.to_field(),
+            artifact_metadata_hash,
+            private_functions_artifact_tree_root,
+            function_data.selector.to_field(),
+            function_data.metadata_hash
+        ]
+        );
+        emit_unencrypted_log_from_private(&mut context, event.serialize());
     }
 }

noir-projects/noir-protocol-circuits/src/crates/types/src/constants.nr

@@ -104,11 +104,7 @@ global ARGS_HASH_CHUNK_COUNT: u32 = 32;
 global INITIALIZATION_SLOT_SEPARATOR: Field = 1000_000_000;
 
 // CONTRACT CLASS CONSTANTS
-// This should be around 8192 (assuming 2**15 instructions packed at 8 bytes each),
-// but it's reduced to speed up build times, otherwise the ClassRegisterer takes over 5 mins to compile.
-// We are not using 1024 so we can squeeze in a few more args to methods that consume packed public bytecode,
-// such as the ClassRegisterer.register, and still land below the 32 * 32 max args limit for hashing.
-global MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS: Field = 1000;
+global MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS: Field = 8000;
 // Bytecode size for private functions is per function, not for the entire contract.
 // Note that private functions bytecode includes a mix of acir and brillig.
 global MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS: Field = 500;

yarn-project/archiver/src/archiver/archiver.ts

@@ -20,12 +20,10 @@ import {
   ContractClassRegisteredEvent,
   FunctionSelector,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-  REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE,
 } from '@aztec/circuits.js';
-import { ContractInstanceDeployedEvent, computeSaltedInitializationHash } from '@aztec/circuits.js/contract';
+import { ContractInstanceDeployedEvent } from '@aztec/circuits.js/contract';
 import { createEthereumChain } from '@aztec/ethereum';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -72,12 +70,6 @@ export class Archiver implements ArchiveSource {
    */
   private lastLoggedL1BlockNumber = 0n;
 
-  /** Address of the ClassRegisterer contract with a salt=1 */
-  private classRegistererAddress = ClassRegistererAddress;
-
-  /** Address of the InstanceDeployer contract with a salt=1 */
-  private instanceDeployerAddress = InstanceDeployerAddress;
-
   /**
    * Creates a new instance of the Archiver.
    * @param publicClient - A client for interacting with the Ethereum node.
@@ -342,22 +334,9 @@ export class Archiver implements ArchiveSource {
    * @param allLogs - All logs emitted in a bunch of blocks.
    */
   private async storeRegisteredContractClasses(allLogs: UnencryptedL2Log[], blockNum: number) {
-    const contractClasses: ContractClassPublic[] = [];
-    for (const log of allLogs) {
-      try {
-        if (
-          !log.contractAddress.equals(this.classRegistererAddress) ||
-          toBigIntBE(log.data.subarray(0, 32)) !== REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE
-        ) {
-          continue;
-        }
-        const event = ContractClassRegisteredEvent.fromLogData(log.data);
-        contractClasses.push(event.toContractClassPublic());
-      } catch (err) {
-        this.log.warn(`Error processing log ${log.toHumanReadable()}: ${err}`);
-      }
-    }
-
+    const contractClasses = ContractClassRegisteredEvent.fromLogs(allLogs, ClassRegistererAddress).map(e =>
+      e.toContractClassPublic(),
+    );
     if (contractClasses.length > 0) {
       contractClasses.forEach(c => this.log(`Registering contract class ${c.id.toString()}`));
       await this.store.addContractClasses(contractClasses, blockNum);
@@ -369,22 +348,9 @@ export class Archiver implements ArchiveSource {
    * @param allLogs - All logs emitted in a bunch of blocks.
    */
   private async storeDeployedContractInstances(allLogs: UnencryptedL2Log[], blockNum: number) {
-    const contractInstances: ContractInstanceWithAddress[] = [];
-    for (const log of allLogs) {
-      try {
-        if (
-          !log.contractAddress.equals(this.instanceDeployerAddress) ||
-          !ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log.data)
-        ) {
-          continue;
-        }
-        const event = ContractInstanceDeployedEvent.fromLogData(log.data);
-        contractInstances.push(event.toContractInstance());
-      } catch (err) {
-        this.log.warn(`Error processing log ${log.toHumanReadable()}: ${err}`);
-      }
-    }
-
+    const contractInstances = ContractInstanceDeployedEvent.fromLogs(allLogs, InstanceDeployerAddress).map(e =>
+      e.toContractInstance(),
+    );
     if (contractInstances.length > 0) {
       contractInstances.forEach(c => this.log(`Storing contract instance at ${c.address.toString()}`));
       await this.store.addContractInstances(contractInstances, blockNum);
@@ -480,19 +446,11 @@ export class Archiver implements ArchiveSource {
 
     const contractClass = await this.store.getContractClass(instance.contractClassId);
     if (!contractClass) {
-      this.log.warn(
-        `Contract class ${instance.contractClassId.toString()} for address ${address.toString()} not found`,
-      );
+      this.log.warn(`Class ${instance.contractClassId.toString()} for address ${address.toString()} not found`);
       return undefined;
     }
 
-    return new ExtendedContractData(
-      new ContractData(address, instance.portalContractAddress),
-      contractClass.publicFunctions.map(f => new EncodedContractFunction(f.selector, f.isInternal, f.bytecode)),
-      contractClass.id,
-      computeSaltedInitializationHash(instance),
-      instance.publicKeysHash,
-    );
+    return ExtendedContractData.fromClassAndInstance(contractClass, instance);
   }
 
   /**
@@ -510,8 +468,21 @@ export class Archiver implements ArchiveSource {
    * @param contractAddress - The contract data address.
    * @returns ContractData with the portal address (if we didn't throw an error).
    */
-  public getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    return this.store.getContractData(contractAddress);
+  public async getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
+    return (await this.store.getContractData(contractAddress)) ?? this.makeContractDataFor(contractAddress);
+  }
+
+  /**
+   * Temporary method for creating a fake contract data out of classes and instances registered in the node.
+   * Used as a fallback if the extended contract data is not found.
+   */
+  private async makeContractDataFor(address: AztecAddress): Promise<ContractData | undefined> {
+    const instance = await this.store.getContractInstance(address);
+    if (!instance) {
+      return undefined;
+    }
+
+    return new ContractData(address, instance.portalContractAddress);
   }
 
   /**
@@ -591,6 +562,10 @@ export class Archiver implements ArchiveSource {
   getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
     return this.store.getConfirmedL1ToL2Message(messageKey);
   }
+
+  getContractClassIds(): Promise<Fr[]> {
+    return this.store.getContractClassIds();
+  }
 }
 
 /**

yarn-project/archiver/src/archiver/archiver_store.ts

@@ -196,4 +196,7 @@ export interface ArchiverDataStore {
    * @param address - Address of the contract.
    */
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+
+  /** Returns the list of all class ids known by the archiver. */
+  getContractClassIds(): Promise<Fr[]>;
 }