@aztec/stdlib 0.82.2 → 0.82.3

package/src/tests/factories.ts

@@ -44,7 +44,7 @@ import {
 import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { compact } from '@aztec/foundation/collection';
-import { SchnorrSignature, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import type { Bufferable } from '@aztec/foundation/serialize';
@@ -55,7 +55,6 @@ import { ContractStorageRead } from '../avm/contract_storage_read.js';
 import { ContractStorageUpdateRequest } from '../avm/contract_storage_update_request.js';
 import {
   AvmAccumulatedData,
-  AvmAppendTreeHint,
   AvmBytecodeCommitmentHint,
   AvmCircuitInputs,
   AvmCircuitPublicInputs,
@@ -63,10 +62,11 @@ import {
   AvmContractInstanceHint,
   AvmEnqueuedCallHint,
   AvmExecutionHints,
-  AvmNullifierReadTreeHint,
-  AvmNullifierWriteTreeHint,
-  AvmPublicDataReadTreeHint,
-  AvmPublicDataWriteTreeHint,
+  AvmGetLeafPreimageHintNullifierTree,
+  AvmGetLeafPreimageHintPublicDataTree,
+  AvmGetLeafValueHint,
+  AvmGetPreviousValueIndexHint,
+  AvmGetSiblingPathHint,
   RevertCode,
 } from '../avm/index.js';
 import { PublicDataHint } from '../avm/public_data_hint.js';
@@ -144,7 +144,7 @@ import { PublicTubeData } from '../rollup/public_tube_data.js';
 import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
 import { PrivateBaseStateDiffHints } from '../rollup/state_diff_hints.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
+import { NullifierLeaf, NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { CallContext } from '../tx/call_context.js';
@@ -990,6 +990,15 @@ export function makePublicDataTreeLeaf(seed = 0): PublicDataTreeLeaf {
   return new PublicDataTreeLeaf(new Fr(seed), new Fr(seed + 1));
 }
 
+/**
+ * Makes arbitrary nullifier leaf.
+ * @param seed - The seed to use for generating the nullifier leaf.
+ * @returns A nullifier leaf.
+ */
+export function makeNullifierLeaf(seed = 0): NullifierLeaf {
+  return new NullifierLeaf(new Fr(seed));
+}
+
 /**
  * Makes arbitrary public data tree leaf preimages.
  * @param seed - The seed to use for generating the public data tree leaf preimage.
@@ -1261,51 +1270,62 @@ export async function makeContractInstanceFromClassId(
   }).withAddress(address);
 }
 
-export function makeAvmTreeHints(seed = 0): AvmAppendTreeHint {
-  return new AvmAppendTreeHint(
-    new Fr(seed),
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
-  );
-}
-
-export function makeAvmNullifierReadTreeHints(seed = 0): AvmNullifierReadTreeHint {
-  const lowNullifierPreimage = new NullifierLeafPreimage(new Fr(seed), new Fr(seed + 1), BigInt(seed + 2));
-  return new AvmNullifierReadTreeHint(
-    lowNullifierPreimage,
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetSiblingPathHint(seed = 0): AvmGetSiblingPathHint {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetSiblingPathHint(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*treeId=*/ (seed + 1) % 5,
+    /*index=*/ index,
+    makeArray(seed % 64, i => new Fr(i), seed + 10),
   );
 }
 
-export function makeAvmPublicDataReadTreeHints(seed = 0): AvmPublicDataReadTreeHint {
-  return new AvmPublicDataReadTreeHint(
-    new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)),
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetPreviousValueIndexHint(seed = 0): AvmGetPreviousValueIndexHint {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  const value = new Fr(BigInt(`0x${sha256(Buffer.from((seed + 2).toString())).toString('hex')}`) % (1n << 128n));
+  return new AvmGetPreviousValueIndexHint(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*treeId=*/ (seed + 1) % 5,
+    value,
+    index,
+    /*alreadyPresent=*/ index % 2n === 0n,
   );
 }
 
-export function makeAvmNullifierInsertionTreeHints(seed = 0): AvmNullifierWriteTreeHint {
-  return new AvmNullifierWriteTreeHint(
-    makeAvmNullifierReadTreeHints(seed),
-    makeArray(20, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetLeafPreimageHintPublicDataTree(seed = 0): AvmGetLeafPreimageHintPublicDataTree {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetLeafPreimageHintPublicDataTree(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*index=*/ index,
+    /*leaf=*/ makePublicDataTreeLeaf(seed + 3),
+    /*nextIndex=*/ index + 1n,
+    /*nextValue*/ new Fr(seed + 0x500),
   );
 }
 
-export function makeAvmStorageReadTreeHints(seed = 0): AvmPublicDataReadTreeHint {
-  return new AvmPublicDataReadTreeHint(
-    new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)),
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetLeafPreimageHintNullifierTree(seed = 0): AvmGetLeafPreimageHintNullifierTree {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetLeafPreimageHintNullifierTree(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*index=*/ index,
+    /*leaf=*/ makeNullifierLeaf(seed + 3),
+    /*nextIndex=*/ index + 1n,
+    /*nextValue*/ new Fr(seed + 0x500),
   );
 }
 
-export function makeAvmStorageUpdateTreeHints(seed = 0): AvmPublicDataWriteTreeHint {
-  return new AvmPublicDataWriteTreeHint(
-    makeAvmStorageReadTreeHints(seed),
-    new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)),
-    makeArray(20, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetLeafValueHint(seed = 0): AvmGetLeafValueHint {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetLeafValueHint(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*treeId=*/ (seed + 1) % 5,
+    /*index=*/ index,
+    /*value=*/ new Fr(seed + 3),
   );
 }
 
@@ -1373,13 +1393,15 @@ export async function makeAvmExecutionHints(
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
     bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
-    publicDataReads: makeArray(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
-    publicDataWrites: makeArray(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
-    nullifierReads: makeArray(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
-    nullifierWrites: makeArray(baseLength + 10, makeAvmNullifierInsertionTreeHints, seed + 0x4c00),
-    noteHashReads: makeArray(baseLength + 11, makeAvmTreeHints, seed + 0x4d00),
-    noteHashWrites: makeArray(baseLength + 12, makeAvmTreeHints, seed + 0x4e00),
-    l1ToL2MessageReads: makeArray(baseLength + 13, makeAvmTreeHints, seed + 0x4f00),
+    getSiblingPathHints: makeArray(baseLength + 5, makeAvmGetSiblingPathHint, seed + 0x4b00),
+    getPreviousValueIndexHints: makeArray(baseLength + 5, makeAvmGetPreviousValueIndexHint, seed + 0x4d00),
+    getLeafPreimageHintPublicDataTree: makeArray(
+      baseLength + 5,
+      makeAvmGetLeafPreimageHintPublicDataTree,
+      seed + 0x4f00,
+    ),
+    getLeafPreimageHintNullifierTree: makeArray(baseLength + 5, makeAvmGetLeafPreimageHintNullifierTree, seed + 0x5100),
+    getLeafValueHints: makeArray(baseLength + 5, makeAvmGetLeafValueHint, seed + 0x5300),
     ...overrides,
   };
 
@@ -1388,13 +1410,11 @@ export async function makeAvmExecutionHints(
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,
-    fields.publicDataReads,
-    fields.publicDataWrites,
-    fields.nullifierReads,
-    fields.nullifierWrites,
-    fields.noteHashReads,
-    fields.noteHashWrites,
-    fields.l1ToL2MessageReads,
+    fields.getSiblingPathHints,
+    fields.getPreviousValueIndexHints,
+    fields.getLeafPreimageHintPublicDataTree,
+    fields.getLeafPreimageHintNullifierTree,
+    fields.getLeafValueHints,
   );
 }
 

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

@@ -88,7 +88,7 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   static fromLeaf(leaf: NullifierLeaf, nextKey: bigint, nextIndex: bigint): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(leaf.nullifier, new Fr(nextKey), nextIndex);
+    return new NullifierLeafPreimage(leaf.value, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: NullifierLeafPreimage): NullifierLeafPreimage {
@@ -104,19 +104,19 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     /**
      * Nullifier value.
      */
-    public nullifier: Fr,
+    public value: Fr,
   ) {}
 
   getKey(): bigint {
-    return this.nullifier.toBigInt();
+    return this.value.toBigInt();
   }
 
   toBuffer(): Buffer {
-    return this.nullifier.toBuffer();
+    return this.value.toBuffer();
   }
 
   isEmpty(): boolean {
-    return this.nullifier.isZero();
+    return this.value.isZero();
   }
 
   updateTo(_another: NullifierLeaf): NullifierLeaf {
@@ -130,4 +130,8 @@ export class NullifierLeaf implements IndexedTreeLeaf {
   static fromBuffer(buf: Buffer): NullifierLeaf {
     return new NullifierLeaf(Fr.fromBuffer(buf));
   }
+
+  static get schema() {
+    return z.object({ value: schemas.Fr }).transform(({ value }) => new NullifierLeaf(value));
+  }
 }

package/src/trees/public_data_leaf.ts

@@ -161,4 +161,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/validators/index.ts

@@ -0,0 +1,3 @@
+export type * from './types.js';
+
+export * from './schemas.js';

package/src/validators/schemas.ts

@@ -0,0 +1,53 @@
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import type { ValidatorStats, ValidatorStatusHistory, ValidatorStatusInSlot, ValidatorsStats } from './types.js';
+
+export const ValidatorStatusInSlotSchema = z.enum([
+  'block-mined',
+  'block-proposed',
+  'block-missed',
+  'attestation-sent',
+  'attestation-missed',
+]) satisfies ZodFor<ValidatorStatusInSlot>;
+
+export const ValidatorStatusHistorySchema = z.array(
+  z.object({
+    slot: schemas.BigInt,
+    status: ValidatorStatusInSlotSchema,
+  }),
+) satisfies ZodFor<ValidatorStatusHistory>;
+
+export const ValidatorStatusHistorySchemaArray = z.array(ValidatorStatusHistorySchema);
+
+export const ValidatorStatusHistorySchemaMap = z.record(ValidatorStatusHistorySchemaArray);
+
+const ValidatorTimeStatSchema = z.object({
+  timestamp: schemas.BigInt,
+  slot: schemas.BigInt,
+  date: z.string(),
+});
+
+const ValidatorFilteredHistorySchema = z.object({
+  currentStreak: schemas.Integer,
+  rate: z.number(),
+  count: schemas.Integer,
+});
+
+export const ValidatorStatsSchema = z.object({
+  address: schemas.EthAddress,
+  lastProposal: ValidatorTimeStatSchema.optional(),
+  lastAttestation: ValidatorTimeStatSchema.optional(),
+  totalSlots: schemas.Integer,
+  missedProposals: ValidatorFilteredHistorySchema,
+  missedAttestations: ValidatorFilteredHistorySchema,
+  history: ValidatorStatusHistorySchema,
+}) satisfies ZodFor<ValidatorStats>;
+
+export const ValidatorsStatsSchema = z.object({
+  stats: z.record(ValidatorStatsSchema),
+  lastProcessedSlot: schemas.BigInt.optional(),
+  initialSlot: schemas.BigInt.optional(),
+  slotWindow: schemas.Integer,
+}) satisfies ZodFor<ValidatorsStats>;

package/src/validators/types.ts

@@ -0,0 +1,37 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+export type ValidatorStatusType = 'block' | 'attestation';
+
+export type ValidatorStatusInSlot =
+  | 'block-mined'
+  | 'block-proposed'
+  | 'block-missed'
+  | 'attestation-sent'
+  | 'attestation-missed';
+
+export type ValidatorStatusHistory = { slot: bigint; status: ValidatorStatusInSlot }[];
+
+export type ValidatorStats = {
+  address: EthAddress;
+  lastProposal?: { timestamp: bigint; slot: bigint; date: string };
+  lastAttestation?: { timestamp: bigint; slot: bigint; date: string };
+  totalSlots: number;
+  missedProposals: {
+    currentStreak: number;
+    rate: number;
+    count: number;
+  };
+  missedAttestations: {
+    currentStreak: number;
+    rate: number;
+    count: number;
+  };
+  history: ValidatorStatusHistory;
+};
+
+export type ValidatorsStats = {
+  stats: Record<string, ValidatorStats>;
+  lastProcessedSlot?: bigint;
+  initialSlot?: bigint;
+  slotWindow: number;
+};