chore: Skip emitting public bytecode (#10009)

Skips emitting the event with the contract public bytecode when
registering the contract class. This allows for smaller L1 txs so they
fit in Sepolia. This is a temporary hack to be reverted.

To get bytecode into the nodes, we push it forcefully from the PXE
whenever we register a new contract. However, this only gets the
bytecode into the node that the PXE is connected to. To avoid nodes or
prover nodes from missing bytecode that is to be used for known
deployments, such as the token or token bridge contracts, we now
manually register them on initialization.

Reverting this is logged as issue #10007

Fixes #10000

Please read [contributing guidelines](CONTRIBUTING.md) and remove this
line.

noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/events/class_registered.nr

@@ -1,29 +1,30 @@
 use dep::aztec::protocol_types::{
-    constants::{
-        MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE,
-    },
-    contract_class_id::ContractClassId,
+    constants::REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE, contract_class_id::ContractClassId,
     traits::Serialize,
 };
 
-// #[event]
+// TODO(#10007): Use MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS instead
+pub global MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS: u32 = 100;
+
 pub struct ContractClassRegistered {
     contract_class_id: ContractClassId,
     version: Field,
     artifact_hash: Field,
     private_functions_root: Field,
-    packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],
+    packed_public_bytecode: [Field; MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],
 }
 
