@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/contract/unconstrained_function_membership_proof.js

@@ -0,0 +1,87 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { computeRootFromSiblingPath } from '@aztec/foundation/trees';
+import { FunctionSelector, FunctionType } from '../abi/index.js';
+import { computeArtifactFunctionTree, computeArtifactHash, computeArtifactHashPreimage, computeFunctionArtifactHash, computeFunctionMetadataHash, getArtifactMerkleTreeHasher } from './artifact_hash.js';
+/**
+ * Creates a membership proof for an unconstrained function in a contract class, to be verified via `isValidUnconstrainedFunctionMembershipProof`.
+ * @param selector - Selector of the function to create the proof for.
+ * @param artifact - Artifact of the contract class where the function is defined.
+ */ export async function createUnconstrainedFunctionMembershipProof(selector, artifact) {
+    const log = createLogger('circuits:function_membership_proof');
+    // Locate function artifact
+    const uncontrainedFunctions = artifact.functions.filter((fn)=>fn.functionType === FunctionType.UNCONSTRAINED);
+    const unconstrainedFunctionsAndSelectors = await Promise.all(uncontrainedFunctions.map(async (fn)=>({
+            fn,
+            selector: await FunctionSelector.fromNameAndParameters(fn)
+        })));
+    const fn = unconstrainedFunctionsAndSelectors.find((fnAndSelector)=>selector.equals(fnAndSelector.selector))?.fn;
+    if (!fn) {
+        throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
+    }
+    // Compute preimage for the artifact hash
+    const { privateFunctionRoot: privateFunctionsArtifactTreeRoot, metadataHash: artifactMetadataHash } = await computeArtifactHashPreimage(artifact);
+    // Compute the sibling path for the "artifact tree"
+    const functionMetadataHash = computeFunctionMetadataHash(fn);
+    const functionArtifactHash = await computeFunctionArtifactHash({
+        ...fn,
+        functionMetadataHash
+    });
+    const artifactTree = await computeArtifactFunctionTree(artifact, FunctionType.UNCONSTRAINED);
+    const artifactTreeLeafIndex = artifactTree.getIndex(functionArtifactHash.toBuffer());
+    const artifactTreeSiblingPath = artifactTree.getSiblingPath(artifactTreeLeafIndex).map(Fr.fromBuffer);
+    log.debug(`Computed proof for unconstrained function with selector ${selector.toString()}`, {
+        functionArtifactHash,
+        functionMetadataHash,
+        artifactMetadataHash,
+        artifactFunctionTreeSiblingPath: artifactTreeSiblingPath.map((fr)=>fr.toString()).join(','),
+        privateFunctionsArtifactTreeRoot
+    });
+    return {
+        artifactTreeSiblingPath,
+        artifactTreeLeafIndex,
+        artifactMetadataHash,
+        functionMetadataHash,
+        privateFunctionsArtifactTreeRoot
+    };
+}
+/**
+ * Verifies that an unconstrained function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * as defined in the protocol specs at contract-deployment/classes:
+ *
+ * ```
+ * // Load contract class from local db
+ * contract_class = db.get_contract_class(contract_class_id)
+ *
+ * // Compute artifact leaf and assert it belongs to the artifact
+ * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))
+ * computed_artifact_unconstrained_function_tree_root = compute_root(artifact_function_leaf, artifact_function_tree_sibling_path, artifact_function_tree_leaf_index)
+ * computed_artifact_hash = sha256(private_functions_artifact_tree_root, computed_artifact_unconstrained_function_tree_root, artifact_metadata_hash)
+ * assert computed_artifact_hash == contract_class.artifact_hash
+ * ```
+ * @param fn - Function to check membership proof for.
+ * @param contractClass - In which contract class the function is expected to be.
+ */ export async function isValidUnconstrainedFunctionMembershipProof(fn, contractClass) {
+    const log = createLogger('circuits:function_membership_proof');
+    const functionArtifactHash = await computeFunctionArtifactHash(fn);
+    const computedArtifactFunctionTreeRootBuffer = await computeRootFromSiblingPath(functionArtifactHash.toBuffer(), fn.artifactTreeSiblingPath.map((fr)=>fr.toBuffer()), fn.artifactTreeLeafIndex, getArtifactMerkleTreeHasher());
+    const computedArtifactFunctionTreeRoot = Fr.fromBuffer(computedArtifactFunctionTreeRootBuffer);
+    const computedArtifactHash = await computeArtifactHash({
+        privateFunctionRoot: fn.privateFunctionsArtifactTreeRoot,
+        unconstrainedFunctionRoot: computedArtifactFunctionTreeRoot,
+        metadataHash: fn.artifactMetadataHash
+    });
+    if (!contractClass.artifactHash.equals(computedArtifactHash)) {
+        log.debug(`Artifact hash mismatch`, {
+            expected: contractClass.artifactHash,
+            computedArtifactHash,
+            computedFunctionArtifactHash: functionArtifactHash,
+            computedArtifactFunctionTreeRoot,
+            privateFunctionsArtifactTreeRoot: fn.privateFunctionsArtifactTreeRoot,
+            metadataHash: fn.artifactMetadataHash,
+            artifactFunctionTreeSiblingPath: fn.artifactTreeSiblingPath.map((fr)=>fr.toString()).join(',')
+        });
+        return false;
+    }
+    return true;
+}

