@aztec/stdlib 0.83.0 → 0.83.1-nightly.20250404

package/src/interfaces/configs.ts

@@ -1,18 +1,10 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 
 import { z } from 'zod';
 
-import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
-
-type AllowedInstance = { address: AztecAddress };
-type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
-type AllowedClass = { classId: Fr };
-type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
-
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+import { type AllowedElement, AllowedElementSchema } from './allowed_element.js';
 
 /**
  * The sequencer configuration.
@@ -37,7 +29,7 @@ export interface SequencerConfig {
   /** The path to the ACVM binary */
   acvmBinaryPath?: string;
   /** The list of functions calls allowed to run in setup */
-  allowedInSetup?: AllowedElement[];
+  txPublicSetupAllowList?: AllowedElement[];
   /** Max block size */
   maxBlockSizeInBytes?: number;
   /** Payload address to vote for */
@@ -48,13 +40,6 @@ export interface SequencerConfig {
   maxL1TxInclusionTimeIntoSlot?: number;
 }
 
-const AllowedElementSchema = z.union([
-  z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
-  z.object({ address: schemas.AztecAddress }),
-  z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
-  z.object({ classId: schemas.Fr }),
-]) satisfies ZodFor<AllowedElement>;
-
 export const SequencerConfigSchema = z.object({
   transactionPollingIntervalMS: z.number().optional(),
   maxTxsPerBlock: z.number().optional(),
@@ -65,7 +50,7 @@ export const SequencerConfigSchema = z.object({
   feeRecipient: schemas.AztecAddress.optional(),
   acvmWorkingDirectory: z.string().optional(),
   acvmBinaryPath: z.string().optional(),
-  allowedInSetup: z.array(AllowedElementSchema).optional(),
+  txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
   maxBlockSizeInBytes: z.number().optional(),
   governanceProposerPayload: schemas.EthAddress.optional(),
   maxL1TxInclusionTimeIntoSlot: z.number().optional(),

package/src/interfaces/public_state_source.ts

@@ -0,0 +1,9 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  /** Returns the value for a given slot at a given contract. */
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}

package/src/interfaces/server.ts

@@ -17,3 +17,4 @@ export * from './p2p.js';
 export * from './p2p-bootstrap.js';
 export * from './l2_logs_source.js';
 export * from './merkle_tree_operations.js';
+export * from './allowed_element.js';

package/src/proofs/proof.ts

@@ -17,11 +17,6 @@ export class Proof {
   // Make sure this type is not confused with other buffer wrappers
   readonly __proofBrand: any;
 
-  // Honk proofs start with a 4 byte length prefix
-  // the proof metadata starts immediately after
-  // TODO(https://github.com/AztecProtocol/barretenberg/issues/1312): Get rid of if possible.
-  private readonly metadataOffset = 4;
-
   constructor(
     /**
      * Holds the serialized proof data in a binary buffer format.
@@ -69,14 +64,14 @@ export class Proof {
       return this.buffer;
     }
     // We are indexing to this particular size because we are assuming the proof buffer looks like:
-    // [4 bytes of metadata for public inputs, binary public inputs, 4 bytes of metadata for proof, binary proof]
-    const proofStart = this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs + this.metadataOffset;
+    // [binary public inputs, binary proof]
+    const proofStart = Fr.SIZE_IN_BYTES * this.numPublicInputs;
     assert(this.buffer.length >= proofStart, 'Proof buffer is not appropriately sized to call withoutPublicInputs()');
     return this.buffer.subarray(proofStart);
   }
 
   // This function assumes that the proof will contain an aggregation object and look something like:
-  // [4 bytes of metadata for public inputs, binary public inputs, 4 bytes of metadata for proof, aggregation object, rest of proof]
+  // [binary public inputs, aggregation object, rest of proof]
   // We are extracting the binary public inputs and reading them as Frs, and also extracting the aggregation object.
   public extractPublicInputs(): Fr[] {
     if (this.isEmpty()) {
@@ -85,9 +80,7 @@ export class Proof {
     }
     assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
     const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-    const reader = BufferReader.asReader(
-      this.buffer.subarray(this.metadataOffset, this.metadataOffset + Fr.SIZE_IN_BYTES * numInnerPublicInputs),
-    );
+    const reader = BufferReader.asReader(this.buffer.subarray(0, Fr.SIZE_IN_BYTES * numInnerPublicInputs));
     let publicInputs = reader.readArray(numInnerPublicInputs, Fr);
     // concatenate Fr[] with aggregation object
     publicInputs = publicInputs.concat(this.extractAggregationObject());
@@ -101,12 +94,9 @@ export class Proof {
     }
     assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
     const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-    // The aggregation object is currently stored after the initial inner public inputs and after the 4 byte proof metadata.
+    // The aggregation object is currently stored after the initial inner public inputs.
     const reader = BufferReader.asReader(
-      this.buffer.subarray(
-        this.metadataOffset + Fr.SIZE_IN_BYTES * numInnerPublicInputs + this.metadataOffset,
-        this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs + this.metadataOffset,
-      ),
+      this.buffer.subarray(Fr.SIZE_IN_BYTES * numInnerPublicInputs, Fr.SIZE_IN_BYTES * this.numPublicInputs),
     );
     return reader.readArray(AGGREGATION_OBJECT_LENGTH, Fr);
   }

package/src/tests/factories.ts

@@ -69,6 +69,7 @@ import {
   AvmGetSiblingPathHint,
   AvmSequentialInsertHintNullifierTree,
   AvmSequentialInsertHintPublicDataTree,
+  AvmTxHint,
   RevertCode,
 } from '../avm/index.js';
 import { PublicDataHint } from '../avm/public_data_hint.js';
@@ -1427,6 +1428,22 @@ export function makeAvmEnqueuedCallHint(seed = 0): AvmEnqueuedCallHint {
   );
 }
 
+export function makeAvmTxHint(seed = 0): AvmTxHint {
+  return new AvmTxHint(
+    {
+      noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
+      nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x2000),
+    },
+    {
+      noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x3000),
+      nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x4000),
+    },
+    makeArray((seed % 20) + 4, i => makeAvmEnqueuedCallHint(i), seed + 0x5000), // setupEnqueuedCalls
+    makeArray((seed % 20) + 4, i => makeAvmEnqueuedCallHint(i), seed + 0x6000), // appLogicEnqueuedCalls
+    makeAvmEnqueuedCallHint(seed + 0x7000), // teardownEnqueuedCall
+  );
+}
+
 /**
  * Creates arbitrary AvmExecutionHints.
  * @param seed - The seed to use for generating the hints.
@@ -1441,7 +1458,7 @@ export async function makeAvmExecutionHints(
   const baseLength = lengthOffset + (seed % lengthSeedMod);
 
   const fields = {
-    enqueuedCalls: makeArray(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
+    tx: makeAvmTxHint(seed + 0x4100),
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
     bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
@@ -1468,7 +1485,7 @@ export async function makeAvmExecutionHints(
   };
 
   return new AvmExecutionHints(
-    fields.enqueuedCalls,
+    fields.tx,
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,

package/src/trees/database_public_state_source.ts

@@ -0,0 +1,30 @@
+import { Fr } from '@aztec/foundation/fields';
+
+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

@@ -6,3 +6,4 @@ 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';