@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/trees/append_only_tree_snapshot.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -71,11 +71,26 @@ export class AppendOnlyTreeSnapshot {
     return new AppendOnlyTreeSnapshot(reader.readField(), Number(reader.readField().toBigInt()));
   }
 
-  static zero() {
+  toAbi(): [`0x${string}`, number] {
+    return [this.root.toString(), this.nextAvailableLeafIndex];
+  }
+
+  static empty() {
     return new AppendOnlyTreeSnapshot(Fr.ZERO, 0);
   }
 
-  isZero(): boolean {
+  /**
+   * Creates an AppendOnlyTreeSnapshot instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AppendOnlyTreeSnapshot fields
+   * @returns An AppendOnlyTreeSnapshot instance
+   */
+  static fromPlainObject(obj: any): AppendOnlyTreeSnapshot {
+    return new AppendOnlyTreeSnapshot(Fr.fromPlainObject(obj.root), obj.nextAvailableLeafIndex);
+  }
+
+  isEmpty(): boolean {
     return this.root.isZero() && this.nextAvailableLeafIndex === 0;
   }
 

package/src/trees/database_public_state_source.ts

@@ -0,0 +1,30 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { computePublicDataTreeLeafSlot } from '../hash/hash.js';
+import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
+import type { PublicStateSource } from '../interfaces/public_state_source.js';
+import { MerkleTreeId } from './merkle_tree_id.js';
+import type { PublicDataTreeLeafPreimage } from './public_data_leaf.js';
+
+export type { PublicStateSource };
+
+export class DatabasePublicStateSource implements PublicStateSource {
+  constructor(private db: MerkleTreeReadOperations) {}
+
+  async storageRead(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
+    const leafSlot = (await computePublicDataTreeLeafSlot(contractAddress, slot)).toBigInt();
+
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+      return Fr.ZERO;
+    }
+
+    const preimage = (await this.db.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
+
+    return preimage.leaf.value;
+  }
+}

package/src/trees/index.ts

@@ -1,8 +1,8 @@
 export * from './nullifier_leaf.js';
-export * from './protocol_contract_leaf.js';
 export * from './public_data_leaf.js';
 export * from './append_only_tree_snapshot.js';
 export * from './merkle_tree_id.js';
 export * from './nullifier_membership_witness.js';
 export * from './public_data_witness.js';
 export * from '../interfaces/merkle_tree_operations.js';
+export * from './database_public_state_source.js';

package/src/trees/merkle_tree_id.ts

@@ -40,3 +40,15 @@ export type TreeHeights = typeof TREE_HEIGHTS;
 export function getTreeHeight<TID extends MerkleTreeId>(treeId: TID): TreeHeights[TID] {
   return TREE_HEIGHTS[treeId];
 }
+
+const TREE_NAMES = {
+  [MerkleTreeId.NULLIFIER_TREE]: 'NULLIFIER_TREE' as const,
+  [MerkleTreeId.NOTE_HASH_TREE]: 'NOTE_HASH_TREE' as const,
+  [MerkleTreeId.PUBLIC_DATA_TREE]: 'PUBLIC_DATA_TREE' as const,
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: 'L1_TO_L2_MESSAGE_TREE' as const,
+  [MerkleTreeId.ARCHIVE]: 'ARCHIVE' as const,
+} as const;
+
+export function getTreeName<TID extends MerkleTreeId>(treeId: TID): (typeof TREE_NAMES)[TID] {
+  return TREE_NAMES[treeId];
+}

package/src/trees/nullifier_leaf.ts

@@ -1,5 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader } from '@aztec/foundation/serialize';
 import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
@@ -15,11 +15,11 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
     /**
      * Leaf value inside the indexed tree's linked list.
      */
-    public nullifier: Fr,
+    public leaf: NullifierLeaf,
     /**
-     * Next value inside the indexed tree's linked list.
+     * Next nullifier inside the indexed tree's linked list.
      */
-    public nextNullifier: Fr,
+    public nextKey: Fr,
     /**
      * Index of the next leaf in the indexed tree's linked list.
      */
@@ -29,21 +29,41 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   static get schema() {
     return z
       .object({
-        nullifier: schemas.Fr,
-        nextNullifier: schemas.Fr,
+        leaf: NullifierLeaf.schema,
+        nextKey: schemas.Fr,
         nextIndex: schemas.BigInt,
       })
-      .transform(
-        ({ nullifier, nextNullifier, nextIndex }) => new NullifierLeafPreimage(nullifier, nextNullifier, nextIndex),
-      );
+      .transform(({ leaf, nextKey, nextIndex }) => new NullifierLeafPreimage(leaf, nextKey, nextIndex));
+  }
+
+  /**
+   * Creates a NullifierLeafPreimage from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing NullifierLeafPreimage fields
+   * @returns A NullifierLeafPreimage instance
+   */
+  static fromPlainObject(obj: any): NullifierLeafPreimage {
+    if (obj instanceof NullifierLeafPreimage) {
+      return obj;
+    }
+    return new NullifierLeafPreimage(
+      NullifierLeaf.fromPlainObject(obj.leaf),
+      Fr.fromPlainObject(obj.nextKey),
+      typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex),
+    );
+  }
+
+  static get leafSchema() {
+    return NullifierLeaf.schema;
   }
 
   getKey(): bigint {
-    return this.nullifier.toBigInt();
+    return this.leaf.getKey();
   }
 
   getNextKey(): bigint {
-    return this.nextNullifier.toBigInt();
+    return this.nextKey.toBigInt();
   }
 
   getNextIndex(): bigint {
@@ -51,7 +71,7 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): NullifierLeaf {
-    return new NullifierLeaf(this.nullifier);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -60,8 +80,8 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
 
   toHashInputs(): Buffer[] {
     return [
-      Buffer.from(this.nullifier.toBuffer()),
-      Buffer.from(this.nextNullifier.toBuffer()),
+      ...this.leaf.toHashInputs(),
+      Buffer.from(this.nextKey.toBuffer()),
       Buffer.from(toBufferBE(this.nextIndex, 32)),
     ];
   }
@@ -71,28 +91,32 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   clone(): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(this.nullifier, this.nextNullifier, this.nextIndex);
+    return new NullifierLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
 
   static random() {
-    return new NullifierLeafPreimage(Fr.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
+    return new NullifierLeafPreimage(NullifierLeaf.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
   }
 
   static empty(): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(Fr.ZERO, Fr.ZERO, 0n);
+    return new NullifierLeafPreimage(NullifierLeaf.empty(), Fr.zero(), 0n);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): NullifierLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    return new NullifierLeafPreimage(reader.readObject(Fr), reader.readObject(Fr), toBigIntBE(reader.readBytes(32)));
+    return new NullifierLeafPreimage(
+      NullifierLeaf.fromBuffer(reader),
+      reader.readObject(Fr),
+      toBigIntBE(reader.readBytes(32)),
+    );
   }
 
   static fromLeaf(leaf: NullifierLeaf, nextKey: bigint, nextIndex: bigint): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(leaf.nullifier, new Fr(nextKey), nextIndex);
+    return new NullifierLeafPreimage(leaf, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: NullifierLeafPreimage): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(preimage.nullifier, preimage.nextNullifier, preimage.nextIndex);
+    return preimage.clone();
   }
 }
 
