@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/versioning/versioning.js

@@ -0,0 +1,100 @@
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+/** Returns components versions from chain config. */ export function getComponentsVersionsFromConfig(config, l2ProtocolContractsHash, l2CircuitsVkTreeRoot) {
+    return {
+        l1ChainId: config.l1ChainId,
+        l1RollupAddress: config.rollupAddress,
+        rollupVersion: config.rollupVersion,
+        l2ProtocolContractsHash: l2ProtocolContractsHash.toString(),
+        l2CircuitsVkTreeRoot: l2CircuitsVkTreeRoot.toString()
+    };
+}
+/** Returns a compressed string representation of the version (around 32 chars). Used in p2p ENRs. */ export function compressComponentVersions(versions) {
+    if (versions.l1RollupAddress === undefined || versions.l2ProtocolContractsHash === undefined || versions.l2CircuitsVkTreeRoot === undefined) {
+        throw new Error(`Component versions are not set: ${jsonStringify(versions)}`);
+    }
+    return [
+        '00',
+        versions.l1ChainId,
+        versions.l1RollupAddress.toString().slice(2, 10),
+        versions.rollupVersion,
+        versions.l2ProtocolContractsHash.toString().slice(2, 10),
+        versions.l2CircuitsVkTreeRoot.toString().slice(2, 10)
+    ].join('-');
+}
+export class ComponentsVersionsError extends Error {
+    constructor(key, expected, value){
+        super(`Expected component version ${key} to be ${expected} but received ${value}`);
+        this.name = 'ComponentsVersionsError';
+    }
+}
+/** Checks if the compressed string matches against the expected versions. Throws on mismatch. */ export function checkCompressedComponentVersion(compressed, expected) {
+    const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsHash, l2CircuitsVkTreeRoot] = compressed.split('-');
+    if (versionVersion !== '00') {
+        throw new ComponentsVersionsError('version', '00', versionVersion);
+    }
+    if (l1ChainId !== expected.l1ChainId.toString()) {
+        throw new ComponentsVersionsError(`L1 chain ID`, expected.l1ChainId.toString(), l1ChainId);
+    }
+    if (l1RollupAddress !== expected.l1RollupAddress.toString().slice(2, 10)) {
+        throw new ComponentsVersionsError(`L1 address`, expected.l1RollupAddress.toString(), l1RollupAddress);
+    }
+    if (rollupVersion !== expected.rollupVersion.toString()) {
+        throw new ComponentsVersionsError('L2 chain version', expected.rollupVersion.toString(), rollupVersion);
+    }
+    if (l2ProtocolContractsHash !== expected.l2ProtocolContractsHash.toString().slice(2, 10)) {
+        throw new ComponentsVersionsError(`L2 protocol contracts vk tree root`, expected.l2ProtocolContractsHash.toString(), l2ProtocolContractsHash);
+    }
+    if (l2CircuitsVkTreeRoot !== expected.l2CircuitsVkTreeRoot.toString().slice(2, 10)) {
+        throw new ComponentsVersionsError('L2 circuits vk tree root', expected.l2CircuitsVkTreeRoot.toString(), l2CircuitsVkTreeRoot);
+    }
+}
+/** Checks that two component versions match. Undefined fields are ignored. */ export function validatePartialComponentVersionsMatch(expected, actual) {
+    for (const key of [
+        'l1RollupAddress',
+        'l2ProtocolContractsHash',
+        'l2CircuitsVkTreeRoot',
+        'l1ChainId',
+        'rollupVersion'
+    ]){
+        const actualValue = actual[key];
+        const expectedValue = expected[key];
+        if (expectedValue !== undefined && actualValue !== undefined) {
+            if (typeof actualValue === 'object' ? !actualValue.equals(expectedValue) : actualValue !== expectedValue) {
+                throw new Error(`Expected ${key} to be ${expectedValue} but received ${actualValue}`);
+            }
+        }
+    }
+}
+/** Returns a Koa middleware that injects the versioning info as headers. */ export function getVersioningMiddleware(versions, opts) {
+    return async (ctx, next)=>{
+        try {
+            await next();
+        } finally{
+            // Always add version headers, even if there was an error
+            // This allows the client to detect version mismatches before processing other errors
+            for(const key in versions){
+                const value = versions[key];
+                if (value !== undefined) {
+                    ctx.set(`x-aztec-${key}`, value.toString());
+                }
+            }
+            if (opts?.packageVersion) {
+                ctx.set('x-aztec-packageVersion', opts.packageVersion);
+            }
+        }
+    };
+}
+/** Returns a json rpc client handler that rejects responses with mismatching versions. */ export function getVersioningResponseHandler(versions) {
+    return ({ headers })=>{
+        for(const key in versions){
+            const value = versions[key];
+            if (value !== undefined) {
+                const headerValue = headers.get(`x-aztec-${key}`);
+                if (headerValue !== undefined && headerValue !== null && headerValue !== value.toString()) {
+                    throw new ComponentsVersionsError(key, value.toString(), headerValue);
+                }
+            }
+        }
+        return Promise.resolve();
+    };
+}

