@aztec/stdlib 0.0.0-test.0

package/dest/contract/unconstrained_function_membership_proof.d.ts

@@ -0,0 +1,27 @@
+import { type ContractArtifact, FunctionSelector } from '../abi/index.js';
+import type { ContractClassPublic, UnconstrainedFunctionMembershipProof, UnconstrainedFunctionWithMembershipProof } from './interfaces/index.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 declare function createUnconstrainedFunctionMembershipProof(selector: FunctionSelector, artifact: ContractArtifact): Promise<UnconstrainedFunctionMembershipProof>;
+/**
+ * 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 declare function isValidUnconstrainedFunctionMembershipProof(fn: UnconstrainedFunctionWithMembershipProof, contractClass: Pick<ContractClassPublic, 'artifactHash'>): Promise<boolean>;
+//# sourceMappingURL=unconstrained_function_membership_proof.d.ts.map

package/dest/contract/unconstrained_function_membership_proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unconstrained_function_membership_proof.d.ts","sourceRoot":"","sources":["../../src/contract/unconstrained_function_membership_proof.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;AASxF,OAAO,KAAK,EACV,mBAAmB,EACnB,oCAAoC,EACpC,wCAAwC,EACzC,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,wBAAsB,0CAA0C,CAC9D,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,oCAAoC,CAAC,CAsC/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,2CAA2C,CAC/D,EAAE,EAAE,wCAAwC,EAC5C,aAAa,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,oBA+BzD"}

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/database-version/index.d.ts

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

package/dest/database-version/index.d.ts.map

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

package/dest/database-version/index.js

@@ -0,0 +1 @@
+export * from './version_manager.js';

package/dest/database-version/version_manager.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { EthAddress } from '@aztec/foundation/eth-address';
+import fs from 'fs/promises';
+import { z } from 'zod';
+/**
+ * Represents a version record for storing in a version file.
+ */
+export declare class DatabaseVersion {
+    readonly schemaVersion: number;
+    readonly rollupAddress: EthAddress;
+    constructor(schemaVersion: number, rollupAddress: EthAddress);
+    toBuffer(): Buffer;
+    static fromBuffer(buf: Buffer): DatabaseVersion;
+    /**
+     * Compares two versions. If the rollups addresses are different then it returns undefined
+     */
+    cmp(other: DatabaseVersion): undefined | -1 | 0 | 1;
+    /**
+     * Checks if two versions exactly match
+     */
+    equals(other: DatabaseVersion): boolean;
+    /**
+     * Returns the schema for this class
+     */
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        schemaVersion: z.ZodNumber;
+        rollupAddress: z.ZodType<EthAddress, any, string>;
+    }, "strip", z.ZodTypeAny, {
+        rollupAddress: EthAddress;
+        schemaVersion: number;
+    }, {
+        rollupAddress: string;
+        schemaVersion: number;
+    }>, DatabaseVersion, {
+        rollupAddress: string;
+        schemaVersion: number;
+    }>;
+    /**
+     * Returns an empty instance
+     */
+    static empty(): DatabaseVersion;
+}
+export type DatabaseVersionManagerFs = Pick<typeof fs, 'readFile' | 'writeFile' | 'rm' | 'mkdir'>;
+/**
+ * A manager for handling database versioning and migrations.
+ * This class will check the version of data in a directory and either
+ * reset or upgrade based on version compatibility.
+ */
+export declare class DatabaseVersionManager<T> {
+    private dataDirectory;
+    private onOpen;
+    private onUpgrade?;
+    private fileSystem;
+    private log;
+    static readonly VERSION_FILE = "db_version";
+    private readonly versionFile;
+    private readonly currentVersion;
+    /**
+     * Create a new version manager
+     *
+     * @param schemaVersion - The current version of the application
+     * @param rollupAddress - The rollup contract address
+     * @param dataDirectory - The directory where version information will be stored
+     * @param onOpen - A callback to the open the database at the given location
+     * @param onUpgrade - An optional callback to upgrade the database before opening. If not provided it will reset the database
+     * @param fileSystem - An interface to access the filesystem
+     * @param log - Optional custom logger
+     * @param options - Configuration options
+     */
+    constructor(schemaVersion: number, rollupAddress: EthAddress, dataDirectory: string, onOpen: (dataDir: string) => Promise<T>, onUpgrade?: ((dataDir: string, currentVersion: number, latestVersion: number) => Promise<void>) | undefined, fileSystem?: DatabaseVersionManagerFs, log?: import("@aztec/foundation/log").Logger);
+    /**
+     * Checks the stored version against the current version and handles the outcome
+     * by either resetting the data directory or calling an upgrade function
+     *
+     * @param onReset - Function to call when a full reset is needed
+     * @param onUpgrade - Function to call when an upgrade is needed
+     * @returns True if data was reset, false if upgraded or no change needed
+     */
+    open(): Promise<[T, boolean]>;
+    /**
+     * Writes the current version to the version file
+     */
+    private writeVersion;
+    /**
+     * Resets the data directory by deleting it and recreating it
+     */
+    private resetDataDirectory;
+    /**
+     * Get the data directory path
+     */
+    getDataDirectory(): string;
+    /**
+     * Get the current version number
+     */
+    getSchemaVersion(): number;
+}
+//# sourceMappingURL=version_manager.d.ts.map