package/dest/epoch-helpers/index.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export type L1RollupConstants = {
+    l1StartBlock: bigint;
+    l1GenesisTime: bigint;
+    slotDuration: number;
+    epochDuration: number;
+    ethereumSlotDuration: number;
+};
+export declare const EmptyL1RollupConstants: L1RollupConstants;
+export declare const L1RollupConstantsSchema: z.ZodObject<{
+    l1StartBlock: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    l1GenesisTime: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slotDuration: z.ZodNumber;
+    epochDuration: z.ZodNumber;
+    ethereumSlotDuration: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    l1StartBlock: bigint;
+    l1GenesisTime: bigint;
+    slotDuration: number;
+    epochDuration: number;
+    ethereumSlotDuration: number;
+}, {
+    l1StartBlock: string | number | bigint;
+    l1GenesisTime: string | number | bigint;
+    slotDuration: number;
+    epochDuration: number;
+    ethereumSlotDuration: number;
+}>;
+/** Returns the slot number for a given timestamp. */
+export declare function getSlotAtTimestamp(ts: bigint, constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>): bigint;
+/** Returns the epoch number for a given timestamp. */
+export declare function getEpochNumberAtTimestamp(ts: bigint, constants: Pick<L1RollupConstants, 'epochDuration' | 'slotDuration' | 'l1GenesisTime'>): bigint;
+/** Returns the epoch number for a given slot. */
+export declare function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>): bigint;
+/** Returns the range of L2 slots (inclusive) for a given epoch number. */
+export declare function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>): bigint[];
+/**
+ * Returns the range of L1 timestamps (inclusive) for a given epoch number.
+ * Note that the endTimestamp is the start timestamp of the last L1 slot for the epoch.
+ */
+export declare function getTimestampRangeForEpoch(epochNumber: bigint, constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>): bigint[];
+//# sourceMappingURL=index.d.ts.map

package/dest/epoch-helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/epoch-helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAMpC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;EAME,CAAC;AAEvC,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,UAElH;AAED,sDAAsD;AACtD,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,GAAG,eAAe,CAAC,UAGvF;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,UAE/F;AAED,0EAA0E;AAC1E,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,YAG5G;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,sBAAsB,CAAC,YAUhH"}

