@aztec/archiver 0.64.0 → 0.65.1

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -15,22 +15,30 @@ import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
  */
 export class ContractClassStore {
   #contractClasses: AztecMap<string, Buffer>;
+  #bytecodeCommitments: AztecMap<string, Buffer>;
 
   constructor(private db: AztecKVStore) {
     this.#contractClasses = db.openMap('archiver_contract_classes');
+    this.#bytecodeCommitments = db.openMap('archiver_bytecode_commitments');
   }
 
-  async addContractClass(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
+  async addContractClass(
+    contractClass: ContractClassPublic,
+    bytecodeCommitment: Fr,
+    blockNumber: number,
+  ): Promise<void> {
     await this.#contractClasses.setIfNotExists(
       contractClass.id.toString(),
       serializeContractClassPublic({ ...contractClass, l2BlockNumber: blockNumber }),
     );
+    await this.#bytecodeCommitments.setIfNotExists(contractClass.id.toString(), bytecodeCommitment.toBuffer());
   }
 
   async deleteContractClasses(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
     const restoredContractClass = this.#contractClasses.get(contractClass.id.toString());
     if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
       await this.#contractClasses.delete(contractClass.id.toString());
+      await this.#bytecodeCommitments.delete(contractClass.id.toString());
     }
   }
 
@@ -39,6 +47,11 @@ export class ContractClassStore {
     return contractClass && { ...deserializeContractClassPublic(contractClass), id };
   }
 
+  getBytecodeCommitment(id: Fr): Fr | undefined {
+    const value = this.#bytecodeCommitments.get(id.toString());
+    return value === undefined ? undefined : Fr.fromBuffer(value);
+  }
+
   getContractClassIds(): Fr[] {
     return Array.from(this.#contractClasses.keys()).map(key => Fr.fromString(key));
   }

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -19,7 +19,7 @@ import {
   type Header,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type AztecKVStore } from '@aztec/kv-store';
@@ -46,6 +46,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   #contractClassStore: ContractClassStore;
   #contractInstanceStore: ContractInstanceStore;
   #contractArtifactStore: ContractArtifactsStore;
+  private functionNames = new Map<string, string>();
 
   #log = createDebugLogger('aztec:archiver:data-store');
 
@@ -63,8 +64,19 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return Promise.resolve(this.#contractArtifactStore.getContractArtifact(address));
   }
 
-  addContractArtifact(address: AztecAddress, contract: ContractArtifact): Promise<void> {
-    return this.#contractArtifactStore.addContractArtifact(address, contract);
+  // TODO:  These function names are in memory only as they are for development/debugging. They require the full contract
+  //        artifact supplied to the node out of band. This should be reviewed and potentially removed as part of
+  //        the node api cleanup process.
+  getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    return Promise.resolve(this.functionNames.get(selector.toString()));
+  }
+
+  async addContractArtifact(address: AztecAddress, contract: ContractArtifact): Promise<void> {
+    await this.#contractArtifactStore.addContractArtifact(address, contract);
+    // Building tup this map of selectors to function names save expensive re-hydration of contract artifacts later
+    contract.functions.forEach(f => {
+      this.functionNames.set(FunctionSelector.fromNameAndParameters(f.name, f.parameters).toString(), f.name);
+    });
   }
 
   getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
@@ -76,11 +88,20 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return Promise.resolve(this.#contractInstanceStore.getContractInstance(address));
+    const contract = this.#contractInstanceStore.getContractInstance(address);
+    return Promise.resolve(contract);
   }
 
-  async addContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
-    return (await Promise.all(data.map(c => this.#contractClassStore.addContractClass(c, blockNumber)))).every(Boolean);
+  async addContractClasses(
+    data: ContractClassPublic[],
+    bytecodeCommitments: Fr[],
+    blockNumber: number,
+  ): Promise<boolean> {
+    return (
+      await Promise.all(
+        data.map((c, i) => this.#contractClassStore.addContractClass(c, bytecodeCommitments[i], blockNumber)),
+      )
+    ).every(Boolean);
   }
 
   async deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
@@ -89,6 +110,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     );
   }
 
+  getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
+    return Promise.resolve(this.#contractClassStore.getBytecodeCommitment(contractClassId));
+  }
+
   addFunctions(
     contractClassId: Fr,
     privateFunctions: ExecutablePrivateFunctionWithMembershipProof[],

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -9,6 +9,7 @@ import {
   type InBlock,
   type InboxLeaf,
   type L2Block,
+  L2BlockHash,
   type L2BlockL2Logs,
   type LogFilter,
   LogId,
@@ -32,7 +33,7 @@ import {
   MAX_NULLIFIERS_PER_TX,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
-import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
 
@@ -78,6 +79,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private contractClasses: Map<string, ContractClassPublicWithBlockNumber> = new Map();
 
+  private bytecodeCommitments: Map<string, Fr> = new Map();
+
   private privateFunctions: Map<string, ExecutablePrivateFunctionWithMembershipProof[]> = new Map();
 
   private unconstrainedFunctions: Map<string, UnconstrainedFunctionWithMembershipProof[]> = new Map();
@@ -116,6 +119,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.contractInstances.get(address.toString()));
   }
 
+  public getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
+    return Promise.resolve(this.bytecodeCommitments.get(contractClassId.toString()));
+  }
+
   public addFunctions(
     contractClassId: Fr,
     newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
@@ -138,14 +145,22 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
-  public addContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
-    for (const contractClass of data) {
+  public addContractClasses(
+    data: ContractClassPublic[],
+    bytecodeCommitments: Fr[],
+    blockNumber: number,
+  ): Promise<boolean> {
+    for (let i = 0; i < data.length; i++) {
+      const contractClass = data[i];
       if (!this.contractClasses.has(contractClass.id.toString())) {
         this.contractClasses.set(contractClass.id.toString(), {
           ...contractClass,
           l2BlockNumber: blockNumber,
         });
       }
+      if (!this.bytecodeCommitments.has(contractClass.id.toString())) {
+        this.bytecodeCommitments.set(contractClass.id.toString(), bytecodeCommitments[i]);
+      }
     }
     return Promise.resolve(true);
   }
@@ -155,6 +170,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       const restored = this.contractClasses.get(contractClass.id.toString());
       if (restored && restored.l2BlockNumber >= blockNumber) {
         this.contractClasses.delete(contractClass.id.toString());
+        this.bytecodeCommitments.delete(contractClass.id.toString());
       }
     }
     return Promise.resolve(true);
@@ -435,7 +451,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
               TxReceipt.statusFromRevertCode(txEffect.revertCode),
               '',
               txEffect.transactionFee.toBigInt(),
-              block.data.hash().toBuffer(),
+              L2BlockHash.fromField(block.data.hash()),
               block.data.number,
             ),
           );
@@ -737,6 +753,19 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.contractArtifacts.get(address.toString()));
   }
 
