@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

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 { 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/protocol_contract_leaf.ts

@@ -89,10 +89,6 @@ export class ProtocolContractLeafPreimage implements IndexedTreeLeafPreimage {
       toBigIntBE(reader.readBytes(32)),
     );
   }
-
-  static fromLeaf(leaf: ProtocolContractLeaf, nextKey: bigint, nextIndex: bigint): ProtocolContractLeafPreimage {
-    return new ProtocolContractLeafPreimage(leaf.address, new Fr(nextKey), nextIndex);
-  }
 }
 
 /**

package/src/trees/public_data_leaf.ts

@@ -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,23 @@ 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));
+  }
+
+  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 +53,7 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): PublicDataTreeLeaf {
-    return new PublicDataTreeLeaf(this.slot, this.value);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -65,45 +62,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 +124,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 +163,13 @@ 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));
+  }
 }

package/src/trees/public_data_witness.ts

@@ -3,7 +3,7 @@ import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 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.

package/src/tx/block_header.ts

@@ -12,6 +12,7 @@ import { z } from 'zod';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { ContentCommitment } from './content_commitment.js';
 import { GlobalVariables } from './global_variables.js';
+import { ProposedBlockHeader } from './proposed_block_header.js';
 import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
@@ -45,7 +46,7 @@ export class BlockHeader {
   }
 
   static getFields(fields: FieldsOf<BlockHeader>) {
-    // Note: The order here must match the order in the HeaderLib solidity library.
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return [
       fields.lastArchive,
       fields.contentCommitment,
@@ -64,6 +65,10 @@ export class BlockHeader {
     return this.globalVariables.slotNumber.toBigInt();
   }
 
+  getBlockNumber() {
+    return this.globalVariables.blockNumber;
+  }
+
   getSize() {
     return (
       this.lastArchive.getSize() +
@@ -119,7 +124,7 @@ export class BlockHeader {
 
   static empty(fields: Partial<FieldsOf<BlockHeader>> = {}): BlockHeader {
     return BlockHeader.from({
-      lastArchive: AppendOnlyTreeSnapshot.zero(),
+      lastArchive: AppendOnlyTreeSnapshot.empty(),
       contentCommitment: ContentCommitment.empty(),
       state: StateReference.empty(),
       globalVariables: GlobalVariables.empty(),
@@ -131,7 +136,7 @@ export class BlockHeader {
 
   isEmpty(): boolean {
     return (
-      this.lastArchive.isZero() &&
+      this.lastArchive.isEmpty() &&
       this.contentCommitment.isEmpty() &&
       this.state.isEmpty() &&
       this.globalVariables.isEmpty() &&
@@ -156,6 +161,19 @@ export class BlockHeader {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
   }
 
+  toPropose(): ProposedBlockHeader {
+    return new ProposedBlockHeader(
+      this.lastArchive.root,
+      this.contentCommitment,
+      this.globalVariables.slotNumber,
+      this.globalVariables.timestamp,
+      this.globalVariables.coinbase,
+      this.globalVariables.feeRecipient,
+      this.globalVariables.gasFees,
+      this.totalManaUsed,
+    );
+  }
+
   toInspect() {
     return {
       lastArchive: this.lastArchive.root.toString(),
@@ -170,10 +188,9 @@ export class BlockHeader {
   [inspect.custom]() {
     return `Header {
   lastArchive: ${inspect(this.lastArchive)},
-  contentCommitment.numTxs: ${this.contentCommitment.numTxs.toNumber()},
-  contentCommitment.blobsHash: ${this.contentCommitment.blobsHash.toString('hex')},
-  contentCommitment.inHash: ${this.contentCommitment.inHash.toString('hex')},
-  contentCommitment.outHash: ${this.contentCommitment.outHash.toString('hex')},
+  contentCommitment.blobsHash: ${inspect(this.contentCommitment.blobsHash)},
+  contentCommitment.inHash: ${inspect(this.contentCommitment.inHash)},
+  contentCommitment.outHash: ${inspect(this.contentCommitment.outHash)},
   state.l1ToL2MessageTree: ${inspect(this.state.l1ToL2MessageTree)},
   state.noteHashTree: ${inspect(this.state.partial.noteHashTree)},
   state.nullifierTree: ${inspect(this.state.partial.nullifierTree)},

package/src/tx/capsule.ts

@@ -8,6 +8,8 @@ import { Vector } from '../types/shared.js';
 
 /**
  * Read-only data that is passed to the contract through an oracle during a transaction execution.
+ * TODO(#12425): Check whether this is always used to represent a transient capsule and if so, rename to
+ * TransientCapsule.
  */
 export class Capsule {
   constructor(

package/src/tx/content_commitment.ts

@@ -1,45 +1,31 @@
-import { CONTENT_COMMITMENT_LENGTH } from '@aztec/constants';
+import type { ViemContentCommitment } from '@aztec/ethereum';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-export const NUM_BYTES_PER_SHA256 = 32;
-
 export class ContentCommitment {
-  constructor(public numTxs: Fr, public blobsHash: Buffer, public inHash: Buffer, public outHash: Buffer) {
-    // NB: we do not calculate blobHash in the circuit, but we still truncate it so it fits in a field
-    if (blobsHash.length !== NUM_BYTES_PER_SHA256) {
-      throw new Error(`blobsHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);
-    }
-    if (blobsHash[0] !== 0) {
-      throw new Error(`blobsHash buffer should be truncated and left padded`);
-    }
-    if (inHash.length !== NUM_BYTES_PER_SHA256) {
-      throw new Error(`inHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);
-    }
-    if (inHash[0] !== 0) {
-      throw new Error(`inHash buffer should be truncated and left padded`);
-    }
-    if (outHash.length !== NUM_BYTES_PER_SHA256) {
-      throw new Error(`outHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);
-    }
-    if (outHash[0] !== 0) {
-      throw new Error(`outHash buffer should be truncated and left padded`);
-    }
-  }
+  constructor(
+    public blobsHash: Fr,
+    public inHash: Fr,
+    public outHash: Fr,
+  ) {}
 
   static get schema() {
     return z
       .object({
-        numTxs: schemas.Fr,
-        blobsHash: schemas.Buffer,
-        inHash: schemas.Buffer,
-        outHash: schemas.Buffer,
+        blobsHash: schemas.Fr,
+        inHash: schemas.Fr,
+        outHash: schemas.Fr,
       })
-      .transform(({ numTxs, blobsHash, inHash, outHash }) => new ContentCommitment(numTxs, blobsHash, inHash, outHash));
+      .transform(({ blobsHash, inHash, outHash }) => new ContentCommitment(blobsHash, inHash, outHash));
+  }
+
+  static getFields(fields: FieldsOf<ContentCommitment>) {
+    return [fields.blobsHash, fields.inHash, fields.outHash] as const;
   }
 
   getSize() {
@@ -47,70 +33,58 @@ export class ContentCommitment {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.numTxs, this.blobsHash, this.inHash, this.outHash);
+    return serializeToBuffer(...ContentCommitment.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ContentCommitment {
+    const reader = BufferReader.asReader(buffer);
+
+    return new ContentCommitment(reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr));
   }
 
   toInspect() {
     return {
-      numTxs: this.numTxs.toNumber(),
-      blobsHash: bufferToHex(this.blobsHash),
-      inHash: bufferToHex(this.inHash),
-      outHash: bufferToHex(this.outHash),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.outHash.toString(),
     };
   }
 
-  toFields(): Fr[] {
-    const serialized = [
-      this.numTxs,
-      Fr.fromBuffer(this.blobsHash),
-      Fr.fromBuffer(this.inHash),
-      Fr.fromBuffer(this.outHash),
-    ];
-    if (serialized.length !== CONTENT_COMMITMENT_LENGTH) {
-      throw new Error(
-        `Expected content commitment to have ${CONTENT_COMMITMENT_LENGTH} fields, but it has ${serialized.length} fields`,
-      );
-    }
-    return serialized;
+  toViem(): ViemContentCommitment {
+    return {
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.outHash.toString(),
+    };
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): ContentCommitment {
-    const reader = BufferReader.asReader(buffer);
-
+  static fromViem(contentCommitment: ViemContentCommitment) {
     return new ContentCommitment(
-      reader.readObject(Fr),
-      reader.readBytes(NUM_BYTES_PER_SHA256),
-      reader.readBytes(NUM_BYTES_PER_SHA256),
-      reader.readBytes(NUM_BYTES_PER_SHA256),
+      Fr.fromString(contentCommitment.blobsHash),
+      Fr.fromString(contentCommitment.inHash),
+      Fr.fromString(contentCommitment.outHash),
     );
   }
 
+  toFields(): Fr[] {
+    return serializeToFields(...ContentCommitment.getFields(this));
+  }
+
   static fromFields(fields: Fr[] | FieldReader): ContentCommitment {
     const reader = FieldReader.asReader(fields);
-    return new ContentCommitment(
-      reader.readField(),
-      reader.readField().toBuffer(),
-      reader.readField().toBuffer(),
-      reader.readField().toBuffer(),
-    );
+    return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
+  }
+
+  static random(): ContentCommitment {
+    return new ContentCommitment(Fr.random(), Fr.random(), Fr.random());
   }
 
   static empty(): ContentCommitment {
-    return new ContentCommitment(
-      Fr.zero(),
-      Buffer.alloc(NUM_BYTES_PER_SHA256),
-      Buffer.alloc(NUM_BYTES_PER_SHA256),
-      Buffer.alloc(NUM_BYTES_PER_SHA256),
-    );
+    return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
   }
 
   isEmpty(): boolean {
-    return (
-      this.numTxs.isZero() &&
-      this.blobsHash.equals(Buffer.alloc(NUM_BYTES_PER_SHA256)) &&
-      this.inHash.equals(Buffer.alloc(NUM_BYTES_PER_SHA256)) &&
-      this.outHash.equals(Buffer.alloc(NUM_BYTES_PER_SHA256))
-    );
+    return this.blobsHash.isZero() && this.inHash.isZero() && this.outHash.isZero();
   }
 
   public toString(): string {
@@ -124,10 +98,7 @@ export class ContentCommitment {
 
   public equals(other: this): boolean {
     return (
-      this.inHash.equals(other.inHash) &&
-      this.outHash.equals(other.outHash) &&
-      this.numTxs.equals(other.numTxs) &&
-      this.blobsHash.equals(other.blobsHash)
+      this.blobsHash.equals(other.blobsHash) && this.inHash.equals(other.inHash) && this.outHash.equals(other.outHash)
     );
   }
 }

package/src/tx/global_variable_builder.ts

@@ -1,8 +1,8 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { GasFees } from '../gas/gas_fees.js';
+import type { UInt32 } from '../types/index.js';
 import type { GlobalVariables } from './global_variables.js';
 
 /**
@@ -20,7 +20,7 @@ export interface GlobalVariableBuilder {
    * @returns A promise that resolves to the GlobalVariables for the given block number.
    */
   buildGlobalVariables(
-    blockNumber: Fr,
+    blockNumber: UInt32,
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber?: bigint,