@aztec/stdlib 1.0.0-nightly.20250605 → 1.0.0-nightly.20250607

package/src/messaging/l2_to_l1_message.ts

@@ -1,9 +1,7 @@
-import { L2_TO_L1_MESSAGE_LENGTH, SCOPED_L2_TO_L1_MESSAGE_LENGTH } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
@@ -13,7 +11,6 @@ export class L2ToL1Message {
   constructor(
     public recipient: EthAddress,
     public content: Fr,
-    public counter: number,
   ) {}
 
   static get schema() {
@@ -21,9 +18,8 @@ export class L2ToL1Message {
       .object({
         recipient: schemas.EthAddress,
         content: schemas.Fr,
-        counter: z.number().int().nonnegative(),
       })
-      .transform(({ recipient, content, counter }) => new L2ToL1Message(recipient, content, counter));
+      .transform(({ recipient, content }) => new L2ToL1Message(recipient, content));
   }
 
   /**
@@ -31,7 +27,7 @@ export class L2ToL1Message {
    * @returns An instance of L2ToL1Message with empty fields.
    */
   static empty(): L2ToL1Message {
-    return new L2ToL1Message(EthAddress.ZERO, Fr.zero(), 0);
+    return new L2ToL1Message(EthAddress.ZERO, Fr.zero());
   }
 
   /**
@@ -40,9 +36,7 @@ export class L2ToL1Message {
    * @returns True if both recipient and content are equal.
    */
   equals(other: L2ToL1Message): boolean {
-    return (
-      this.recipient.equals(other.recipient) && this.content.equals(other.content) && this.counter === other.counter
-    );
+    return this.recipient.equals(other.recipient) && this.content.equals(other.content);
   }
 
   /**
@@ -50,7 +44,7 @@ export class L2ToL1Message {
    * @returns The buffer.
    */
   toBuffer(): Buffer {
-    return serializeToBuffer(this.recipient, this.content, this.counter);
+    return serializeToBuffer(this.recipient, this.content);
   }
 
   /**
@@ -58,13 +52,7 @@ export class L2ToL1Message {
    * @returns An array of fields representing the serialized message.
    */
   toFields(): Fr[] {
-    const fields = [this.recipient.toField(), this.content, new Fr(this.counter)];
-    if (fields.length !== L2_TO_L1_MESSAGE_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for L2ToL1Message. Expected ${L2_TO_L1_MESSAGE_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
+    return [this.recipient.toField(), this.content];
   }
 
   /**
@@ -74,7 +62,7 @@ export class L2ToL1Message {
    */
   static fromFields(fields: Fr[] | FieldReader): L2ToL1Message {
     const reader = FieldReader.asReader(fields);
-    return new L2ToL1Message(reader.readObject(EthAddress), reader.readField(), reader.readU32());
+    return new L2ToL1Message(reader.readObject(EthAddress), reader.readField());
   }
 
   /**
@@ -84,7 +72,7 @@ export class L2ToL1Message {
    */
   static fromBuffer(buffer: Buffer | BufferReader): L2ToL1Message {
     const reader = BufferReader.asReader(buffer);
-    return new L2ToL1Message(reader.readObject(EthAddress), reader.readObject(Fr), reader.readNumber());
+    return new L2ToL1Message(reader.readObject(EthAddress), reader.readObject(Fr));
   }
 
   /**
@@ -92,14 +80,56 @@ export class L2ToL1Message {
    * @returns True if both recipient and content are zero.
    */
   isEmpty(): boolean {
-    return this.recipient.isZero() && this.content.isZero() && !this.counter;
+    return this.recipient.isZero() && this.content.isZero();
   }
 
-  scope(contractAddress: AztecAddress) {
+  scope(contractAddress: AztecAddress): ScopedL2ToL1Message {
     return new ScopedL2ToL1Message(this, contractAddress);
   }
 }
 
+export class CountedL2ToL1Message {
+  constructor(
+    public message: L2ToL1Message,
+    public counter: number,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        message: L2ToL1Message.schema,
+        counter: z.number().int().nonnegative(),
+      })
+      .transform(({ message, counter }) => new CountedL2ToL1Message(message, counter));
+  }
+
+  static empty() {
+    return new CountedL2ToL1Message(L2ToL1Message.empty(), 0);
+  }
+
+  isEmpty(): boolean {
+    return this.message.isEmpty() && !this.counter;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CountedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readNumber());
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.message, this.counter);
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new CountedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readU32());
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(this.message, this.counter);
+  }
+}
+
 export class ScopedL2ToL1Message {
   constructor(
     public message: L2ToL1Message,
@@ -115,20 +145,12 @@ export class ScopedL2ToL1Message {
       .transform(({ message, contractAddress }) => new ScopedL2ToL1Message(message, contractAddress));
   }
 
-  static getFields(fields: FieldsOf<ScopedL2ToL1Message>) {
-    return [fields.message, fields.contractAddress] as const;
-  }
-
   static empty() {
     return new ScopedL2ToL1Message(L2ToL1Message.empty(), AztecAddress.ZERO);
   }
 
-  equals(other: ScopedL2ToL1Message): boolean {
-    return this.message.equals(other.message) && this.contractAddress.equals(other.contractAddress);
-  }
-
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.message, this.contractAddress);
+  isEmpty(): boolean {
+    return this.message.isEmpty() && this.contractAddress.isZero();
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -136,22 +158,49 @@ export class ScopedL2ToL1Message {
     return new ScopedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readObject(AztecAddress));
   }
 
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.message, this.contractAddress);
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return new ScopedL2ToL1Message(reader.readObject(L2ToL1Message), reader.readObject(AztecAddress));
   }
 
   toFields(): Fr[] {
-    const fields = serializeToFields(...ScopedL2ToL1Message.getFields(this));
-    if (fields.length !== SCOPED_L2_TO_L1_MESSAGE_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for ScopedL2ToL1Message. Expected ${SCOPED_L2_TO_L1_MESSAGE_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
+    return serializeToFields(this.message, this.contractAddress);
+  }
+}
+
+export class ScopedCountedL2ToL1Message {
+  constructor(
+    public inner: CountedL2ToL1Message,
+    public contractAddress: AztecAddress,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        inner: CountedL2ToL1Message.schema,
+        contractAddress: AztecAddress.schema,
+      })
+      .transform(({ inner, contractAddress }) => new ScopedCountedL2ToL1Message(inner, contractAddress));
+  }
+
+  static empty() {
+    return new ScopedCountedL2ToL1Message(CountedL2ToL1Message.empty(), AztecAddress.ZERO);
   }
 
   isEmpty(): boolean {
-    return this.message.isEmpty() && this.contractAddress.isZero();
+    return this.inner.isEmpty() && this.contractAddress.isZero();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new ScopedCountedL2ToL1Message(reader.readObject(CountedL2ToL1Message), reader.readObject(AztecAddress));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.inner, this.contractAddress);
   }
 }