package/dest/database-version/version_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version_manager.d.ts","sourceRoot":"","sources":["../../src/database-version/version_manager.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAI3D,OAAO,EAAE,MAAM,aAAa,CAAC;AAE7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,qBAAa,eAAe;aACE,aAAa,EAAE,MAAM;aAAkB,aAAa,EAAE,UAAU;gBAAhE,aAAa,EAAE,MAAM,EAAkB,aAAa,EAAE,UAAU;IAErF,QAAQ,IAAI,MAAM;WAIX,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;IAQtD;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAa1D;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAI9C;;OAEG;IACH,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED;;OAEG;IACH,MAAM,CAAC,KAAK;CAGb;AAED,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC;AAElG;;;;GAIG;AACH,qBAAa,sBAAsB,CAAC,CAAC;IAqBjC,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS,CAAC;IAClB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,GAAG;IAxBb,gBAAuB,YAAY,gBAAgB;IAEnD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkB;IAEjD;;;;;;;;;;;OAWG;gBAED,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,UAAU,EACjB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACvC,SAAS,CAAC,aAAY,MAAM,kBAAkB,MAAM,iBAAiB,MAAM,KAAK,QAAQ,IAAI,CAAC,aAAA,EAC7F,UAAU,GAAE,wBAA6B,EACzC,GAAG,yCAA6C;IAU1D;;;;;;;OAOG;IACU,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAmD1C;;OAEG;YACW,YAAY;IAO1B;;OAEG;YACW,kBAAkB;IAUhC;;OAEG;IACI,gBAAgB,IAAI,MAAM;IAIjC;;OAEG;IACI,gBAAgB,IAAI,MAAM;CAGlC"}

package/dest/database-version/version_manager.js

