@aztec/archiver 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/{archiver/kv_archiver_store → store}/contract_class_store.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
@@ -7,12 +7,12 @@ import type {
   ContractClassPublic,
   ContractClassPublicWithBlockNumber,
   ExecutablePrivateFunctionWithMembershipProof,
-  UnconstrainedFunctionWithMembershipProof,
+  UtilityFunctionWithMembershipProof,
 } from '@aztec/stdlib/contract';
 import { Vector } from '@aztec/stdlib/types';
 
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based contract class storage for the archiver.
  */
 export class ContractClassStore {
   #contractClasses: AztecAsyncMap<string, Buffer>;
@@ -28,18 +28,22 @@ export class ContractClassStore {
     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());
+    await this.db.transactionAsync(async () => {
+      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 = await this.#contractClasses.getAsync(contractClass.id.toString());
     if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
-      await this.#contractClasses.delete(contractClass.id.toString());
-      await this.#bytecodeCommitments.delete(contractClass.id.toString());
+      await this.db.transactionAsync(async () => {
+        await this.#contractClasses.delete(contractClass.id.toString());
+        await this.#bytecodeCommitments.delete(contractClass.id.toString());
+      });
     }
   }
 
@@ -60,7 +64,7 @@ export class ContractClassStore {
   async addFunctions(
     contractClassId: Fr,
     newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
-    newUnconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
+    newUtilityFunctions: UtilityFunctionWithMembershipProof[],
   ): Promise<boolean> {
     await this.db.transactionAsync(async () => {
       const existingClassBuffer = await this.#contractClasses.getAsync(contractClassId.toString());
@@ -69,7 +73,7 @@ export class ContractClassStore {
       }
 
       const existingClass = deserializeContractClassPublic(existingClassBuffer);
-      const { privateFunctions: existingPrivateFns, unconstrainedFunctions: existingUnconstrainedFns } = existingClass;
+      const { privateFunctions: existingPrivateFns, utilityFunctions: existingUtilityFns } = existingClass;
 
       const updatedClass: Omit<ContractClassPublicWithBlockNumber, 'id'> = {
         ...existingClass,
@@ -77,11 +81,9 @@ export class ContractClassStore {
           ...existingPrivateFns,
           ...newPrivateFunctions.filter(newFn => !existingPrivateFns.some(f => f.selector.equals(newFn.selector))),
         ],
-        unconstrainedFunctions: [
-          ...existingUnconstrainedFns,
-          ...newUnconstrainedFunctions.filter(
-            newFn => !existingUnconstrainedFns.some(f => f.selector.equals(newFn.selector)),
-          ),
+        utilityFunctions: [
+          ...existingUtilityFns,
+          ...newUtilityFunctions.filter(newFn => !existingUtilityFns.some(f => f.selector.equals(newFn.selector))),
         ],
       };
       await this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
@@ -96,12 +98,10 @@ function serializeContractClassPublic(contractClass: Omit<ContractClassPublicWit
     contractClass.l2BlockNumber,
     numToUInt8(contractClass.version),
     contractClass.artifactHash,
-    contractClass.publicFunctions.length,
-    contractClass.publicFunctions?.map(f => serializeToBuffer(f.selector, f.bytecode.length, f.bytecode)) ?? [],
     contractClass.privateFunctions.length,
     contractClass.privateFunctions.map(serializePrivateFunction),
-    contractClass.unconstrainedFunctions.length,
-    contractClass.unconstrainedFunctions.map(serializeUnconstrainedFunction),
+    contractClass.utilityFunctions.length,
+    contractClass.utilityFunctions.map(serializeUtilityFunction),
     contractClass.packedBytecode.length,
     contractClass.packedBytecode,
     contractClass.privateFunctionsRoot,
@@ -116,7 +116,7 @@ function serializePrivateFunction(fn: ExecutablePrivateFunctionWithMembershipPro
     fn.bytecode,
     fn.functionMetadataHash,
     fn.artifactMetadataHash,
-    fn.unconstrainedFunctionsArtifactTreeRoot,
+    fn.utilityFunctionsTreeRoot,
     new Vector(fn.privateFunctionTreeSiblingPath),
     fn.privateFunctionTreeLeafIndex,
     new Vector(fn.artifactTreeSiblingPath),
@@ -124,7 +124,7 @@ function serializePrivateFunction(fn: ExecutablePrivateFunctionWithMembershipPro
   );
 }
 
-function serializeUnconstrainedFunction(fn: UnconstrainedFunctionWithMembershipProof): Buffer {
+function serializeUtilityFunction(fn: UtilityFunctionWithMembershipProof): Buffer {
   return serializeToBuffer(
     fn.selector,
     fn.bytecode.length,
@@ -143,14 +143,8 @@ function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPubli
     l2BlockNumber: reader.readNumber(),
     version: reader.readUInt8() as 1,
     artifactHash: reader.readObject(Fr),
-    publicFunctions: reader.readVector({
-      fromBuffer: reader => ({
-        selector: reader.readObject(FunctionSelector),
-        bytecode: reader.readBuffer(),
-      }),
-    }),
     privateFunctions: reader.readVector({ fromBuffer: deserializePrivateFunction }),
-    unconstrainedFunctions: reader.readVector({ fromBuffer: deserializeUnconstrainedFunction }),
+    utilityFunctions: reader.readVector({ fromBuffer: deserializeUtilityFunction }),
     packedBytecode: reader.readBuffer(),
     privateFunctionsRoot: reader.readObject(Fr),
   };
@@ -164,7 +158,7 @@ function deserializePrivateFunction(buffer: Buffer | BufferReader): ExecutablePr
     bytecode: reader.readBuffer(),
     functionMetadataHash: reader.readObject(Fr),
     artifactMetadataHash: reader.readObject(Fr),
-    unconstrainedFunctionsArtifactTreeRoot: reader.readObject(Fr),
+    utilityFunctionsTreeRoot: reader.readObject(Fr),
     privateFunctionTreeSiblingPath: reader.readVector(Fr),
     privateFunctionTreeLeafIndex: reader.readNumber(),
     artifactTreeSiblingPath: reader.readVector(Fr),
@@ -172,7 +166,7 @@ function deserializePrivateFunction(buffer: Buffer | BufferReader): ExecutablePr
   };
 }
 
-function deserializeUnconstrainedFunction(buffer: Buffer | BufferReader): UnconstrainedFunctionWithMembershipProof {
+function deserializeUtilityFunction(buffer: Buffer | BufferReader): UtilityFunctionWithMembershipProof {
   const reader = BufferReader.asReader(buffer);
   return {
     selector: reader.readObject(FunctionSelector),

package/src/{archiver/kv_archiver_store → store}/contract_instance_store.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
@@ -7,71 +7,75 @@ import {
   SerializableContractInstance,
   SerializableContractInstanceUpdate,
 } from '@aztec/stdlib/contract';
+import type { UInt64 } from '@aztec/stdlib/types';
 
-type ContractInstanceUpdateKey = [string, number] | [string, number, number];
+type ContractInstanceUpdateKey = [string, string] | [string, string, number];
 
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based contract instance storage for the archiver.
  */
 export class ContractInstanceStore {
   #contractInstances: AztecAsyncMap<string, Buffer>;
+  #contractInstancePublishedAt: AztecAsyncMap<string, number>;
   #contractInstanceUpdates: AztecAsyncMap<ContractInstanceUpdateKey, Buffer>;
 
-  constructor(db: AztecAsyncKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#contractInstances = db.openMap('archiver_contract_instances');
+    this.#contractInstancePublishedAt = db.openMap('archiver_contract_instances_publication_block_number');
     this.#contractInstanceUpdates = db.openMap('archiver_contract_instance_updates');
   }
 
-  addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
-    return this.#contractInstances.set(
-      contractInstance.address.toString(),
-      new SerializableContractInstance(contractInstance).toBuffer(),
-    );
+  addContractInstance(contractInstance: ContractInstanceWithAddress, blockNumber: number): Promise<void> {
+    return this.db.transactionAsync(async () => {
+      await this.#contractInstances.set(
+        contractInstance.address.toString(),
+        new SerializableContractInstance(contractInstance).toBuffer(),
+      );
+      await this.#contractInstancePublishedAt.set(contractInstance.address.toString(), blockNumber);
+    });
   }
 
   deleteContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
-    return this.#contractInstances.delete(contractInstance.address.toString());
+    return this.db.transactionAsync(async () => {
+      await this.#contractInstances.delete(contractInstance.address.toString());
+      await this.#contractInstancePublishedAt.delete(contractInstance.address.toString());
+    });
   }
 
-  getUpdateKey(contractAddress: AztecAddress, blockNumber: number, logIndex?: number): ContractInstanceUpdateKey {
+  getUpdateKey(contractAddress: AztecAddress, timestamp: UInt64, logIndex?: number): ContractInstanceUpdateKey {
     if (logIndex === undefined) {
-      return [contractAddress.toString(), blockNumber];
+      return [contractAddress.toString(), timestamp.toString()];
     } else {
-      return [contractAddress.toString(), blockNumber, logIndex];
+      return [contractAddress.toString(), timestamp.toString(), logIndex];
     }
   }
 
   addContractInstanceUpdate(
     contractInstanceUpdate: ContractInstanceUpdateWithAddress,
-    blockNumber: number,
+    timestamp: UInt64,
     logIndex: number,
   ): Promise<void> {
     return this.#contractInstanceUpdates.set(
-      this.getUpdateKey(contractInstanceUpdate.address, blockNumber, logIndex),
+      this.getUpdateKey(contractInstanceUpdate.address, timestamp, logIndex),
       new SerializableContractInstanceUpdate(contractInstanceUpdate).toBuffer(),
     );
   }
 
   deleteContractInstanceUpdate(
     contractInstanceUpdate: ContractInstanceUpdateWithAddress,
-    blockNumber: number,
+    timestamp: UInt64,
     logIndex: number,
   ): Promise<void> {
-    return this.#contractInstanceUpdates.delete(
-      this.getUpdateKey(contractInstanceUpdate.address, blockNumber, logIndex),
-    );
+    return this.#contractInstanceUpdates.delete(this.getUpdateKey(contractInstanceUpdate.address, timestamp, logIndex));
   }
 
-  async getCurrentContractInstanceClassId(
-    address: AztecAddress,
-    blockNumber: number,
-    originalClassId: Fr,
-  ): Promise<Fr> {
-    // We need to find the last update before the given block number
+  async getCurrentContractInstanceClassId(address: AztecAddress, timestamp: UInt64, originalClassId: Fr): Promise<Fr> {
+    // We need to find the last update before the given timestamp
     const queryResult = await this.#contractInstanceUpdates
       .valuesAsync({
         reverse: true,
-        end: this.getUpdateKey(address, blockNumber + 1), // No update can match this key since it doesn't have a log index. We want the highest key <= blockNumber
+        start: this.getUpdateKey(address, 0n), // Make sure we only look at updates for this contract
+        end: this.getUpdateKey(address, timestamp + 1n), // No update can match this key since it doesn't have a log index. We want the highest key <= timestamp
         limit: 1,
       })
       .next();
@@ -81,7 +85,7 @@ export class ContractInstanceStore {
 
     const serializedUpdate = queryResult.value;
     const update = SerializableContractInstanceUpdate.fromBuffer(serializedUpdate);
-    if (blockNumber < update.blockOfChange) {
+    if (timestamp < update.timestampOfChange) {
       return update.prevContractClassId.isZero() ? originalClassId : update.prevContractClassId;
     }
     return update.newContractClassId;
@@ -89,7 +93,7 @@ export class ContractInstanceStore {
 
   async getContractInstance(
     address: AztecAddress,
-    blockNumber: number,
+    timestamp: UInt64,
   ): Promise<ContractInstanceWithAddress | undefined> {
     const contractInstance = await this.#contractInstances.getAsync(address.toString());
     if (!contractInstance) {
@@ -99,9 +103,13 @@ export class ContractInstanceStore {
     const instance = SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);
     instance.currentContractClassId = await this.getCurrentContractInstanceClassId(
       address,
-      blockNumber,
+      timestamp,
       instance.originalContractClassId,
     );
     return instance;
   }
+
+  getContractInstanceDeploymentBlockNumber(address: AztecAddress): Promise<number | undefined> {
+    return this.#contractInstancePublishedAt.getAsync(address.toString());
+  }
 }