-impl Serialize<MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS + 5> for ContractClassRegistered {
-    fn serialize(self: Self) -> [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS + 5] {
-        let mut packed = [0; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS + 5];
+impl Serialize<MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS + 5> for ContractClassRegistered {
+    fn serialize(
+        self: Self,
+    ) -> [Field; MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS + 5] {
+        let mut packed = [0; MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS + 5];
         packed[0] = REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE;
         packed[1] = self.contract_class_id.to_field();
         packed[2] = self.version;
         packed[3] = self.artifact_hash;
         packed[4] = self.private_functions_root;
-        for i in 0..MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS {
+        for i in 0..MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS {
             packed[i + 5] = self.packed_public_bytecode[i];
         }
         packed

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

@@ -22,7 +22,9 @@ contract ContractClassRegisterer {
     };
 
     use crate::events::{
-        class_registered::ContractClassRegistered,
+        class_registered::{
+            ContractClassRegistered, MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,
+        },
         private_function_broadcasted::{
             ClassPrivateFunctionBroadcasted, InnerPrivateFunction, PrivateFunction,
         },
@@ -81,13 +83,6 @@ contract ContractClassRegisterer {
         );
 
         // Emit the contract class id as a nullifier to be able to prove that this class has been (not) registered
-        let event = ContractClassRegistered {
-            contract_class_id,
-            version: 1,
-            artifact_hash,
-            private_functions_root,
-            packed_public_bytecode,
-        };
         context.push_nullifier(contract_class_id.to_field());
 
         // Broadcast class info including public bytecode
@@ -100,7 +95,24 @@ contract ContractClassRegisterer {
                 public_bytecode_commitment,
             ],
         );
-        emit_contract_class_log(&mut context, event.serialize());
+
+        // TODO(#10007): Drop this conditional and always emit the bytecode. We allow skipping the broadcast
+        // as a stopgap solution to allow txs to fit in Sepolia when we broadcast public bytecode.
+        if bytecode_length_in_fields <= MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS {
+            let mut event_public_bytecode =
+                [0; MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS];
+            for i in 0..MAX_BROADCASTEABLE_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS {
+                event_public_bytecode[i] = packed_public_bytecode[i];
+            }
+            let event = ContractClassRegistered {
+                contract_class_id,
+                version: 1,
+                artifact_hash,
+                private_functions_root,
+                packed_public_bytecode: event_public_bytecode,
+            };
+            emit_contract_class_log(&mut context, event.serialize());
+        }
     }
 
     #[private]

yarn-project/archiver/package.json

@@ -71,6 +71,7 @@
     "@aztec/foundation": "workspace:^",
     "@aztec/kv-store": "workspace:^",
     "@aztec/l1-artifacts": "workspace:^",
+    "@aztec/noir-contracts.js": "workspace:^",
     "@aztec/protocol-contracts": "workspace:^",
     "@aztec/telemetry-client": "workspace:^",
     "@aztec/types": "workspace:^",
@@ -83,7 +84,6 @@
     "ws": "^8.13.0"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "workspace:^",
     "@jest/globals": "^29.5.0",
     "@types/debug": "^4.1.7",
     "@types/jest": "^29.5.0",

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

@@ -712,6 +712,12 @@ export class Archiver implements ArchiveSource {
     return this.store.getContractClassIds();
   }
 
+  // TODO(#10007): Remove this method
+  async addContractClass(contractClass: ContractClassPublic): Promise<void> {
+    await this.store.addContractClasses([contractClass], 0);
+    return;
+  }
+
   addContractArtifact(address: AztecAddress, artifact: ContractArtifact): Promise<void> {
     return this.store.addContractArtifact(address, artifact);
   }
@@ -764,7 +770,6 @@ class ArchiverStoreHelper
       ArchiverDataStore,
       | 'addLogs'
       | 'deleteLogs'
-      | 'addContractClasses'
       | 'deleteContractClasses'
       | 'addContractInstances'
       | 'deleteContractInstances'
@@ -775,6 +780,11 @@ class ArchiverStoreHelper
 
   constructor(private readonly store: ArchiverDataStore) {}
 
+  // TODO(#10007): Remove this method
+  addContractClasses(contractClasses: ContractClassPublic[], blockNum: number): Promise<boolean> {
+    return this.store.addContractClasses(contractClasses, blockNum);
+  }
+
   /**
    * Extracts and stores contract classes out of ContractClassRegistered events emitted by the class registerer contract.
    * @param allLogs - All logs emitted in a bunch of blocks.

yarn-project/archiver/src/factory.ts

@@ -1,9 +1,10 @@
 import { type ArchiverApi, type Service } from '@aztec/circuit-types';
-import { type ContractClassPublic } from '@aztec/circuits.js';
+import { type ContractClassPublic, getContractClassFromArtifact } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type Maybe } from '@aztec/foundation/types';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/utils';
+import { TokenBridgeContractArtifact, TokenContractArtifact } from '@aztec/noir-contracts.js';
 import { getCanonicalProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
@@ -21,14 +22,15 @@ export async function createArchiver(
   if (!config.archiverUrl) {
     const store = await createStore('archiver', config, createDebugLogger('aztec:archiver:lmdb'));
     const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
-    await initWithProtocolContracts(archiverStore);
+    await registerProtocolContracts(archiverStore);
+    await registerCommonContracts(archiverStore);
     return Archiver.createAndSync(config, archiverStore, telemetry, opts.blockUntilSync);
   } else {
     return createArchiverClient(config.archiverUrl);
   }
 }
 
-async function initWithProtocolContracts(store: KVArchiverDataStore) {
+async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const contract = getCanonicalProtocolContract(name);
@@ -42,3 +44,19 @@ async function initWithProtocolContracts(store: KVArchiverDataStore) {
     await store.addContractInstances([contract.instance], blockNumber);
   }
 }
+
+// TODO(#10007): Remove this method. We are explicitly registering these contracts
+// here to ensure they are available to all nodes and all prover nodes, since the PXE
+// was tweaked to automatically push contract classes to the node it is registered,
+// but other nodes in the network may require the contract classes to be registered as well.
+// TODO(#10007): Remove the dependency on noir-contracts.js from this package once we remove this.
+async function registerCommonContracts(store: KVArchiverDataStore) {
+  const blockNumber = 0;
+  const artifacts = [TokenBridgeContractArtifact, TokenContractArtifact];
+  const classes = artifacts.map(artifact => ({
+    ...getContractClassFromArtifact(artifact),
+    privateFunctions: [],
+    unconstrainedFunctions: [],
+  }));
+  await store.addContractClasses(classes, blockNumber);
+}

yarn-project/archiver/tsconfig.json

@@ -24,6 +24,9 @@
     {
       "path": "../l1-artifacts"
     },
+    {
+      "path": "../noir-contracts.js"
+    },
     {
       "path": "../protocol-contracts"
     },
@@ -32,9 +35,6 @@
     },
     {
       "path": "../types"
-    },
-    {
-      "path": "../noir-contracts.js"
     }
   ],
   "include": ["src"]

yarn-project/aztec-node/src/aztec-node/server.ts

@@ -812,7 +812,13 @@ export class AztecNodeService implements AztecNode {
     });
   }
 
+  // TODO(#10007): Remove this method
+  public addContractClass(contractClass: ContractClassPublic): Promise<void> {
+    return this.contractDataSource.addContractClass(contractClass);
+  }
+
   public addContractArtifact(address: AztecAddress, artifact: ContractArtifact): Promise<void> {
+    // TODO: Node should validate the artifact before accepting it
     return this.contractDataSource.addContractArtifact(address, artifact);
   }
 

yarn-project/circuit-types/src/interfaces/archiver.test.ts

@@ -232,6 +232,15 @@ describe('ArchiverApiSchema', () => {
       version: 1,
     });
   });
+
+  it('addContractClass', async () => {
+    const contractClass = getContractClassFromArtifact(artifact);
+    await context.client.addContractClass({
+      ...omit(contractClass, 'publicBytecodeCommitment'),
+      unconstrainedFunctions: [],
+      privateFunctions: [],
+    });
+  });
 });
 
 class MockArchiver implements ArchiverApi {
@@ -362,4 +371,7 @@ class MockArchiver implements ArchiverApi {
     expect(l1ToL2Message).toBeInstanceOf(Fr);
     return Promise.resolve(1n);
   }
+  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
+    return Promise.resolve();
+  }
 }

yarn-project/circuit-types/src/interfaces/archiver.ts

@@ -70,4 +70,6 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   addContractArtifact: z.function().args(schemas.AztecAddress, ContractArtifactSchema).returns(z.void()),
   getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),
   getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
+  // TODO(#10007): Remove this method
+  addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
 };

yarn-project/circuit-types/src/interfaces/aztec-node.test.ts

@@ -313,6 +313,11 @@ describe('AztecNodeApiSchema', () => {
     const response = await context.client.getEpochProofQuotes(1n);
     expect(response).toEqual([expect.any(EpochProofQuote)]);
   });
+
+  it('addContractClass', async () => {
+    const contractClass = getContractClassFromArtifact(artifact);
+    await context.client.addContractClass({ ...contractClass, unconstrainedFunctions: [], privateFunctions: [] });
+  });
 });
 
 class MockAztecNode implements AztecNode {
@@ -538,4 +543,7 @@ class MockAztecNode implements AztecNode {
     expect(epoch).toEqual(1n);
     return Promise.resolve([EpochProofQuote.random()]);
   }
+  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
+    return Promise.resolve();
+  }
 }

yarn-project/circuit-types/src/interfaces/aztec-node.ts

@@ -391,6 +391,13 @@ export interface AztecNode extends ProverCoordination {
    * @param epoch - The epoch for which to get the quotes
    */
   getEpochProofQuotes(epoch: bigint): Promise<EpochProofQuote[]>;
+
+  /**
+   * Adds a contract class bypassing the registerer.
+   * TODO(#10007): Remove this method.
+   * @param contractClass - The class to register.
+   */
+  addContractClass(contractClass: ContractClassPublic): Promise<void>;
 }
 
 export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
@@ -514,6 +521,9 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
   addEpochProofQuote: z.function().args(EpochProofQuote.schema).returns(z.void()),
 
   getEpochProofQuotes: z.function().args(schemas.BigInt).returns(z.array(EpochProofQuote.schema)),
+
+  // TODO(#10007): Remove this method
+  addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
 };
 
 export function createAztecNodeClient(url: string, fetch = defaultFetch): AztecNode {

yarn-project/circuits.js/src/contract/interfaces/contract_data_source.ts

@@ -26,6 +26,12 @@ export interface ContractDataSource {
    */
   getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
 
+  /**
+   * Adds a contract class to the database.
+   * TODO(#10007): Remove this method
+   */
+  addContractClass(contractClass: ContractClassPublic): Promise<void>;
+
   /**
    * Returns a publicly deployed contract instance given its address.
    * @param address - Address of the deployed contract.