package/dest/vks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './verification_key.js';
+export * from './vk_data.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92a3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQyJ9

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

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

package/dest/vks/index.js

@@ -0,0 +1,2 @@
+export * from './verification_key.js';
+export * from './vk_data.js';

package/dest/vks/verification_key.d.ts

@@ -0,0 +1,67 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+export declare const CIRCUIT_SIZE_INDEX = 0;
+export declare const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
+/**
+ * Provides a 'fields' representation of a circuit's verification key
+ */
+export declare class VerificationKeyAsFields {
+    key: Fr[];
+    hash: Fr;
+    constructor(key: Fr[], hash: Fr);
+    static fromKey(key: Fr[]): Promise<VerificationKeyAsFields>;
+    get numPublicInputs(): number;
+    get circuitSize(): number;
+    static get schema(): import("zod").ZodType<VerificationKeyAsFields, string, import("zod/v4/core").$ZodTypeInternals<VerificationKeyAsFields, string>>;
+    toJSON(): Buffer<ArrayBufferLike>;
+    /**
+     * Serialize as a buffer.
+     * @returns The buffer.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    toFields(): (number | Fr)[];
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer to read from.
+     * @returns The VerificationKeyAsFields.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): VerificationKeyAsFields;
+    static fromFrBuffer(vkBytes: Buffer): Promise<VerificationKeyAsFields>;
+    /**
+     * Builds a fake verification key that should be accepted by circuits.
+     * @returns A fake verification key.
+     */
+    static makeFake(size: number, seed?: number): VerificationKeyAsFields;
+    static makeFakeHonk(seed?: number): VerificationKeyAsFields;
+    static makeFakeRollupHonk(seed?: number): VerificationKeyAsFields;
+    /**
+     * Builds an 'empty' verification key
+     * @returns An 'empty' verification key
+     */
+    static makeEmpty(size: number): VerificationKeyAsFields;
+}
+export declare class VerificationKeyData {
+    readonly keyAsFields: VerificationKeyAsFields;
+    readonly keyAsBytes: Buffer;
+    constructor(keyAsFields: VerificationKeyAsFields, keyAsBytes: Buffer);
+    get numPublicInputs(): number;
+    get circuitSize(): number;
+    static empty(): VerificationKeyData;
+    static makeFakeHonk(): VerificationKeyData;
+    static makeFakeRollupHonk(): VerificationKeyData;
+    /**
+     * Serialize as a buffer.
+     * @returns The buffer.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    toString(): `0x${string}`;
+    static fromBuffer(buffer: Buffer | BufferReader): VerificationKeyData;
+    static fromFrBuffer(vkBytes: Buffer): Promise<VerificationKeyData>;
+    static fromString(str: string): VerificationKeyData;
+    clone(): VerificationKeyData;
+    /** Returns a hex representation for JSON serialization. */
+    toJSON(): Buffer<ArrayBufferLike>;
+    /** Creates an instance from a hex string. */
+    static get schema(): import("zod").ZodType<VerificationKeyData, string, import("zod/v4/core").$ZodTypeInternals<VerificationKeyData, string>>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/vks/verification_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification_key.d.ts","sourceRoot":"","sources":["../../src/vks/verification_key.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAMnF,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C;;GAEG;AACH,qBAAa,uBAAuB;IAEzB,GAAG,EAAE,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IAFjB,YACS,GAAG,EAAE,EAAE,EAAE,EACT,IAAI,EAAE,EAAE,EACb;IAEJ,OAAa,OAAO,CAAC,GAAG,EAAE,EAAE,EAAE,oCAG7B;IAED,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,KAAK,MAAM,qIAGhB;IAED,MAAM,4BAEL;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED,QAAQ,oBAEP;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,uBAAuB,CAGxE;IAED,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAKrE;IAED;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,uBAAuB,CAE/D;IAED,MAAM,CAAC,YAAY,CAAC,IAAI,SAAI,GAAG,uBAAuB,CAErD;IAED,MAAM,CAAC,kBAAkB,CAAC,IAAI,SAAI,GAAG,uBAAuB,CAK3D;IAED;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB,CAEtD;CACF;AAED,qBAAa,mBAAmB;aAEZ,WAAW,EAAE,uBAAuB;aACpC,UAAU,EAAE,MAAM;IAFpC,YACkB,WAAW,EAAE,uBAAuB,EACpC,UAAU,EAAE,MAAM,EAChC;IAEJ,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,CAAC,KAAK,wBAEX;IAED,MAAM,CAAC,YAAY,IAAI,mBAAmB,CAGzC;IAED,MAAM,CAAC,kBAAkB,IAAI,mBAAmB,CAG/C;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED,QAAQ,kBAEP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAMpE;IAED,OAAa,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAEvE;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAElD;IAEM,KAAK,wBAEX;IAED,2DAA2D;IAC3D,MAAM,4BAEL;IAED,6CAA6C;IAC7C,MAAM,KAAK,MAAM,6HAEhB;CACF"}

package/dest/vks/verification_key.js

@@ -0,0 +1,138 @@
+import { ULTRA_VK_LENGTH_IN_FIELDS } from '@aztec-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { hashVK } from '../hash/index.js';
+// TODO: find better home for these constants
+export const CIRCUIT_SIZE_INDEX = 0;
+export const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
+/**
+ * Provides a 'fields' representation of a circuit's verification key
+ */ export class VerificationKeyAsFields {
+    key;
+    hash;
+    constructor(key, hash){
+        this.key = key;
+        this.hash = hash;
+    }
+    static async fromKey(key) {
+        const hash = await hashVK(key);
+        return new VerificationKeyAsFields(key, hash);
+    }
+    get numPublicInputs() {
+        return Number(this.key[CIRCUIT_PUBLIC_INPUTS_INDEX]);
+    }
+    get circuitSize() {
+        return Number(this.key[CIRCUIT_SIZE_INDEX]);
+    }
+    static get schema() {
+        // TODO(palla/schemas): Should we verify the hash matches the key when deserializing?
+        return bufferSchemaFor(VerificationKeyAsFields);
+    }
+    toJSON() {
+        return this.toBuffer();
+    }
+    /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */ toBuffer() {
+        return serializeToBuffer(...this.toFields());
+    }
+    toFields() {
+        return [
+            this.key.length,
+            ...this.key,
+            this.hash
+        ];
+    }
+    /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer to read from.
+   * @returns The VerificationKeyAsFields.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new VerificationKeyAsFields(reader.readVector(Fr), reader.readObject(Fr));
+    }
+    static fromFrBuffer(vkBytes) {
+        const numFields = vkBytes.length / Fr.SIZE_IN_BYTES;
+        const reader = BufferReader.asReader(vkBytes);
+        const fields = reader.readArray(numFields, Fr);
+        return VerificationKeyAsFields.fromKey(fields);
+    }
+    /**
+   * Builds a fake verification key that should be accepted by circuits.
+   * @returns A fake verification key.
+   */ static makeFake(size, seed = 1) {
+        return new VerificationKeyAsFields(makeTuple(size, Fr.random, seed), Fr.random());
+    }
+    static makeFakeHonk(seed = 1) {
+        return new VerificationKeyAsFields(makeTuple(ULTRA_VK_LENGTH_IN_FIELDS, Fr.random, seed), Fr.random());
+    }
+    static makeFakeRollupHonk(seed = 1) {
+        return new VerificationKeyAsFields(makeTuple(ULTRA_VK_LENGTH_IN_FIELDS, (i)=>new Fr(i), seed), new Fr(seed + 1));
+    }
+    /**
+   * Builds an 'empty' verification key
+   * @returns An 'empty' verification key
+   */ static makeEmpty(size) {
+        return new VerificationKeyAsFields(makeTuple(size, Fr.zero), Fr.zero());
+    }
+}
+export class VerificationKeyData {
+    keyAsFields;
+    keyAsBytes;
+    constructor(keyAsFields, keyAsBytes){
+        this.keyAsFields = keyAsFields;
+        this.keyAsBytes = keyAsBytes;
+    }
+    get numPublicInputs() {
+        return this.keyAsFields.numPublicInputs;
+    }
+    get circuitSize() {
+        return this.keyAsFields.circuitSize;
+    }
+    static empty() {
+        return new VerificationKeyData(VerificationKeyAsFields.makeEmpty(0), Buffer.alloc(0));
+    }
+    static makeFakeHonk() {
+        const keyAsFields = VerificationKeyAsFields.makeFakeHonk();
+        return new VerificationKeyData(keyAsFields, keyAsFields.toBuffer());
+    }
+    static makeFakeRollupHonk() {
+        const keyAsFields = VerificationKeyAsFields.makeFakeRollupHonk();
+        return new VerificationKeyData(keyAsFields, keyAsFields.toBuffer());
+    }
+    /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */ toBuffer() {
+        return serializeToBuffer(this.keyAsFields, this.keyAsBytes.length, this.keyAsBytes);
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const verificationKeyAsFields = reader.readObject(VerificationKeyAsFields);
+        const length = reader.readNumber();
+        const bytes = reader.readBytes(length);
+        return new VerificationKeyData(verificationKeyAsFields, bytes);
+    }
+    static async fromFrBuffer(vkBytes) {
+        return new VerificationKeyData(await VerificationKeyAsFields.fromFrBuffer(vkBytes), vkBytes);
+    }
+    static fromString(str) {
+        return VerificationKeyData.fromBuffer(hexToBuffer(str));
+    }
+    clone() {
+        return VerificationKeyData.fromBuffer(this.toBuffer());
+    }
+    /** Returns a hex representation for JSON serialization. */ toJSON() {
+        return this.toBuffer();
+    }
+    /** Creates an instance from a hex string. */ static get schema() {
+        return bufferSchemaFor(VerificationKeyData);
+    }
+}