@@ -115,6 +139,22 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     return this.nullifier.toBuffer();
   }
 
+  clone(): NullifierLeaf {
+    return new NullifierLeaf(new Fr(this.nullifier));
+  }
+
+  toHashInputs(): Buffer[] {
+    return [Buffer.from(this.nullifier.toBuffer())];
+  }
+
+  static empty(): NullifierLeaf {
+    return new NullifierLeaf(Fr.ZERO);
+  }
+
+  static random(): NullifierLeaf {
+    return new NullifierLeaf(Fr.random());
+  }
+
   isEmpty(): boolean {
     return this.nullifier.isZero();
   }
@@ -127,7 +167,26 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     return new NullifierLeaf(new Fr(key));
   }
 
-  static fromBuffer(buf: Buffer): NullifierLeaf {
-    return new NullifierLeaf(Fr.fromBuffer(buf));
+  static fromBuffer(buf: Buffer | BufferReader): NullifierLeaf {
+    const reader = BufferReader.asReader(buf);
+    return new NullifierLeaf(reader.readObject(Fr));
+  }
+
+  static get schema() {
+    return z.object({ nullifier: schemas.Fr }).transform(({ nullifier }) => new NullifierLeaf(nullifier));
+  }
+
+  /**
+   * Creates a NullifierLeaf from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing NullifierLeaf fields
+   * @returns A NullifierLeaf instance
+   */
+  static fromPlainObject(obj: any): NullifierLeaf {
+    if (obj instanceof NullifierLeaf) {
+      return obj;
+    }
+    return new NullifierLeaf(Fr.fromPlainObject(obj.nullifier));
   }
 }