package/src/note/extended_note.ts

@@ -87,8 +87,8 @@ export class UniqueNote extends ExtendedNote {
     storageSlot: Fr,
     /** The hash of the tx the note was created in. */
     txHash: TxHash,
-    /** The nonce of the note. */
-    public nonce: Fr,
+    /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
+    public noteNonce: Fr,
   ) {
     super(note, recipient, contractAddress, storageSlot, txHash);
   }
@@ -101,10 +101,10 @@ export class UniqueNote extends ExtendedNote {
         contractAddress: schemas.AztecAddress,
         storageSlot: schemas.Fr,
         txHash: TxHash.schema,
-        nonce: schemas.Fr,
+        noteNonce: schemas.Fr,
       })
-      .transform(({ note, recipient, contractAddress, storageSlot, txHash, nonce }) => {
-        return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, nonce);
+      .transform(({ note, recipient, contractAddress, storageSlot, txHash, noteNonce }) => {
+        return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, noteNonce);
       });
   }
 
@@ -115,7 +115,7 @@ export class UniqueNote extends ExtendedNote {
       this.contractAddress,
       this.storageSlot,
       this.txHash,
-      this.nonce,
+      this.noteNonce,
     ]);
   }
 
@@ -138,9 +138,9 @@ export class UniqueNote extends ExtendedNote {
     const contractAddress = reader.readObject(AztecAddress);
     const storageSlot = reader.readObject(Fr);
     const txHash = reader.readObject(TxHash);
-    const nonce = reader.readObject(Fr);
+    const noteNonce = reader.readObject(Fr);
 
-    return new this(note, recipient, contractAddress, storageSlot, txHash, nonce);
+    return new this(note, recipient, contractAddress, storageSlot, txHash, noteNonce);
   }
 
   static override fromString(str: string) {

package/src/tests/factories.ts

@@ -126,7 +126,7 @@ import { PublicKeys, computeAddress } from '../keys/index.js';
 import { ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { PublicLog } from '../logs/public_log.js';
-import { L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { BaseParityInputs } from '../parity/base_parity_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import { RootParityInput } from '../parity/root_parity_input.js';
@@ -593,7 +593,7 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
     privateCallRequests: makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, makePrivateCallRequest, seed + 0x600),
     publicCallRequests: makeTuple(MAX_ENQUEUED_CALLS_PER_CALL, makeCountedPublicCallRequest, seed + 0x700),
     publicTeardownCallRequest: makePublicCallRequest(seed + 0x800),
-    l2ToL1Msgs: makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, makeL2ToL1Message, seed + 0x800),
+    l2ToL1Msgs: makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, makeCountedL2ToL1Message, seed + 0x800),
     privateLogs: makeTuple(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
     contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeCountedLogHash, seed + 0xa00),
     startSideEffectCounter: fr(seed + 0x849),