+  async getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    const artifact = await this.getContractArtifact(address);
+
+    if (!artifact) {
+      return undefined;
+    }
+
+    const func = artifact.functions.find(f =>
+      FunctionSelector.fromNameAndParameters({ name: f.name, parameters: f.parameters }).equals(selector),
+    );
+    return Promise.resolve(func?.name);
+  }
+
   public estimateSize(): { mappingSize: number; actualSize: number; numItems: number } {
     return { mappingSize: 0, actualSize: 0, numItems: 0 };
   }

package/src/factory.ts

@@ -1,5 +1,9 @@
 import { type ArchiverApi, type Service } from '@aztec/circuit-types';
-import { type ContractClassPublic, getContractClassFromArtifact } from '@aztec/circuits.js';
+import {
+  type ContractClassPublic,
+  computePublicBytecodeCommitment,
+  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';
@@ -40,7 +44,8 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
       unconstrainedFunctions: [],
     };
     await store.addContractArtifact(contract.address, contract.artifact);
-    await store.addContractClasses([contractClassPublic], blockNumber);
+    const bytecodeCommitment = computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
+    await store.addContractClasses([contractClassPublic], [bytecodeCommitment], blockNumber);
     await store.addContractInstances([contract.instance], blockNumber);
   }
 }
@@ -58,5 +63,6 @@ async function registerCommonContracts(store: KVArchiverDataStore) {
     privateFunctions: [],
     unconstrainedFunctions: [],
   }));
-  await store.addContractClasses(classes, blockNumber);
+  const bytecodeCommitments = classes.map(x => computePublicBytecodeCommitment(x.packedBytecode));
+  await store.addContractClasses(classes, bytecodeCommitments, blockNumber);
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
@@ -25,7 +26,7 @@ async function main() {
   const config = getArchiverConfigFromEnv();
   const { l1RpcUrl: rpcUrl, l1Contracts } = config;
 
-  log.info(`Starting archiver in main(): ${JSON.stringify(config)}`);
+  log.info(`Starting archiver in main(): ${jsonStringify(config)}`);
   const publicClient = createPublicClient({
     chain: localhost,
     transport: http(rpcUrl),

package/src/test/mock_l2_block_source.ts

@@ -1,4 +1,12 @@
-import { L2Block, type L2BlockSource, type L2Tips, type TxHash, TxReceipt, TxStatus } from '@aztec/circuit-types';
+import {
+  L2Block,
+  L2BlockHash,
+  type L2BlockSource,
+  type L2Tips,
+  type TxHash,
+  TxReceipt,
+  TxStatus,
+} from '@aztec/circuit-types';
 import { EthAddress, type Header } from '@aztec/circuits.js';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -144,7 +152,7 @@ export class MockL2BlockSource implements L2BlockSource {
               TxStatus.SUCCESS,
               '',
               txEffect.transactionFee.toBigInt(),
-              block.hash().toBuffer(),
+              L2BlockHash.fromField(block.hash()),
               block.number,
             ),
           );