package/dest/epoch-helpers/index.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { schemas } from '../schemas/index.js';
+export const EmptyL1RollupConstants = {
+    l1StartBlock: 0n,
+    l1GenesisTime: 0n,
+    epochDuration: 1,
+    slotDuration: 1,
+    ethereumSlotDuration: 1
+};
+export const L1RollupConstantsSchema = z.object({
+    l1StartBlock: schemas.BigInt,
+    l1GenesisTime: schemas.BigInt,
+    slotDuration: z.number(),
+    epochDuration: z.number(),
+    ethereumSlotDuration: z.number()
+});
+/** Returns the slot number for a given timestamp. */ export function getSlotAtTimestamp(ts, constants) {
+    return ts < constants.l1GenesisTime ? 0n : (ts - constants.l1GenesisTime) / BigInt(constants.slotDuration);
+}
+/** Returns the epoch number for a given timestamp. */ export function getEpochNumberAtTimestamp(ts, constants) {
+    return getEpochAtSlot(getSlotAtTimestamp(ts, constants), constants);
+}
+/** Returns the epoch number for a given slot. */ export function getEpochAtSlot(slot, constants) {
+    return slot / BigInt(constants.epochDuration);
+}
+/** Returns the range of L2 slots (inclusive) for a given epoch number. */ export function getSlotRangeForEpoch(epochNumber, constants) {
+    const startSlot = epochNumber * BigInt(constants.epochDuration);
+    return [
+        startSlot,
+        startSlot + BigInt(constants.epochDuration) - 1n
+    ];
+}
+/**
+ * Returns the range of L1 timestamps (inclusive) for a given epoch number.
+ * Note that the endTimestamp is the start timestamp of the last L1 slot for the epoch.
+ */ export function getTimestampRangeForEpoch(epochNumber, constants) {
+    const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
+    const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
+    return [
+        constants.l1GenesisTime + startSlot * BigInt(constants.slotDuration),
+        constants.l1GenesisTime + endSlot * BigInt(constants.slotDuration) + BigInt((ethereumSlotsPerL2Slot - 1) * constants.ethereumSlotDuration)
+    ];
+}

package/dest/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './proving_error.js';
+export * from './simulation_error.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}

package/dest/errors/index.js

@@ -0,0 +1,2 @@
+export * from './proving_error.js';
+export * from './simulation_error.js';

package/dest/errors/proving_error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An error thrown when generating a proof fails.
+ */
+export declare class ProvingError extends Error {
+    readonly retry: boolean;
+    static readonly NAME = "ProvingError";
+    /**
+     * Creates a new instance
+     * @param message - The error message.
+     * @param cause - The cause of the error.
+     * @param retry - Whether the proof should be retried.
+     */
+    constructor(message: string, cause?: unknown, retry?: boolean);
+}
+//# sourceMappingURL=proving_error.d.ts.map

package/dest/errors/proving_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving_error.d.ts","sourceRoot":"","sources":["../../src/errors/proving_error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;aASyB,KAAK,EAAE,OAAO;IAR5E,gBAAuB,IAAI,kBAAkB;IAE7C;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAkB,KAAK,GAAE,OAAe;CAKrF"}

package/dest/errors/proving_error.js

@@ -0,0 +1,16 @@
+/**
+ * An error thrown when generating a proof fails.
+ */ export class ProvingError extends Error {
+    retry;
+    static NAME = 'ProvingError';
+    /**
+   * Creates a new instance
+   * @param message - The error message.
+   * @param cause - The cause of the error.
+   * @param retry - Whether the proof should be retried.
+   */ constructor(message, cause, retry = false){
+        super(message), this.retry = retry;
+        this.name = ProvingError.NAME;
+        this.cause = cause;
+    }
+}

package/dest/errors/simulation_error.d.ts