@@ -613,13 +613,13 @@ export function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<Global
     timestamp: new Fr(seed + 4),
     coinbase: EthAddress.fromField(new Fr(seed + 5)),
     feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),
-    gasFees: new GasFees(new Fr(seed + 7), new Fr(seed + 8)),
+    gasFees: new GasFees(seed + 7, seed + 8),
     ...compact(overrides),
   });
 }
 
 export function makeGasFees(seed = 1) {
-  return new GasFees(fr(seed), fr(seed + 1));
+  return new GasFees(seed, seed + 1);
 }
 
 export function makeFeeRecipient(seed = 1) {
@@ -644,10 +644,6 @@ export function makeConstantRollupData(
   });
 }
 
-export function makeScopedL2ToL1Message(seed = 1): ScopedL2ToL1Message {
-  return new ScopedL2ToL1Message(makeL2ToL1Message(seed), makeAztecAddress(seed + 3));
-}
-
 /**
  * Makes arbitrary append only tree snapshot.
  * @param seed - The seed to use for generating the append only tree snapshot.
@@ -969,7 +965,15 @@ export function makeL2ToL1Message(seed = 0): L2ToL1Message {
   const recipient = EthAddress.fromField(new Fr(seed));
   const content = new Fr(seed + 1);
 
-  return new L2ToL1Message(recipient, content, seed + 2);
+  return new L2ToL1Message(recipient, content);
+}
+
+function makeCountedL2ToL1Message(seed = 0) {
+  return new CountedL2ToL1Message(makeL2ToL1Message(seed), seed + 2);
+}
+
+function makeScopedL2ToL1Message(seed = 1) {
+  return new ScopedL2ToL1Message(makeL2ToL1Message(seed), makeAztecAddress(seed + 3));
 }
 
 /**

package/src/tests/mocks.ts

@@ -67,7 +67,7 @@ export const randomUniqueNote = async ({
   contractAddress = undefined,
   txHash = randomTxHash(),
   storageSlot = Fr.random(),
-  nonce = Fr.random(),
+  noteNonce = Fr.random(),
 }: Partial<UniqueNote> = {}) => {
   return new UniqueNote(
     note,
@@ -75,7 +75,7 @@ export const randomUniqueNote = async ({
     contractAddress ?? (await AztecAddress.random()),
     storageSlot,
     txHash,
-    nonce,
+    noteNonce,
   );
 };
 

package/src/tx/global_variables.ts

@@ -169,8 +169,8 @@ export class GlobalVariables {
       timestamp: this.timestamp.toNumber(),
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
-      feePerDaGas: this.gasFees.feePerDaGas.toNumber(),
-      feePerL2Gas: this.gasFees.feePerL2Gas.toNumber(),
+      feePerDaGas: Number(this.gasFees.feePerDaGas),
+      feePerL2Gas: Number(this.gasFees.feePerL2Gas),
     };
   }
 

package/src/tx/proposed_block_header.ts

@@ -154,7 +154,7 @@ export class ProposedBlockHeader {
   }
 
   [inspect.custom]() {
-    const gasfees = `da:${this.gasFees.feePerDaGas.toBigInt()}, l2:${this.gasFees.feePerL2Gas.toBigInt()}`;
+    const gasfees = `da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas}`;
     return `Header {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
   contentCommitment: ${inspect(this.contentCommitment)},

package/src/types/shared.ts

@@ -30,6 +30,11 @@ export type UInt32 = number;
  */
 export type UInt64 = bigint;
 