@@ -0,0 +1,188 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { jsonParseWithSchemaSync, jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import fs from 'fs/promises';
+import { join } from 'path';
+import { z } from 'zod';
+/**
+ * Represents a version record for storing in a version file.
+ */ export class DatabaseVersion {
+    schemaVersion;
+    rollupAddress;
+    constructor(schemaVersion, rollupAddress){
+        this.schemaVersion = schemaVersion;
+        this.rollupAddress = rollupAddress;
+    }
+    toBuffer() {
+        return Buffer.from(jsonStringify(this));
+    }
+    static fromBuffer(buf) {
+        try {
+            return jsonParseWithSchemaSync(buf.toString('utf-8'), DatabaseVersion.schema);
+        } catch (err) {
+            throw new Error(`Failed to deserialize version information: ${err}`, {
+                cause: err
+            });
+        }
+    }
+    /**
+   * Compares two versions. If the rollups addresses are different then it returns undefined
+   */ cmp(other) {
+        if (this.rollupAddress.equals(other.rollupAddress)) {
+            if (this.schemaVersion < other.schemaVersion) {
+                return -1;
+            } else if (this.schemaVersion > other.schemaVersion) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+        return undefined;
+    }
+    /**
+   * Checks if two versions exactly match
+   */ equals(other) {
+        return this.cmp(other) === 0;
+    }
+    /**
+   * Returns the schema for this class
+   */ static get schema() {
+        return z.object({
+            schemaVersion: z.number(),
+            rollupAddress: EthAddress.schema
+        }).transform(({ schemaVersion, rollupAddress })=>new DatabaseVersion(schemaVersion, rollupAddress));
+    }
+    /**
+   * Returns an empty instance
+   */ static empty() {
+        return new DatabaseVersion(0, EthAddress.ZERO);
+    }
+}
+/**
+ * A manager for handling database versioning and migrations.
+ * This class will check the version of data in a directory and either
+ * reset or upgrade based on version compatibility.
+ */ export class DatabaseVersionManager {
+    dataDirectory;
+    onOpen;
+    onUpgrade;
+    fileSystem;
+    log;
+    static VERSION_FILE = 'db_version';
+    versionFile;
+    currentVersion;
+    /**
+   * Create a new version manager
+   *
+   * @param schemaVersion - The current version of the application
+   * @param rollupAddress - The rollup contract address
+   * @param dataDirectory - The directory where version information will be stored
+   * @param onOpen - A callback to the open the database at the given location
+   * @param onUpgrade - An optional callback to upgrade the database before opening. If not provided it will reset the database
+   * @param fileSystem - An interface to access the filesystem
+   * @param log - Optional custom logger
+   * @param options - Configuration options
+   */ constructor(schemaVersion, rollupAddress, dataDirectory, onOpen, onUpgrade, fileSystem = fs, log = createLogger(`foundation:version-manager`)){
+        this.dataDirectory = dataDirectory;
+        this.onOpen = onOpen;
+        this.onUpgrade = onUpgrade;
+        this.fileSystem = fileSystem;
+        this.log = log;
+        if (schemaVersion < 1) {
+            throw new TypeError(`Invalid schema version received: ${schemaVersion}`);
+        }
+        this.versionFile = join(this.dataDirectory, DatabaseVersionManager.VERSION_FILE);
+        this.currentVersion = new DatabaseVersion(schemaVersion, rollupAddress);
+    }
+    /**
+   * Checks the stored version against the current version and handles the outcome
+   * by either resetting the data directory or calling an upgrade function
+   *
+   * @param onReset - Function to call when a full reset is needed
+   * @param onUpgrade - Function to call when an upgrade is needed
+   * @returns True if data was reset, false if upgraded or no change needed
+   */ async open() {
+        // const storedVersion = await DatabaseVersion.readVersion(this.versionFile);
+        let storedVersion;
+        try {
+            const versionBuf = await this.fileSystem.readFile(this.versionFile);
+            storedVersion = DatabaseVersion.fromBuffer(versionBuf);
+        } catch (err) {
+            if (err && err.code === 'ENOENT') {
+                storedVersion = DatabaseVersion.empty();
+            } else {
+                this.log.warn(`Failed to read stored version information: ${err}. Defaulting to empty version`);
+                storedVersion = DatabaseVersion.empty();
+            }
+        }
+        const cmp = storedVersion.cmp(this.currentVersion);
+        let needsReset = false;
+        if (typeof cmp === 'number') {
+            // only allow forward upgrades
+            if (cmp === -1 && this.onUpgrade) {
+                this.log.info(`Upgrading from version ${storedVersion.schemaVersion} to ${this.currentVersion.schemaVersion}`);
+                try {
+                    await this.onUpgrade(this.dataDirectory, storedVersion.schemaVersion, this.currentVersion.schemaVersion);
+                } catch (error) {
+                    this.log.error(`Failed to upgrade: ${error}. Falling back to reset.`);
+                    needsReset = true;
+                }
+            } else if (cmp !== 0) {
+                this.log.info(`Can't upgrade from version ${storedVersion.schemaVersion} to ${this.currentVersion}. Resetting database at ${this.dataDirectory}`);
+                needsReset = true;
+            }
+        } else {
+            this.log.warn('Rollup address changed, resetting data directory');
+            needsReset = true;
+        }
+        // Handle reset if needed
+        if (needsReset) {
+            await this.resetDataDirectory();
+        }
+        // Write the current version to disk
+        await this.writeVersion();
+        return [
+            await this.onOpen(this.dataDirectory),
+            needsReset
+        ];
+    }
+    /**
+   * Writes the current version to the version file
+   */ async writeVersion() {
+        // Ensure the directory exists
+        await this.fileSystem.mkdir(this.dataDirectory, {
+            recursive: true
+        });
+        // Write the version file
+        await this.fileSystem.writeFile(this.versionFile, this.currentVersion.toBuffer());
+    }
+    /**
+   * Resets the data directory by deleting it and recreating it
+   */ async resetDataDirectory() {
+        try {
+            await this.fileSystem.rm(this.dataDirectory, {
+                recursive: true,
+                force: true,
+                maxRetries: 3
+            });
+            await this.fileSystem.mkdir(this.dataDirectory, {
+                recursive: true
+            });
+        } catch (err) {
+            this.log.error(`Failed to reset data directory: ${err}`);
+            throw new Error(`Failed to reset data directory: ${err}`, {
+                cause: err
+            });
+        }
+    }
+    /**
+   * Get the data directory path
+   */ getDataDirectory() {
+        return this.dataDirectory;
+    }
+    /**
+   * Get the current version number
+   */ getSchemaVersion() {
+        return this.currentVersion.schemaVersion;
+    }
+}

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;
+    }
+}