@@ -0,0 +1,111 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { OpcodeLocation } from '../abi/abi.js';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { type ZodFor } from '../schemas/index.js';
+/**
+ * Address and selector of a function that failed during simulation.
+ */
+export interface FailingFunction {
+    /**
+     * The address of the contract that failed.
+     */
+    contractAddress: AztecAddress;
+    /**
+     * The name of the contract that failed.
+     */
+    contractName?: string;
+    /**
+     * The selector of the function that failed.
+     */
+    functionSelector?: FunctionSelector;
+    /**
+     * The name of the function that failed.
+     */
+    functionName?: string;
+}
+/**
+ * A pointer to a failing section of the noir source code.
+ */
+export interface SourceCodeLocation {
+    /**
+     * The path to the source file.
+     */
+    filePath: string;
+    /**
+     * The line number of the call.
+     */
+    line: number;
+    /**
+     * The column number of the call.
+     */
+    column: number;
+    /**
+     * The source code of the file.
+     */
+    fileSource: string;
+    /**
+     * The source code text of the failed constraint.
+     */
+    locationText: string;
+}
+/**
+ * A stack of noir source code locations.
+ */
+export type NoirCallStack = SourceCodeLocation[] | OpcodeLocation[];
+/**
+ * Checks if a call stack is unresolved.
+ */
+export declare function isNoirCallStackUnresolved(callStack: NoirCallStack): callStack is OpcodeLocation[];
+/**
+ * An error during the simulation of a function call.
+ */
+export declare class SimulationError extends Error {
+    private originalMessage;
+    private functionErrorStack;
+    revertData: Fr[];
+    private noirErrorStack?;
+    private aztecContext;
+    constructor(originalMessage: string, functionErrorStack: FailingFunction[], revertData?: Fr[], noirErrorStack?: NoirCallStack | undefined, options?: ErrorOptions);
+    getMessage(): string;
+    getOriginalMessage(): string;
+    setOriginalMessage(message: string): void;
+    /**
+     * Enriches the error with the name of a contract that failed.
+     * @param contractAddress - The address of the contract
+     * @param contractName - The corresponding name
+     */
+    enrichWithContractName(contractAddress: AztecAddress, contractName: string): void;
+    /**
+     * Enriches the error with the name of a function that failed.
+     * @param contractAddress - The address of the contract
+     * @param functionSelector - The selector of the function
+     * @param functionName - The corresponding name
+     */
+    enrichWithFunctionName(contractAddress: AztecAddress, functionSelector: FunctionSelector, functionName: string): void;
+    getStack(): string;
+    /**
+     * The aztec function stack that failed during simulation.
+     */
+    getCallStack(): FailingFunction[];
+    /**
+     * Returns the noir call stack inside the first function that failed during simulation.
+     * @returns The noir call stack.
+     */
+    getNoirCallStack(): NoirCallStack;
+    /**
+     * Sets the noir call stack.
+     * @param callStack - The noir call stack.
+     */
+    setNoirCallStack(callStack: NoirCallStack): void;
+    setAztecContext(context: string): void;
+    toJSON(): {
+        originalMessage: string;
+        functionErrorStack: FailingFunction[];
+        noirErrorStack: NoirCallStack | undefined;
+        revertData: `0x${string}`[];
+    };
+    static get schema(): ZodFor<SimulationError>;
+    static random(): Promise<SimulationError>;
+}
+//# sourceMappingURL=simulation_error.d.ts.map

package/dest/errors/simulation_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation_error.d.ts","sourceRoot":"","sources":["../../src/errors/simulation_error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAInD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,eAAe,EAAE,YAAY,CAAC;IAC9B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAUD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,EAAE,GAAG,cAAc,EAAE,CAAC;AAIpE;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,aAAa,GAAG,SAAS,IAAI,cAAc,EAAE,CAEjG;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IAItC,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,kBAAkB;IACnB,UAAU,EAAE,EAAE,EAAE;IACvB,OAAO,CAAC,cAAc,CAAC;IANzB,OAAO,CAAC,YAAY,CAAc;gBAGxB,eAAe,EAAE,MAAM,EACvB,kBAAkB,EAAE,eAAe,EAAE,EACtC,UAAU,GAAE,EAAE,EAAO,EACpB,cAAc,CAAC,2BAAe,EACtC,OAAO,CAAC,EAAE,YAAY;IAuCxB,UAAU;IASV,kBAAkB;IAIlB,kBAAkB,CAAC,OAAO,EAAE,MAAM;IAIlC;;;;OAIG;IACH,sBAAsB,CAAC,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM;IAQ1E;;;;;OAKG;IACH,sBAAsB,CAAC,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM;IAY9G,QAAQ;IAqBR;;OAEG;IACH,YAAY,IAAI,eAAe,EAAE;IAIjC;;;OAGG;IACH,gBAAgB,IAAI,aAAa;IAIjC;;;OAGG;IACH,gBAAgB,CAAC,SAAS,EAAE,aAAa;IAIzC,eAAe,CAAC,OAAO,EAAE,MAAM;IAI/B,MAAM;;;;;;IASN,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,CAmB3C;WAEY,MAAM;CAKpB"}