+/**
+ * A type alias for a 128-bit unsigned integer.
+ */
+export type UInt128 = bigint;
+
 /**
  * CircuitType replaces ComposerType for now. When using Plonk, CircuitType is equivalent to the information of the proving system that will be used
  * to construct a proof. In the future Aztec zk stack, more information must be specified (e.g., the curve over which circuits are  constructed;

package/src/zkpassport/index.ts

@@ -0,0 +1,115 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { withoutHexPrefix } from '@aztec/foundation/string';
+
+export type ViemZkPassportProofParams = {
+  vkeyHash: `0x${string}`;
+  proof: `0x${string}`;
+  publicInputs: `0x${string}`[];
+  committedInputs: `0x${string}`;
+  committedInputCounts: bigint[];
+  validityPeriodInDays: bigint;
+  scope: string;
+  subscope: string;
+  devMode: boolean;
+};
+
+// NOTE: Must match the ZkPassportProofParams struct in the zkpassport verifier contract
+// find here: ROOT/l1-contracts/lib/circuits/src/solidity/src/ZKPassportVerifier.sol
+export class ZkPassportProofParams {
+  constructor(
+    public devMode: boolean,
+    public vkeyHash: Buffer32,
+    public proof: Buffer,
+    public publicInputs: Fr[],
+    public committedInputs: Buffer,
+    public committedInputCounts: bigint[],
+    public validityPeriodInDays: bigint,
+    public scope: string,
+    public subscope: string,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer([
+      this.devMode,
+      this.vkeyHash,
+      this.proof.length,
+      this.proof,
+      this.publicInputs.length,
+      this.publicInputs,
+      this.committedInputs.length,
+      this.committedInputs,
+      this.committedInputCounts.length,
+      this.committedInputCounts,
+      this.validityPeriodInDays,
+      this.scope,
+      this.subscope,
+    ]);
+  }
+
+  static random() {
+    const committedInputCounts = [BigInt(1), BigInt(2), BigInt(3), BigInt(4)];
+    const numberOfCommittedInputs = committedInputCounts.reduce((acc, count) => acc + count, BigInt(0));
+    const committedInputs = randomBytes(Number(numberOfCommittedInputs) * 32);
+
+    const publicInputsCount = numberOfCommittedInputs + 16n;
+    const publicInputs = Array.from({ length: Number(publicInputsCount) }, () => Fr.random());
+
+    return new ZkPassportProofParams(
+      false,
+      Buffer32.random(),
+      randomBytes(1024),
+      publicInputs,
+      committedInputs,
+      committedInputCounts,
+      BigInt(100),
+      'sequencer.alpha-testnet.aztec.network',
+      'personhood',
+    );
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return new ZkPassportProofParams(
+      reader.readBoolean(),
+      reader.readObject(Buffer32),
+      reader.readBuffer(),
+      reader.readVector(Fr),
+      reader.readBuffer(),
+      reader.readUint256Vector(),
+      reader.readUInt256(),
+      reader.readString(),
+      reader.readString(),
+    );
+  }
+
+  static fromViem(params: ViemZkPassportProofParams) {
+    return new ZkPassportProofParams(
+      params.devMode,
+      Buffer32.fromString(params.vkeyHash),
+      Buffer.from(withoutHexPrefix(params.proof), 'hex'),
+      params.publicInputs.map(input => Fr.fromString(input)),
+      Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'),
+      params.committedInputCounts,
+      params.validityPeriodInDays,
+      params.scope,
+      params.subscope,
+    );
+  }
+
+  toViem(): ViemZkPassportProofParams {
+    return {
+      devMode: this.devMode,
+      vkeyHash: this.vkeyHash.toString(),
+      proof: `0x${this.proof.toString('hex')}`,
+      publicInputs: this.publicInputs.map(input => input.toString()),
+      committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      committedInputCounts: this.committedInputCounts,
+      validityPeriodInDays: this.validityPeriodInDays,
+      scope: this.scope,
+      subscope: this.subscope,
+    };
+  }
+}