package/src/trees/nullifier_membership_witness.ts

@@ -1,6 +1,6 @@
 import { NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { SiblingPath } from '@aztec/foundation/trees';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
 
@@ -49,6 +49,10 @@ export class NullifierMembershipWitness {
     );
   }
 
+  public withoutPreimage(): MembershipWitness<typeof NULLIFIER_TREE_HEIGHT> {
+    return new MembershipWitness(NULLIFIER_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
+  }
+
   /**
    * Returns a field array representation of a nullifier witness.
    * @returns A field array representation of a nullifier witness.
@@ -56,4 +60,16 @@ export class NullifierMembershipWitness {
   public toFields(): Fr[] {
     return [new Fr(this.index), ...this.leafPreimage.toFields(), ...this.siblingPath.toFields()];
   }
+
+  /**
+   * Returns a representation of the nullifier membership witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      ...(this.leafPreimage.toFields().map(fr => fr.toString()) as string[]),
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
 }

package/src/trees/public_data_leaf.ts

@@ -1,5 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
@@ -13,17 +13,13 @@ import { z } from 'zod';
 export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   constructor(
     /**
-     * The slot of the leaf
+     * The leaf (slot, value).
      */
-    public slot: Fr,
-    /**
-     * The value of the leaf
-     */
-    public value: Fr,
+    public leaf: PublicDataTreeLeaf,
     /**
-     * Next value inside the indexed tree's linked list.
+     * Next key (slot) inside the indexed tree's linked list.
      */
-    public nextSlot: Fr,
+    public nextKey: Fr,
     /**
      * Index of the next leaf in the indexed tree's linked list.
      */
@@ -33,22 +29,41 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   static get schema() {
     return z
       .object({
-        slot: schemas.Fr,
-        value: schemas.Fr,
-        nextSlot: schemas.Fr,
+        leaf: PublicDataTreeLeaf.schema,
+        nextKey: schemas.Fr,
         nextIndex: schemas.BigInt,
       })
-      .transform(
-        ({ slot, value, nextSlot, nextIndex }) => new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex),
-      );
+      .transform(({ leaf, nextKey, nextIndex }) => new PublicDataTreeLeafPreimage(leaf, nextKey, nextIndex));
+  }
+
+  /**
+   * Creates a PublicDataTreeLeafPreimage from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataTreeLeafPreimage fields
+   * @returns A PublicDataTreeLeafPreimage instance
+   */
+  static fromPlainObject(obj: any): PublicDataTreeLeafPreimage {
+    if (obj instanceof PublicDataTreeLeafPreimage) {
+      return obj;
+    }
+    return new PublicDataTreeLeafPreimage(
+      PublicDataTreeLeaf.fromPlainObject(obj.leaf),
+      Fr.fromPlainObject(obj.nextKey),
+      typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex),
+    );
+  }
+
+  static get leafSchema() {
+    return PublicDataTreeLeaf.schema;
   }
 
   getKey(): bigint {
-    return this.slot.toBigInt();
+    return this.leaf.getKey();
   }
 
   getNextKey(): bigint {
-    return this.nextSlot.toBigInt();
+    return this.nextKey.toBigInt();
   }
 
   getNextIndex(): bigint {
@@ -56,7 +71,7 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): PublicDataTreeLeaf {
-    return new PublicDataTreeLeaf(this.slot, this.value);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -65,45 +80,42 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
 
   toHashInputs(): Buffer[] {
     return [
-      Buffer.from(this.slot.toBuffer()),
-      Buffer.from(this.value.toBuffer()),
+      ...this.leaf.toHashInputs(),
       Buffer.from(toBufferBE(this.nextIndex, 32)),
-      Buffer.from(this.nextSlot.toBuffer()),
+      Buffer.from(this.nextKey.toBuffer()),
     ];
   }
 
   clone(): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(this.slot, this.value, this.nextSlot, this.nextIndex);
+    return new PublicDataTreeLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
 
   static random() {
     return new PublicDataTreeLeafPreimage(
-      Fr.random(),
-      Fr.random(),
+      PublicDataTreeLeaf.buildDummy(BigInt(Math.floor(Math.random() * 1000))),
       Fr.random(),
       BigInt(Math.floor(Math.random() * 1000)),
     );
   }
 
   static empty(): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
+    return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.empty(), Fr.ZERO, 0n);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PublicDataTreeLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    const slot = Fr.fromBuffer(reader);
-    const value = Fr.fromBuffer(reader);
+    const value = PublicDataTreeLeaf.fromBuffer(reader);
     const nextIndex = toBigIntBE(reader.readBytes(32));
     const nextSlot = Fr.fromBuffer(reader);