package/dest/errors/simulation_error.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/index.js';
+const SourceCodeLocationSchema = z.object({
+    filePath: z.string(),
+    line: z.number(),
+    column: z.number(),
+    fileSource: z.string(),
+    locationText: z.string()
+});
+const NoirCallStackSchema = z.union([
+    z.array(SourceCodeLocationSchema),
+    z.array(z.string())
+]);
+/**
+ * Checks if a call stack is unresolved.
+ */ export function isNoirCallStackUnresolved(callStack) {
+    return typeof callStack[0] === 'string';
+}
+/**
+ * An error during the simulation of a function call.
+ */ export class SimulationError extends Error {
+    originalMessage;
+    functionErrorStack;
+    revertData;
+    noirErrorStack;
+    aztecContext;
+    constructor(originalMessage, functionErrorStack, revertData = [], noirErrorStack, options){
+        super(originalMessage, options), this.originalMessage = originalMessage, this.functionErrorStack = functionErrorStack, this.revertData = revertData, this.noirErrorStack = noirErrorStack, this.aztecContext = '';
+        const getMessage = ()=>this.getMessage();
+        const getStack = ()=>this.getStack();
+        Object.defineProperties(this, {
+            message: {
+                configurable: false,
+                enumerable: true,
+                /**
+         * Getter for the custom error message. It has to be defined here because JS errors have the message property defined
+         * in the error itself, not its prototype. Thus if we define it as a class getter will be shadowed.
+         * @returns The message.
+         */ get () {
+                    return getMessage();
+                }
+            },
+            stack: {
+                configurable: false,
+                enumerable: true,
+                /**
+         * Getter for the custom error stack. It has to be defined here due to the same issue as the message.
+         * @returns The stack.
+         */ get () {
+                    return getStack();
+                },
+                /**
+         * We need a setter to avoid the error "TypeError: Cannot set property stack of #<SimulationError> which has only a getter"
+         * whenever we are traversing a nested error chain. However, we don't want to allow setting the stack, since the simulation
+         * error is always gonna be the root of the error chain.
+         * @param value
+         */ set (_) {}
+            }
+        });
+    }
+    getMessage() {
+        if (this.noirErrorStack && !isNoirCallStackUnresolved(this.noirErrorStack) && this.noirErrorStack.length) {
+            return `${this.originalMessage} '${this.noirErrorStack[this.noirErrorStack.length - 1].locationText}'${this.aztecContext}`;
+        }
+        return this.originalMessage;
+    }
+    getOriginalMessage() {
+        return this.originalMessage;
+    }
+    setOriginalMessage(message) {
+        this.originalMessage = message;
+    }
+    /**
+   * Enriches the error with the name of a contract that failed.
+   * @param contractAddress - The address of the contract
+   * @param contractName - The corresponding name
+   */ enrichWithContractName(contractAddress, contractName) {
+        this.functionErrorStack.forEach((failingFunction)=>{
+            if (failingFunction.contractAddress.equals(contractAddress)) {
+                failingFunction.contractName = contractName;
+            }
+        });
+    }
+    /**
+   * Enriches the error with the name of a function that failed.
+   * @param contractAddress - The address of the contract
+   * @param functionSelector - The selector of the function
+   * @param functionName - The corresponding name
+   */ enrichWithFunctionName(contractAddress, functionSelector, functionName) {
+        this.functionErrorStack.forEach((failingFunction)=>{
+            if (failingFunction.contractAddress.equals(contractAddress) && !!failingFunction.functionSelector && failingFunction.functionSelector.equals(functionSelector)) {
+                failingFunction.functionName = functionName;
+            }
+        });
+    }
+    getStack() {
+        const functionCallStack = this.getCallStack();
+        const noirCallStack = this.getNoirCallStack();
+        // Try to resolve the contract and function names of the stack of failing functions.
+        const stackLines = [
+            ...functionCallStack.map((failingFunction)=>{
+                return `at ${failingFunction.contractName ?? failingFunction.contractAddress.toString()}.${failingFunction.functionName ?? failingFunction.functionSelector?.toString() ?? 'unknown'}`;
+            }),
+            ...noirCallStack.map((errorLocation)=>typeof errorLocation === 'string' ? `at opcode ${errorLocation}` : `at ${errorLocation.locationText} (${errorLocation.filePath}:${errorLocation.line}:${errorLocation.column})`)
+        ];
+        return [
+            `Simulation error: ${this.message}`,
+            ...stackLines.reverse()
+        ].join('\n');
+    }
+    /**
+   * The aztec function stack that failed during simulation.
+   */ getCallStack() {
+        return this.functionErrorStack;
+    }
+    /**
+   * Returns the noir call stack inside the first function that failed during simulation.
+   * @returns The noir call stack.
+   */ getNoirCallStack() {
+        return this.noirErrorStack || [];
+    }
+    /**
+   * Sets the noir call stack.
+   * @param callStack - The noir call stack.
+   */ setNoirCallStack(callStack) {
+        this.noirErrorStack = callStack;
+    }
+    setAztecContext(context) {
+        this.aztecContext = context;
+    }
+    toJSON() {
+        return {
+            originalMessage: this.originalMessage,
+            functionErrorStack: this.functionErrorStack,
+            noirErrorStack: this.noirErrorStack,
+            revertData: this.revertData.map((fr)=>fr.toString())
+        };
+    }
+    static get schema() {
+        return z.object({
+            originalMessage: z.string(),
+            functionErrorStack: z.array(z.object({
+                contractAddress: schemas.AztecAddress,
+                contractName: z.string().optional(),
+                functionSelector: schemas.FunctionSelector,
+                functionName: z.string().optional()
+            })),
+            noirErrorStack: NoirCallStackSchema.optional(),
+            revertData: z.array(schemas.Fr)
+        }).transform(({ originalMessage, functionErrorStack, noirErrorStack, revertData })=>new SimulationError(originalMessage, functionErrorStack, revertData, noirErrorStack));
+    }
+    static async random() {
+        return new SimulationError('Random simulation error', [
+            {
+                contractAddress: await AztecAddress.random(),
+                functionSelector: FunctionSelector.random()
+            }
+        ]);
+    }
+}