package/dest/vks/vk_data.d.ts

@@ -0,0 +1,30 @@
+import { VK_TREE_HEIGHT } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, type Tuple } from '@aztec-labs/foundation/serialize';
+import type { UInt32 } from '../types/shared.js';
+import { VerificationKeyData } from './verification_key.js';
+export declare class VkData {
+    vk: VerificationKeyData;
+    /**
+     * Index of the vk in the vk tree.
+     */
+    leafIndex: UInt32;
+    /**
+     * Sibling path of the vk in the vk tree.
+     */
+    siblingPath: Tuple<Fr, typeof VK_TREE_HEIGHT>;
+    constructor(vk: VerificationKeyData, 
+    /**
+     * Index of the vk in the vk tree.
+     */
+    leafIndex: UInt32, 
+    /**
+     * Sibling path of the vk in the vk tree.
+     */
+    siblingPath: Tuple<Fr, typeof VK_TREE_HEIGHT>);
+    static empty(): VkData;
+    static fromBuffer(buffer: Buffer | BufferReader): VkData;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    toString(): `0x${string}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmtfZGF0YS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Zrcy92a19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV2RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDekQsT0FBTyxFQUFFLFlBQVksRUFBRSxLQUFLLEtBQUssRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUcvRixPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNqRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RCxxQkFBYSxNQUFNO0lBRVIsRUFBRSxFQUFFLG1CQUFtQjtJQUM5Qjs7T0FFRztJQUNJLFNBQVMsRUFBRSxNQUFNO0lBQ3hCOztPQUVHO0lBQ0ksV0FBVyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsT0FBTyxjQUFjLENBQUM7SUFUdEQsWUFDUyxFQUFFLEVBQUUsbUJBQW1CO0lBQzlCOztPQUVHO0lBQ0ksU0FBUyxFQUFFLE1BQU07SUFDeEI7O09BRUc7SUFDSSxXQUFXLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxPQUFPLGNBQWMsQ0FBQyxFQUNsRDtJQUVKLE1BQU0sQ0FBQyxLQUFLLFdBRVg7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxVQU85QztJQUVELFFBQVEsNEJBRVA7SUFFRCxRQUFRLGtCQUVQO0NBQ0YifQ==

package/dest/vks/vk_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vk_data.d.ts","sourceRoot":"","sources":["../../src/vks/vk_data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,KAAK,KAAK,EAAqB,MAAM,kCAAkC,CAAC;AAG/F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,MAAM;IAER,EAAE,EAAE,mBAAmB;IAC9B;;OAEG;IACI,SAAS,EAAE,MAAM;IACxB;;OAEG;IACI,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC;IATtD,YACS,EAAE,EAAE,mBAAmB;IAC9B;;OAEG;IACI,SAAS,EAAE,MAAM;IACxB;;OAEG;IACI,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,EAClD;IAEJ,MAAM,CAAC,KAAK,WAEX;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,UAO9C;IAED,QAAQ,4BAEP;IAED,QAAQ,kBAEP;CACF"}

package/dest/vks/vk_data.js

@@ -0,0 +1,33 @@
+import { VK_TREE_HEIGHT } from '@aztec-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex } from '@aztec-labs/foundation/string';
+import { VerificationKeyData } from './verification_key.js';
+export class VkData {
+    vk;
+    leafIndex;
+    siblingPath;
+    constructor(vk, /**
+     * Index of the vk in the vk tree.
+     */ leafIndex, /**
+     * Sibling path of the vk in the vk tree.
+     */ siblingPath){
+        this.vk = vk;
+        this.leafIndex = leafIndex;
+        this.siblingPath = siblingPath;
+    }
+    static empty() {
+        return new VkData(VerificationKeyData.empty(), 0, makeTuple(VK_TREE_HEIGHT, Fr.zero));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new VkData(reader.readObject(VerificationKeyData), reader.readNumber(), reader.readArray(VK_TREE_HEIGHT, Fr));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.vk, this.leafIndex, this.siblingPath);
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+}

package/dest/world-state/genesis_data.d.ts

@@ -0,0 +1,21 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { PublicDataTreeLeaf } from '../trees/index.js';
+/** Data used to initialize the genesis block, including prefilled public state and an optional timestamp. */
+export type GenesisData = {
+    /** Public data tree leaves to pre-populate in the genesis state (e.g. fee juice balances). */
+    prefilledPublicData: PublicDataTreeLeaf[];
+    /**
+     * Nullifiers to pre-insert into the genesis nullifier tree. Optional; defaults to an empty list, which leaves the
+     * nullifier tree at its canonical empty-genesis state so that production genesis roots are unchanged. When non-empty,
+     * the leaves must be unique and strictly increasing in field value (the native world state enforces this before
+     * construction). Test networks pass a non-empty list to seed e.g. standard-contract registration nullifiers.
+     */
+    prefilledNullifiers?: Fr[];
+    /** Timestamp for the genesis block header. Defaults to 0 (canonical empty genesis) in production. */
+    genesisTimestamp: bigint;
+};
+/** An empty genesis data with no prefilled state and a zero timestamp. */
+export declare const EMPTY_GENESIS_DATA: GenesisData;
+/** Returns if an object looks like genesis data */
+export declare function isGenesisData(obj: any): obj is GenesisData;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXNpc19kYXRhLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ybGQtc3RhdGUvZ2VuZXNpc19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRTlELE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFNUQsNkdBQTZHO0FBQzdHLE1BQU0sTUFBTSxXQUFXLEdBQUc7SUFDeEIsOEZBQThGO0lBQzlGLG1CQUFtQixFQUFFLGtCQUFrQixFQUFFLENBQUM7SUFDMUM7Ozs7O09BS0c7SUFDSCxtQkFBbUIsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQzNCLHFHQUFxRztJQUNyRyxnQkFBZ0IsRUFBRSxNQUFNLENBQUM7Q0FDMUIsQ0FBQztBQUVGLDBFQUEwRTtBQUMxRSxlQUFPLE1BQU0sa0JBQWtCLEVBQUUsV0FJaEMsQ0FBQztBQUVGLG1EQUFtRDtBQUNuRCx3QkFBZ0IsYUFBYSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsR0FBRyxJQUFJLFdBQVcsQ0FTMUQifQ==

package/dest/world-state/genesis_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genesis_data.d.ts","sourceRoot":"","sources":["../../src/world-state/genesis_data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,6GAA6G;AAC7G,MAAM,MAAM,WAAW,GAAG;IACxB,8FAA8F;IAC9F,mBAAmB,EAAE,kBAAkB,EAAE,CAAC;IAC1C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,EAAE,EAAE,CAAC;IAC3B,qGAAqG;IACrG,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,EAAE,WAIhC,CAAC;AAEF,mDAAmD;AACnD,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,WAAW,CAS1D"}

package/dest/world-state/genesis_data.js

@@ -0,0 +1,8 @@
+/** An empty genesis data with no prefilled state and a zero timestamp. */ export const EMPTY_GENESIS_DATA = {
+    prefilledPublicData: [],
+    prefilledNullifiers: [],
+    genesisTimestamp: 0n
+};
+/** Returns if an object looks like genesis data */ export function isGenesisData(obj) {
+    return obj && typeof obj === 'object' && 'prefilledPublicData' in obj && Array.isArray(obj.prefilledPublicData) && 'genesisTimestamp' in obj && typeof obj.genesisTimestamp === 'bigint';
+}

package/dest/world-state/index.d.ts

@@ -0,0 +1,3 @@
+export * from './genesis_data.js';
+export * from './world_state_revision.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93b3JsZC1zdGF0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMkJBQTJCLENBQUMifQ==

package/dest/world-state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world-state/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC"}

package/dest/world-state/index.js

@@ -0,0 +1,2 @@
+export * from './genesis_data.js';
+export * from './world_state_revision.js';

package/dest/world-state/world_state_revision.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare class WorldStateRevision {
+    readonly forkId: number;
+    readonly blockNumber: number;
+    readonly includeUncommitted: boolean;
+    /**
+     * Sentinel `blockNumber` meaning "not pinned to any historical block; use the latest committed
+     * state of the underlying tree". Mirrors the `WorldStateRevision::LATEST` constant on the C++
+     * side (defined as `std::numeric_limits<uint32_t>::max()`). Distinct from `blockNumber === 0`,
+     * which pins to the initial / genesis state.
+     */
+    static readonly LATEST = 4294967295;
+    constructor(forkId: number, blockNumber: number, includeUncommitted: boolean);
+    toString(): string;
+    static empty(): WorldStateRevision;
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        forkId: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        includeUncommitted: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodTransform<WorldStateRevision, {
+        forkId: number;
+        blockNumber: number;
+        includeUncommitted: boolean;
+    }>>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfcmV2aXNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93b3JsZC1zdGF0ZS93b3JsZF9zdGF0ZV9yZXZpc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLHFCQUFhLGtCQUFrQjthQVVYLE1BQU0sRUFBRSxNQUFNO2FBQ2QsV0FBVyxFQUFFLE1BQU07YUFDbkIsa0JBQWtCLEVBQUUsT0FBTztJQVg3Qzs7Ozs7T0FLRztJQUNILGdCQUF1QixNQUFNLGNBQWM7SUFFM0MsWUFDa0IsTUFBTSxFQUFFLE1BQU0sRUFDZCxXQUFXLEVBQUUsTUFBTSxFQUNuQixrQkFBa0IsRUFBRSxPQUFPLEVBQ3pDO0lBRUcsUUFBUSxXQUVkO0lBRUQsTUFBTSxDQUFDLEtBQUssdUJBRVg7SUFFRCxNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7UUFXaEI7Q0FDRiJ9

package/dest/world-state/world_state_revision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world_state_revision.d.ts","sourceRoot":"","sources":["../../src/world-state/world_state_revision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,qBAAa,kBAAkB;aAUX,MAAM,EAAE,MAAM;aACd,WAAW,EAAE,MAAM;aACnB,kBAAkB,EAAE,OAAO;IAX7C;;;;;OAKG;IACH,gBAAuB,MAAM,cAAc;IAE3C,YACkB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,OAAO,EACzC;IAEG,QAAQ,WAEd;IAED,MAAM,CAAC,KAAK,uBAEX;IAED,MAAM,KAAK,MAAM;;;;;;;;QAWhB;CACF"}

package/dest/world-state/world_state_revision.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export class WorldStateRevision {
+    forkId;
+    blockNumber;
+    includeUncommitted;
+    /**
+   * Sentinel `blockNumber` meaning "not pinned to any historical block; use the latest committed
+   * state of the underlying tree". Mirrors the `WorldStateRevision::LATEST` constant on the C++
+   * side (defined as `std::numeric_limits<uint32_t>::max()`). Distinct from `blockNumber === 0`,
+   * which pins to the initial / genesis state.
+   */ static LATEST = 0xffffffff;
+    constructor(forkId, blockNumber, includeUncommitted){
+        this.forkId = forkId;
+        this.blockNumber = blockNumber;
+        this.includeUncommitted = includeUncommitted;
+    }
+    toString() {
+        return `WorldStateRevision(forkId: ${this.forkId}, blockNumber: ${this.blockNumber}, includeUncommitted: ${this.includeUncommitted})`;
+    }
+    static empty() {
+        return new WorldStateRevision(0, WorldStateRevision.LATEST, false);
+    }
+    static get schema() {
+        return z.object({
+            forkId: z.number(),
+            blockNumber: z.number(),
+            includeUncommitted: z.boolean()
+        }).transform(({ forkId, blockNumber, includeUncommitted })=>new WorldStateRevision(forkId, blockNumber, includeUncommitted));
+    }
+}

package/dest/zkpassport/index.d.ts

@@ -0,0 +1,34 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+export type ViemZkPassportProofParams = {
+    version: `0x${string}`;
+    proofVerificationData: {
+        vkeyHash: `0x${string}`;
+        proof: `0x${string}`;
+        publicInputs: `0x${string}`[];
+    };
+    committedInputs: `0x${string}`;
+    serviceConfig: {
+        validityPeriodInSeconds: bigint;
+        domain: string;
+        scope: string;
+        devMode: boolean;
+    };
+};
+export declare class ZkPassportProofParams {
+    devMode: boolean;
+    vkeyHash: Buffer32;
+    proof: Buffer;
+    publicInputs: Fr[];
+    committedInputs: Buffer;
+    validityPeriodInSeconds: bigint;
+    domain: string;
+    scope: string;
+    constructor(devMode: boolean, vkeyHash: Buffer32, proof: Buffer, publicInputs: Fr[], committedInputs: Buffer, validityPeriodInSeconds: bigint, domain: string, scope: string);
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static random(): ZkPassportProofParams;
+    static fromBuffer(buffer: Buffer): ZkPassportProofParams;
+    static fromViem(params: ViemZkPassportProofParams): ZkPassportProofParams;
+    toViem(): ViemZkPassportProofParams;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy96a3Bhc3Nwb3J0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUV6RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFJekQsTUFBTSxNQUFNLHlCQUF5QixHQUFHO0lBQ3RDLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO0lBQ3ZCLHFCQUFxQixFQUFFO1FBQ3JCLFFBQVEsRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQ3hCLEtBQUssRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQ3JCLFlBQVksRUFBRSxLQUFLLE1BQU0sRUFBRSxFQUFFLENBQUM7S0FDL0IsQ0FBQztJQUNGLGVBQWUsRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO0lBQy9CLGFBQWEsRUFBRTtRQUNiLHVCQUF1QixFQUFFLE1BQU0sQ0FBQztRQUNoQyxNQUFNLEVBQUUsTUFBTSxDQUFDO1FBQ2YsS0FBSyxFQUFFLE1BQU0sQ0FBQztRQUNkLE9BQU8sRUFBRSxPQUFPLENBQUM7S0FDbEIsQ0FBQztDQUNILENBQUM7QUFJRixxQkFBYSxxQkFBcUI7SUFFdkIsT0FBTyxFQUFFLE9BQU87SUFDaEIsUUFBUSxFQUFFLFFBQVE7SUFDbEIsS0FBSyxFQUFFLE1BQU07SUFDYixZQUFZLEVBQUUsRUFBRSxFQUFFO0lBQ2xCLGVBQWUsRUFBRSxNQUFNO0lBQ3ZCLHVCQUF1QixFQUFFLE1BQU07SUFDL0IsTUFBTSxFQUFFLE1BQU07SUFDZCxLQUFLLEVBQUUsTUFBTTtJQVJ0QixZQUNTLE9BQU8sRUFBRSxPQUFPLEVBQ2hCLFFBQVEsRUFBRSxRQUFRLEVBQ2xCLEtBQUssRUFBRSxNQUFNLEVBQ2IsWUFBWSxFQUFFLEVBQUUsRUFBRSxFQUNsQixlQUFlLEVBQUUsTUFBTSxFQUN2Qix1QkFBdUIsRUFBRSxNQUFNLEVBQy9CLE1BQU0sRUFBRSxNQUFNLEVBQ2QsS0FBSyxFQUFFLE1BQU0sRUFDbEI7SUFFSixRQUFRLDRCQWNQO0lBRUQsTUFBTSxDQUFDLE1BQU0sMEJBa0JaO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSx5QkFZL0I7SUFFRCxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSx5QkFBeUIseUJBV2hEO0lBRUQsTUFBTSxJQUFJLHlCQUF5QixDQWlCbEM7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zkpassport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAIzD,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC;IACvB,qBAAqB,EAAE;QACrB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;QACxB,KAAK,EAAE,KAAK,MAAM,EAAE,CAAC;QACrB,YAAY,EAAE,KAAK,MAAM,EAAE,EAAE,CAAC;KAC/B,CAAC;IACF,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,aAAa,EAAE;QACb,uBAAuB,EAAE,MAAM,CAAC;QAChC,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH,CAAC;AAIF,qBAAa,qBAAqB;IAEvB,OAAO,EAAE,OAAO;IAChB,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,MAAM;IACb,YAAY,EAAE,EAAE,EAAE;IAClB,eAAe,EAAE,MAAM;IACvB,uBAAuB,EAAE,MAAM;IAC/B,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,MAAM;IARtB,YACS,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,EAAE,EAAE,EAClB,eAAe,EAAE,MAAM,EACvB,uBAAuB,EAAE,MAAM,EAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EAClB;IAEJ,QAAQ,4BAcP;IAED,MAAM,CAAC,MAAM,0BAkBZ;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,yBAY/B;IAED,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,yBAWhD;IAED,MAAM,IAAI,yBAAyB,CAiBlC;CACF"}

package/dest/zkpassport/index.js

@@ -0,0 +1,82 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { withoutHexPrefix } from '@aztec-labs/foundation/string';
+// 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 {
+    devMode;
+    vkeyHash;
+    proof;
+    publicInputs;
+    committedInputs;
+    validityPeriodInSeconds;
+    domain;
+    scope;
+    constructor(devMode, vkeyHash, proof, publicInputs, committedInputs, validityPeriodInSeconds, domain, scope){
+        this.devMode = devMode;
+        this.vkeyHash = vkeyHash;
+        this.proof = proof;
+        this.publicInputs = publicInputs;
+        this.committedInputs = committedInputs;
+        this.validityPeriodInSeconds = validityPeriodInSeconds;
+        this.domain = domain;
+        this.scope = scope;
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.devMode,
+            this.vkeyHash,
+            this.proof.length,
+            this.proof,
+            this.publicInputs.length,
+            this.publicInputs,
+            this.committedInputs.length,
+            this.committedInputs,
+            this.validityPeriodInSeconds,
+            this.domain,
+            this.scope
+        ]);
+    }
+    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, BigInt(7 * 24 * 60 * 60), 'sequencer.alpha-testnet.aztec.network', 'personhood');
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new ZkPassportProofParams(reader.readBoolean(), reader.readObject(Buffer32), reader.readBuffer(), reader.readVector(Fr), reader.readBuffer(), reader.readUInt256(), reader.readString(), reader.readString());
+    }
+    static fromViem(params) {
+        return new ZkPassportProofParams(params.serviceConfig.devMode, Buffer32.fromString(params.proofVerificationData.vkeyHash), Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'), params.proofVerificationData.publicInputs.map((input)=>Fr.fromString(input)), Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'), params.serviceConfig.validityPeriodInSeconds, params.serviceConfig.domain, params.serviceConfig.scope);
+    }
+    toViem() {
+        // Version is set to bytes32(0) as per zkpassport library convention
+        return {
+            version: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            proofVerificationData: {
+                vkeyHash: this.vkeyHash.toString(),
+                proof: `0x${this.proof.toString('hex')}`,
+                publicInputs: this.publicInputs.map((input)=>input.toString())
+            },
+            committedInputs: `0x${this.committedInputs.toString('hex')}`,
+            serviceConfig: {
+                devMode: this.devMode,
+                validityPeriodInSeconds: this.validityPeriodInSeconds,
+                domain: this.domain,
+                scope: this.scope
+            }
+        };
+    }
+}