-    return new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex);
+    return new PublicDataTreeLeafPreimage(value, nextSlot, nextIndex);
   }
 
   static fromLeaf(leaf: PublicDataTreeLeaf, nextKey: bigint, nextIndex: bigint): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(leaf.slot, leaf.value, new Fr(nextKey), nextIndex);
+    return new PublicDataTreeLeafPreimage(leaf, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: PublicDataTreeLeafPreimage): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(preimage.slot, preimage.value, preimage.nextSlot, preimage.nextIndex);
+    return preimage.clone();
   }
 }
 
@@ -130,6 +142,14 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
     return serializeToBuffer([this.slot, this.value]);
   }
 
+  clone(): PublicDataTreeLeaf {
+    return new PublicDataTreeLeaf(this.slot, this.value);
+  }
+
+  toHashInputs(): Buffer[] {
+    return [this.slot.toBuffer(), this.value.toBuffer()];
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PublicDataTreeLeaf(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
@@ -161,4 +181,27 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
   static empty(): PublicDataTreeLeaf {
     return new PublicDataTreeLeaf(Fr.ZERO, Fr.ZERO);
   }
+
+  static get schema() {
+    return z
+      .object({
+        slot: schemas.Fr,
+        value: schemas.Fr,
+      })
+      .transform(({ slot, value }) => new PublicDataTreeLeaf(slot, value));
+  }
+
+  /**
+   * Creates a PublicDataTreeLeaf from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataTreeLeaf fields
+   * @returns A PublicDataTreeLeaf instance
+   */
+  static fromPlainObject(obj: any): PublicDataTreeLeaf {
+    if (obj instanceof PublicDataTreeLeaf) {
+      return obj;
+    }
+    return new PublicDataTreeLeaf(Fr.fromPlainObject(obj.slot), Fr.fromPlainObject(obj.value));
+  }
 }

package/src/trees/public_data_witness.ts

@@ -1,9 +1,9 @@
 import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { SiblingPath } from '@aztec/foundation/trees';
+import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
 
@@ -50,14 +50,29 @@ export class PublicDataWitness {
   public toFields(): Fr[] {
     return [
       new Fr(this.index),
-      new Fr(this.leafPreimage.slot),
-      new Fr(this.leafPreimage.value),
+      new Fr(this.leafPreimage.leaf.slot),
+      new Fr(this.leafPreimage.leaf.value),
       new Fr(this.leafPreimage.nextIndex),
-      new Fr(this.leafPreimage.nextSlot),
+      new Fr(this.leafPreimage.nextKey),
       ...this.siblingPath.toFields(),
     ];
   }
 
+  /**
+   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      new Fr(this.leafPreimage.leaf.slot).toString() as string,
+      new Fr(this.leafPreimage.leaf.value).toString() as string,
+      new Fr(this.leafPreimage.nextKey).toString() as string,
+      new Fr(this.leafPreimage.nextIndex).toString() as string,
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
+
   toBuffer(): Buffer {
     return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
   }
@@ -77,6 +92,10 @@ export class PublicDataWitness {
     );
   }
 
+  public withoutPreimage(): MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT> {
+    return new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
+  }
+
   /**
    * Deserializes an PublicDataWitness object from a buffer.
    * @param buf - Buffer or BufferReader to deserialize.