package/dest/event/event.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { BufferReader } from '@aztec/foundation/serialize';
+import { Payload } from '../logs/l1_payload/payload.js';
+export declare class Event extends Payload {
+    static get schema(): import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Buffer, string>, import("zod").ZodEffects<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"Buffer">;
+        data: import("zod").ZodArray<import("zod").ZodNumber, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "Buffer";
+        data: number[];
+    }, {
+        type: "Buffer";
+        data: number[];
+    }>, Buffer, {
+        type: "Buffer";
+        data: number[];
+    }>]>, Event, string | {
+        type: "Buffer";
+        data: number[];
+    }>;
+    static fromBuffer(buffer: Buffer | BufferReader): Event;
+}
+//# sourceMappingURL=event.d.ts.map

package/dest/event/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/event/event.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAGxD,qBAAa,KAAM,SAAQ,OAAO;IAChC,WAAoB,MAAM;;;;;;;;;;;;;;;OAEzB;WAEe,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;CAIzD"}

package/dest/event/event.js

@@ -0,0 +1,13 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { Payload } from '../logs/l1_payload/payload.js';
+import { schemas } from '../schemas/schemas.js';
+export class Event extends Payload {
+    static get schema() {
+        return schemas.Buffer.transform(Event.fromBuffer);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new Event(reader.readVector(Fr));
+    }
+}

package/dest/event/event_metadata.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { type AbiType } from '../abi/abi.js';
+import type { EventSelector } from '../abi/event_selector.js';
+import type { PublicLog } from '../logs/public_log.js';
+import { L1EventPayload } from './l1_event_payload.js';
+/**
+ * Represents metadata for an event decoder, including all information needed to reconstruct it.
+ */
+export declare class EventMetadata<T> {
+    readonly decode: (payload: L1EventPayload | PublicLog) => T | undefined;
+    readonly eventSelector: EventSelector;
+    readonly abiType: AbiType;
+    readonly fieldNames: string[];
+    constructor(event: {
+        eventSelector: EventSelector;
+        abiType: AbiType;
+        fieldNames: string[];
+    });
+    static decodeEvent<T>(eventSelector: EventSelector, abiType: AbiType): (payload: L1EventPayload | PublicLog | undefined) => T | undefined;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        eventSelector: z.ZodType<EventSelector, any, string>;
+        abiType: z.ZodType<AbiType, z.ZodTypeDef, AbiType>;
+        fieldNames: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        eventSelector: EventSelector;
+        abiType: AbiType;
+        fieldNames: string[];
+    }, {
+        eventSelector: string;
+        abiType: AbiType;
+        fieldNames: string[];
+    }>, EventMetadata<unknown>, {
+        eventSelector: string;
+        abiType: AbiType;
+        fieldNames: string[];
+    }>;
+}
+//# sourceMappingURL=event_metadata.d.ts.map

package/dest/event/event_metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_metadata.d.ts","sourceRoot":"","sources":["../../src/event/event_metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,eAAe,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;GAEG;AACH,qBAAa,aAAa,CAAC,CAAC;IAC1B,SAAgB,MAAM,EAAE,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS,CAAC;IAE/E,SAAgB,aAAa,EAAE,aAAa,CAAC;IAC7C,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,UAAU,EAAE,MAAM,EAAE,CAAC;gBAEzB,KAAK,EAAE;QAAE,aAAa,EAAE,aAAa,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE;WAO7E,WAAW,CAAC,CAAC,EACzB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,OAAO,GACf,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS;IAiBrE,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAQhB;CACF"}

package/dest/event/event_metadata.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { AbiTypeSchema } from '../abi/abi.js';
+import { decodeFromAbi } from '../abi/decoder.js';
+import { schemas } from '../schemas/index.js';
+import { L1EventPayload } from './l1_event_payload.js';
+/**
+ * Represents metadata for an event decoder, including all information needed to reconstruct it.
+ */ export class EventMetadata {
+    decode;
+    eventSelector;
+    abiType;
+    fieldNames;
+    constructor(event){
+        this.eventSelector = event.eventSelector;
+        this.abiType = event.abiType;
+        this.fieldNames = event.fieldNames;
+        this.decode = EventMetadata.decodeEvent(event.eventSelector, event.abiType);
+    }
+    static decodeEvent(eventSelector, abiType) {
+        return (payload)=>{
+            if (payload === undefined) {
+                return undefined;
+            }
+            if (payload instanceof L1EventPayload) {
+                if (!eventSelector.equals(payload.eventTypeId)) {
+                    return undefined;
+                }
+                return decodeFromAbi([
+                    abiType
+                ], payload.event.items);
+            } else {
+                return decodeFromAbi([
+                    abiType
+                ], payload.log);
+            }
+        };
+    }
+    static get schema() {
+        return z.object({
+            eventSelector: schemas.EventSelector,
+            abiType: AbiTypeSchema,
+            fieldNames: z.array(z.string())
+        }).transform((obj)=>new EventMetadata(obj));
+    }
+}

package/dest/event/index.d.ts

@@ -0,0 +1,4 @@
+export * from './event.js';
+export * from './event_metadata.js';
+export * from './l1_event_payload.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/event/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/event/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

package/dest/event/index.js

@@ -0,0 +1,3 @@
+export * from './event.js';
+export * from './event_metadata.js';
+export * from './l1_event_payload.js';