@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/error/index.js

@@ -0,0 +1,17 @@
+/**
+ * Represents an error thrown when an operation is interrupted unexpectedly.
+ * This custom error class extends the built-in Error class in JavaScript and
+ * can be used to handle cases where a process or task is terminated before completion.
+ */ export class InterruptError extends Error {
+    name = 'InterruptError';
+}
+/**
+ * An error thrown when an action times out.
+ */ export class TimeoutError extends Error {
+    name = 'TimeoutError';
+}
+/**
+ * Represents an error thrown when an operation is aborted.
+ */ export class AbortError extends Error {
+    name = 'AbortError';
+}

package/dest/eth-address/index.d.ts

@@ -0,0 +1,143 @@
+import { inspect } from 'util';
+import { Fr } from '../curves/bn254/index.js';
+import { BufferReader, FieldReader } from '../serialize/index.js';
+/**
+ * Represents an Ethereum address as a 20-byte buffer and provides various utility methods
+ * for converting between different representations, generating random addresses, validating
+ * checksums, and comparing addresses. EthAddress can be instantiated using a buffer or string,
+ * and can be serialized/deserialized from a buffer or BufferReader.
+ */
+export declare class EthAddress {
+    private buffer;
+    /** The size of an Ethereum address in bytes. */
+    static SIZE_IN_BYTES: number;
+    /** Represents a zero Ethereum address with 20 bytes filled with zeros. */
+    static ZERO: EthAddress;
+    constructor(buffer: Buffer);
+    /**
+     * Creates an EthAddress instance from a valid Ethereum address string.
+     * The input 'address' can be either in checksum format or lowercase, and it can be prefixed with '0x'.
+     * Throws an error if the input is not a valid Ethereum address.
+     *
+     * @param address - The string representing the Ethereum address.
+     * @returns An EthAddress instance.
+     */
+    static fromString(address: string): EthAddress;
+    /**
+     * Creates an EthAddress from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * Handles buffers (20 or 32 bytes), strings, or existing instances.
+     * @param obj - Plain object, buffer, string, or EthAddress instance
+     * @returns An EthAddress instance
+     */
+    static fromPlainObject(obj: any): EthAddress;
+    /**
+     * Create a random EthAddress instance with 20 random bytes.
+     * This method generates a new Ethereum address with a randomly generated set of 20 bytes.
+     * It is useful for generating test addresses or unique identifiers.
+     *
+     * @returns A randomly generated EthAddress instance.
+     */
+    static random(): EthAddress;
+    /**
+     * Determines if the given string represents a valid Ethereum address.
+     * A valid address should meet the following criteria:
+     * 1. Contains exactly 40 hex characters (excluding an optional '0x' prefix).
+     * 2. Is either all lowercase, all uppercase, or has a valid checksum based on EIP-55.
+     *
+     * @param address - The string to be checked for validity as an Ethereum address.
+     * @returns True if the input string represents a valid Ethereum address, false otherwise.
+     */
+    static isAddress(address: string): boolean;
+    /**
+     * Checks if the EthAddress instance represents a zero address.
+     * A zero address consists of 20 bytes filled with zeros and is considered an invalid address.
+     *
+     * @returns A boolean indicating whether the EthAddress instance is a zero address or not.
+     */
+    isZero(): boolean;
+    /**
+     * Checks if the given Ethereum address has a valid checksum.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+     * Returns true if the address has a valid checksum, false otherwise.
+     *
+     * @param address - The hex-encoded string representing the Ethereum address.
+     * @returns A boolean value indicating whether the address has a valid checksum.
+     */
+    static checkAddressChecksum(address: string): boolean;
+    /**
+     * Converts an Ethereum address to its checksum format.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+     * The checksum format is created by capitalizing certain characters in the hex string
+     * based on the hash of the lowercase address.
+     * Throws an error if the input address is invalid.
+     *
+     * @param address - The Ethereum address as a hex-encoded string.
+     * @returns The Ethereum address in its checksum format.
+     */
+    static toChecksumAddress(address: string): `0x${string}`;
+    /**
+     * Checks whether the given EthAddress instance is equal to the current instance.
+     * Equality is determined by comparing the underlying byte buffers of both instances.
+     *
+     * @param rhs - The EthAddress instance to compare with the current instance.
+     * @returns A boolean value indicating whether the two instances are equal (true) or not (false).
+     */
+    equals(rhs: EthAddress): boolean;
+    /**
+     * Converts the Ethereum address to a hex-encoded string.
+     * The resulting string is prefixed with '0x' and has exactly 40 hex characters.
+     * This method can be used to represent the EthAddress instance in the widely used hexadecimal format.
+     *
+     * @returns A hex-encoded string representation of the Ethereum address.
+     */
+    toString(): `0x${string}`;
+    [inspect.custom](): string;
+    /**
+     * Returns the Ethereum address as a checksummed string.
+     * The output string will have characters in the correct upper or lowercase form, according to EIP-55.
+     * This provides a way to verify if an address is typed correctly, by checking the character casing.
+     *
+     * @returns A checksummed Ethereum address string.
+     */
+    toChecksumString(): `0x${string}`;
+    /**
+     * Returns a 20-byte buffer representation of the Ethereum address.
+     * @returns A 20-byte Buffer containing the Ethereum address.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Returns a 32-byte buffer representation of the Ethereum address, with the original 20-byte address
+     * occupying the last 20 bytes and the first 12 bytes being zero-filled.
+     * This format is commonly used in smart contracts when handling addresses as 32-byte values.
+     *
+     * @returns A 32-byte Buffer containing the padded Ethereum address.
+     */
+    toBuffer32(): Buffer<ArrayBuffer>;
+    /**
+     * Returns a new field with the same contents as this EthAddress.
+     *
+     * @returns An Fr instance.
+     */
+    toField(): Fr;
+    /**
+     * Converts a field to a eth address.
+     * @param fr - The field to convert.
+     * @returns The eth address.
+     */
+    static fromField(fr: Fr): EthAddress;
+    static fromFields(fields: Fr[] | FieldReader): EthAddress;
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer to read from.
+     * @returns The EthAddress.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): EthAddress;
+    /** Converts a number into an address. Useful for testing. */
+    static fromNumber(num: bigint | number): EthAddress;
+    toJSON(): `0x${string}`;
+    static get schema(): import("zod").ZodType<EthAddress, string, import("zod/v4/core").$ZodTypeInternals<EthAddress, string>>;
+    static areEqual(a: EthAddress | string, b: EthAddress | string): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ldGgtYWRkcmVzcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBSS9CLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU5QyxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR2xFOzs7OztHQUtHO0FBQ0gscUJBQWEsVUFBVTtJQU1ULE9BQU8sQ0FBQyxNQUFNO0lBTDFCLGdEQUFnRDtJQUNoRCxPQUFjLGFBQWEsU0FBTTtJQUNqQywwRUFBMEU7SUFDMUUsT0FBYyxJQUFJLGFBQTBEO0lBRTVFLFlBQW9CLE1BQU0sRUFBRSxNQUFNLEVBSWpDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILE9BQWMsVUFBVSxDQUFDLE9BQU8sRUFBRSxNQUFNLGNBS3ZDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILE9BQWMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsVUFBVSxDQVFsRDtJQUVEOzs7Ozs7T0FNRztJQUNILE9BQWMsTUFBTSxlQUVuQjtJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsT0FBYyxTQUFTLENBQUMsT0FBTyxFQUFFLE1BQU0sV0FVdEM7SUFFRDs7Ozs7T0FLRztJQUNJLE1BQU0sWUFFWjtJQUVEOzs7Ozs7O09BT0c7SUFDSCxPQUFjLG9CQUFvQixDQUFDLE9BQU8sRUFBRSxNQUFNLFdBY2pEO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsT0FBYyxpQkFBaUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxHQUFHLEtBQUssTUFBTSxFQUFFLENBa0I5RDtJQUVEOzs7Ozs7T0FNRztJQUNJLE1BQU0sQ0FBQyxHQUFHLEVBQUUsVUFBVSxXQUU1QjtJQUVEOzs7Ozs7T0FNRztJQUNJLFFBQVEsa0JBRWQ7SUFFRCxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsV0FFZjtJQUVEOzs7Ozs7T0FNRztJQUNJLGdCQUFnQixrQkFFdEI7SUFFRDs7O09BR0c7SUFDSSxRQUFRLDRCQUVkO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksVUFBVSx3QkFJaEI7SUFFRDs7OztPQUlHO0lBQ0ksT0FBTyxPQUViO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxVQUFVLENBRW5DO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxjQUczQztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLFVBQVUsQ0FHM0Q7SUFFRCw2REFBNkQ7SUFDN0QsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxVQUFVLENBSWxEO0lBRUQsTUFBTSxrQkFFTDtJQUVELE1BQU0sS0FBSyxNQUFNLDJHQUdoQjtJQUVELE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxFQUFFLFVBQVUsR0FBRyxNQUFNLEVBQUUsQ0FBQyxFQUFFLFVBQVUsR0FBRyxNQUFNLFdBSTdEO0NBQ0YifQ==

package/dest/eth-address/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/eth-address/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAI/B,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGlE;;;;;GAKG;AACH,qBAAa,UAAU;IAMT,OAAO,CAAC,MAAM;IAL1B,gDAAgD;IAChD,OAAc,aAAa,SAAM;IACjC,0EAA0E;IAC1E,OAAc,IAAI,aAA0D;IAE5E,YAAoB,MAAM,EAAE,MAAM,EAIjC;IAED;;;;;;;OAOG;IACH,OAAc,UAAU,CAAC,OAAO,EAAE,MAAM,cAKvC;IAED;;;;;;;OAOG;IACH,OAAc,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAQlD;IAED;;;;;;OAMG;IACH,OAAc,MAAM,eAEnB;IAED;;;;;;;;OAQG;IACH,OAAc,SAAS,CAAC,OAAO,EAAE,MAAM,WAUtC;IAED;;;;;OAKG;IACI,MAAM,YAEZ;IAED;;;;;;;OAOG;IACH,OAAc,oBAAoB,CAAC,OAAO,EAAE,MAAM,WAcjD;IAED;;;;;;;;;OASG;IACH,OAAc,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAkB9D;IAED;;;;;;OAMG;IACI,MAAM,CAAC,GAAG,EAAE,UAAU,WAE5B;IAED;;;;;;OAMG;IACI,QAAQ,kBAEd;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAEf;IAED;;;;;;OAMG;IACI,gBAAgB,kBAEtB;IAED;;;OAGG;IACI,QAAQ,4BAEd;IAED;;;;;;OAMG;IACI,UAAU,wBAIhB;IAED;;;;OAIG;IACI,OAAO,OAEb;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,UAAU,CAEnC;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,cAG3C;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU,CAG3D;IAED,6DAA6D;IAC7D,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAIlD;IAED,MAAM,kBAEL;IAED,MAAM,KAAK,MAAM,2GAGhB;IAED,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,WAI7D;CACF"}

package/dest/eth-address/index.js

@@ -0,0 +1,224 @@
+var _computedKey;
+import { inspect } from 'util';
+import { keccak256String } from '../crypto/keccak/index.js';
+import { randomBytes } from '../crypto/random/index.js';
+import { Fr } from '../curves/bn254/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
+import { BufferReader, FieldReader } from '../serialize/index.js';
+import { bufferToHex } from '../string/index.js';
+_computedKey = inspect.custom;
+/**
+ * Represents an Ethereum address as a 20-byte buffer and provides various utility methods
+ * for converting between different representations, generating random addresses, validating
+ * checksums, and comparing addresses. EthAddress can be instantiated using a buffer or string,
+ * and can be serialized/deserialized from a buffer or BufferReader.
+ */ export class EthAddress {
+    buffer;
+    /** The size of an Ethereum address in bytes. */ static SIZE_IN_BYTES = 20;
+    /** Represents a zero Ethereum address with 20 bytes filled with zeros. */ static ZERO = new EthAddress(Buffer.alloc(EthAddress.SIZE_IN_BYTES));
+    constructor(buffer){
+        this.buffer = buffer;
+        if (buffer.length !== EthAddress.SIZE_IN_BYTES) {
+            throw new Error(`Expect buffer size to be ${EthAddress.SIZE_IN_BYTES}. Got ${buffer.length}.`);
+        }
+    }
+    /**
+   * Creates an EthAddress instance from a valid Ethereum address string.
+   * The input 'address' can be either in checksum format or lowercase, and it can be prefixed with '0x'.
+   * Throws an error if the input is not a valid Ethereum address.
+   *
+   * @param address - The string representing the Ethereum address.
+   * @returns An EthAddress instance.
+   */ static fromString(address) {
+        if (!EthAddress.isAddress(address)) {
+            throw new Error(`Invalid address string: ${address}`);
+        }
+        return new EthAddress(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+    }
+    /**
+   * Creates an EthAddress from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * Handles buffers (20 or 32 bytes), strings, or existing instances.
+   * @param obj - Plain object, buffer, string, or EthAddress instance
+   * @returns An EthAddress instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof EthAddress) {
+            return obj;
+        }
+        if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
+            return obj.length === 20 ? new EthAddress(obj) : EthAddress.fromField(new Fr(obj));
+        }
+        return EthAddress.fromString(obj);
+    }
+    /**
+   * Create a random EthAddress instance with 20 random bytes.
+   * This method generates a new Ethereum address with a randomly generated set of 20 bytes.
+   * It is useful for generating test addresses or unique identifiers.
+   *
+   * @returns A randomly generated EthAddress instance.
+   */ static random() {
+        return new EthAddress(randomBytes(20));
+    }
+    /**
+   * Determines if the given string represents a valid Ethereum address.
+   * A valid address should meet the following criteria:
+   * 1. Contains exactly 40 hex characters (excluding an optional '0x' prefix).
+   * 2. Is either all lowercase, all uppercase, or has a valid checksum based on EIP-55.
+   *
+   * @param address - The string to be checked for validity as an Ethereum address.
+   * @returns True if the input string represents a valid Ethereum address, false otherwise.
+   */ static isAddress(address) {
+        if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+            // Does not have the basic requirements of an address.
+            return false;
+        } else if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {
+            // It's ALL lowercase or ALL uppercase.
+            return true;
+        } else {
+            return EthAddress.checkAddressChecksum(address);
+        }
+    }
+    /**
+   * Checks if the EthAddress instance represents a zero address.
+   * A zero address consists of 20 bytes filled with zeros and is considered an invalid address.
+   *
+   * @returns A boolean indicating whether the EthAddress instance is a zero address or not.
+   */ isZero() {
+        return this.equals(EthAddress.ZERO);
+    }
+    /**
+   * Checks if the given Ethereum address has a valid checksum.
+   * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+   * Returns true if the address has a valid checksum, false otherwise.
+   *
+   * @param address - The hex-encoded string representing the Ethereum address.
+   * @returns A boolean value indicating whether the address has a valid checksum.
+   */ static checkAddressChecksum(address) {
+        address = address.replace(/^0x/i, '');
+        const addressHash = keccak256String(address.toLowerCase());
+        for(let i = 0; i < 40; i++){
+            // The nth letter should be uppercase if the nth digit of casemap is 1.
+            if (parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i] || parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+   * Converts an Ethereum address to its checksum format.
+   * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+   * The checksum format is created by capitalizing certain characters in the hex string
+   * based on the hash of the lowercase address.
+   * Throws an error if the input address is invalid.
+   *
+   * @param address - The Ethereum address as a hex-encoded string.
+   * @returns The Ethereum address in its checksum format.
+   */ static toChecksumAddress(address) {
+        if (!EthAddress.isAddress(address)) {
+            throw new Error('Invalid address string.');
+        }
+        address = address.toLowerCase().replace(/^0x/i, '');
+        const addressHash = keccak256String(address);
+        let checksumAddress = '0x';
+        for(let i = 0; i < address.length; i++){
+            // If ith character is 9 to f then make it uppercase.
+            if (parseInt(addressHash[i], 16) > 7) {
+                checksumAddress += address[i].toUpperCase();
+            } else {
+                checksumAddress += address[i];
+            }
+        }
+        return checksumAddress;
+    }
+    /**
+   * Checks whether the given EthAddress instance is equal to the current instance.
+   * Equality is determined by comparing the underlying byte buffers of both instances.
+   *
+   * @param rhs - The EthAddress instance to compare with the current instance.
+   * @returns A boolean value indicating whether the two instances are equal (true) or not (false).
+   */ equals(rhs) {
+        return this.buffer.equals(rhs.buffer);
+    }
+    /**
+   * Converts the Ethereum address to a hex-encoded string.
+   * The resulting string is prefixed with '0x' and has exactly 40 hex characters.
+   * This method can be used to represent the EthAddress instance in the widely used hexadecimal format.
+   *
+   * @returns A hex-encoded string representation of the Ethereum address.
+   */ toString() {
+        return bufferToHex(this.buffer);
+    }
+    [_computedKey]() {
+        return `EthAddress<${this.toString()}>`;
+    }
+    /**
+   * Returns the Ethereum address as a checksummed string.
+   * The output string will have characters in the correct upper or lowercase form, according to EIP-55.
+   * This provides a way to verify if an address is typed correctly, by checking the character casing.
+   *
+   * @returns A checksummed Ethereum address string.
+   */ toChecksumString() {
+        return EthAddress.toChecksumAddress(this.buffer.toString('hex'));
+    }
+    /**
+   * Returns a 20-byte buffer representation of the Ethereum address.
+   * @returns A 20-byte Buffer containing the Ethereum address.
+   */ toBuffer() {
+        return this.buffer;
+    }
+    /**
+   * Returns a 32-byte buffer representation of the Ethereum address, with the original 20-byte address
+   * occupying the last 20 bytes and the first 12 bytes being zero-filled.
+   * This format is commonly used in smart contracts when handling addresses as 32-byte values.
+   *
+   * @returns A 32-byte Buffer containing the padded Ethereum address.
+   */ toBuffer32() {
+        const buffer = Buffer.alloc(32);
+        this.buffer.copy(buffer, 12);
+        return buffer;
+    }
+    /**
+   * Returns a new field with the same contents as this EthAddress.
+   *
+   * @returns An Fr instance.
+   */ toField() {
+        return Fr.fromBuffer(this.toBuffer32());
+    }
+    /**
+   * Converts a field to a eth address.
+   * @param fr - The field to convert.
+   * @returns The eth address.
+   */ static fromField(fr) {
+        return new EthAddress(fr.toBuffer().slice(-EthAddress.SIZE_IN_BYTES));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return EthAddress.fromField(reader.readField());
+    }
+    /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer to read from.
+   * @returns The EthAddress.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new EthAddress(reader.readBytes(EthAddress.SIZE_IN_BYTES));
+    }
+    /** Converts a number into an address. Useful for testing. */ static fromNumber(num) {
+        const buffer = Buffer.alloc(EthAddress.SIZE_IN_BYTES);
+        buffer.writeBigUInt64BE(BigInt(num), EthAddress.SIZE_IN_BYTES - 8);
+        return new EthAddress(buffer);
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        // Serialization from hex string.
+        return hexSchemaFor(EthAddress, EthAddress.isAddress);
+    }
+    static areEqual(a, b) {
+        const addrA = typeof a === 'string' ? EthAddress.fromString(a) : a;
+        const addrB = typeof b === 'string' ? EthAddress.fromString(b) : b;
+        return addrA.equals(addrB);
+    }
+}

package/dest/eth-signature/eth_signature.d.ts

@@ -0,0 +1,65 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import { z } from 'zod';
+/**
+ * A version of the Signature class that uses `0x${string}` values for r and s rather than Buffer32s
+ */
+export type ViemSignature = {
+    r: `0x${string}`;
+    s: `0x${string}`;
+    v: number;
+};
+export type ViemTransactionSignature = {
+    r: `0x${string}`;
+    s: `0x${string}`;
+    yParity: 0 | 1;
+};
+/**
+ * Contains a signature split into it's primary components (r,s,v)
+ */
+export declare class Signature {
+    /** The r value of the signature */
+    readonly r: Buffer32;
+    /** The s value of the signature */
+    readonly s: Buffer32;
+    /** The v value of the signature */
+    readonly v: number;
+    private size;
+    readonly empty: boolean;
+    constructor(
+    /** The r value of the signature */
+    r: Buffer32, 
+    /** The s value of the signature */
+    s: Buffer32, 
+    /** The v value of the signature */
+    v: number);
+    static fromBuffer(buf: Buffer | BufferReader): Signature;
+    static isValidString(sig: `0x${string}`): boolean;
+    /**
+     * A seperate method exists for this as when signing locally with viem, as when
+     * parsing from viem, we can expect the v value to be a u8, rather than our
+     * default serialization of u32
+     */
+    static fromString(sig: `0x${string}`): Signature;
+    static fromViemSignature(sig: ViemSignature): Signature;
+    static fromViemTransactionSignature(sig: ViemTransactionSignature): Signature;
+    /** Generates a random valid ECDSA signature with a low s-value by signing a random message with a random key. */
+    static random(): Signature;
+    static empty(): Signature;
+    isEmpty(): boolean;
+    equals(other: Signature): boolean;
+    toBuffer(): Buffer;
+    getSize(): number;
+    toString(): `0x${string}`;
+    /**
+     * Return the signature with `0x${string}` encodings for r and s
+     */
+    toViemSignature(): ViemSignature;
+    /**
+     * Return the signature with `0x${string}` encodings for r and s. Verifies v is valid
+     */
+    toViemTransactionSignature(): ViemTransactionSignature;
+    toJSON(): `0x${string}`;
+    static get schema(): z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<Signature, `0x${string}`>>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/eth-signature/eth_signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth_signature.d.ts","sourceRoot":"","sources":["../../src/eth-signature/eth_signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAEnF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS;IAOlB,mCAAmC;aACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;aACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;aACnB,CAAC,EAAE,MAAM;IAV3B,OAAO,CAAC,IAAI,CAAqB;IAEjC,SAAgB,KAAK,EAAE,OAAO,CAAC;IAE/B;IACE,mCAAmC;IACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;IACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;IACnB,CAAC,EAAE,MAAM,EAG1B;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAQvD;IAED,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,MAAM,EAAE,GAAG,OAAO,CAEhD;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAQ/C;IAED,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,CAEtD;IAED,MAAM,CAAC,4BAA4B,CAAC,GAAG,EAAE,wBAAwB,GAAG,SAAS,CAE5E;IAED,iHAAiH;IACjH,MAAM,CAAC,MAAM,IAAI,SAAS,CAKzB;IAED,MAAM,CAAC,KAAK,IAAI,SAAS,CAExB;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEhC;IAED,QAAQ,IAAI,MAAM,CAEjB;IAED,OAAO,IAAI,MAAM,CAQhB;IAED,QAAQ,IAAI,KAAK,MAAM,EAAE,CAExB;IAED;;OAEG;IACH,eAAe,IAAI,aAAa,CAM/B;IAED;;OAEG;IACH,0BAA0B,IAAI,wBAAwB,CASrD;IAED,MAAM,kBAEL;IAED,MAAM,KAAK,MAAM,yJAMhB;CACF"}

package/dest/eth-signature/eth_signature.js

@@ -0,0 +1,110 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { z } from 'zod';
+import { randomBytes } from '../crypto/random/index.js';
+import { hasHexPrefix, hexToBuffer } from '../string/index.js';
+/**
+ * Contains a signature split into it's primary components (r,s,v)
+ */ export class Signature {
+    r;
+    s;
+    v;
+    // Cached values
+    size;
+    empty;
+    constructor(/** The r value of the signature */ r, /** The s value of the signature */ s, /** The v value of the signature */ v){
+        this.r = r;
+        this.s = s;
+        this.v = v;
+        this.empty = r.isZero() && s.isZero() && v === 0;
+    }
+    static fromBuffer(buf) {
+        const reader = BufferReader.asReader(buf);
+        const r = reader.readObject(Buffer32);
+        const s = reader.readObject(Buffer32);
+        const v = reader.readNumber();
+        return new Signature(r, s, v);
+    }
+    static isValidString(sig) {
+        return /^0x[0-9a-f]{129,}$/i.test(sig);
+    }
+    /**
+   * A seperate method exists for this as when signing locally with viem, as when
+   * parsing from viem, we can expect the v value to be a u8, rather than our
+   * default serialization of u32
+   */ static fromString(sig) {
+        const buf = hexToBuffer(sig);
+        const reader = BufferReader.asReader(buf);
+        const r = reader.readObject(Buffer32);
+        const s = reader.readObject(Buffer32);
+        const v = parseInt(sig.slice(2 + 64 * 2), 16);
+        return new Signature(r, s, v);
+    }
+    static fromViemSignature(sig) {
+        return new Signature(Buffer32.fromBuffer(hexToBuffer(sig.r)), Buffer32.fromBuffer(hexToBuffer(sig.s)), sig.v);
+    }
+    static fromViemTransactionSignature(sig) {
+        return new Signature(Buffer32.fromBuffer(hexToBuffer(sig.r)), Buffer32.fromBuffer(hexToBuffer(sig.s)), sig.yParity);
+    }
+    /** Generates a random valid ECDSA signature with a low s-value by signing a random message with a random key. */ static random() {
+        const privateKey = randomBytes(32);
+        const message = randomBytes(32);
+        const { r, s, recovery } = secp256k1.sign(message, privateKey);
+        return new Signature(Buffer32.fromBigInt(r), Buffer32.fromBigInt(s), recovery ? 28 : 27);
+    }
+    static empty() {
+        return new Signature(Buffer32.ZERO, Buffer32.ZERO, 0);
+    }
+    isEmpty() {
+        return this.empty;
+    }
+    equals(other) {
+        return this.r.equals(other.r) && this.s.equals(other.s) && this.v === other.v && this.empty === other.empty;
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.r,
+            this.s,
+            this.v
+        ]);
+    }
+    getSize() {
+        // We cache size to avoid recalculating it
+        if (this.size) {
+            return this.size;
+        }
+        this.size = this.toBuffer().length;
+        return this.size;
+    }
+    toString() {
+        return `0x${this.r.buffer.toString('hex')}${this.s.buffer.toString('hex')}${this.v.toString(16)}`;
+    }
+    /**
+   * Return the signature with `0x${string}` encodings for r and s
+   */ toViemSignature() {
+        return {
+            r: this.r.toString(),
+            s: this.s.toString(),
+            v: this.v
+        };
+    }
+    /**
+   * Return the signature with `0x${string}` encodings for r and s. Verifies v is valid
+   */ toViemTransactionSignature() {
+        if (this.v !== 0 && this.v !== 1) {
+            throw new Error('Invalid transaction signature');
+        }
+        return {
+            r: this.r.toString(),
+            s: this.s.toString(),
+            yParity: this.v
+        };
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return z.string().refine(hasHexPrefix, 'No hex prefix').refine(Signature.isValidString, 'Not a valid Ethereum signature').transform(Signature.fromString);
+    }
+}

package/dest/eth-signature/index.d.ts

@@ -0,0 +1,2 @@
+export * from './eth_signature.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ldGgtc2lnbmF0dXJlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUMifQ==

package/dest/eth-signature/index.d.ts.map

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

package/dest/eth-signature/index.js

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

package/dest/fifo/fifo_frame_reader.d.ts

@@ -0,0 +1,41 @@
+import EventEmitter from 'node:events';
+import type { Readable } from 'node:stream';
+/**
+ * Events emitted by FifoFrameReader.
+ *
+ * - `frame`: A complete frame payload (without the 4-byte length header).
+ * - `error`: An unrecoverable error (invalid frame length, stream error).
+ * - `end`: The underlying stream has ended.
+ */
+export interface FifoFrameReaderEvents {
+    frame: [payload: Buffer];
+    error: [error: Error];
+    end: [];
+}
+/**
+ * Reads length-delimited frames from a readable stream (typically a named FIFO pipe).
+ *
+ * Wire format: `[4-byte big-endian payload length][payload bytes]`
+ *
+ * Emits a `frame` event for each complete frame with the raw payload buffer.
+ * Callers are responsible for deserializing the payload (e.g., via msgpack).
+ *
+ * On encountering an invalid payload length (0 or >maxPayloadSize), emits `error`
+ * and destroys the stream.
+ */
+export declare class FifoFrameReader extends EventEmitter<FifoFrameReaderEvents> {
+    private readonly maxPayloadSize;
+    private stream;
+    private pendingBuf;
+    private running;
+    constructor(maxPayloadSize?: number);
+    /** Open a FIFO at the given path and start reading frames. */
+    start(fifoPath: string): void;
+    /** Start reading frames from an existing readable stream. */
+    startFromStream(stream: Readable): void;
+    /** Stop reading and destroy the underlying stream. */
+    stop(): void;
+    /** Parse complete frames out of the pending buffer. */
+    private drainFrames;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlmb19mcmFtZV9yZWFkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWZvL2ZpZm9fZnJhbWVfcmVhZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sWUFBWSxNQUFNLGFBQWEsQ0FBQztBQUd2QyxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFNUM7Ozs7OztHQU1HO0FBQ0gsTUFBTSxXQUFXLHFCQUFxQjtJQUNwQyxLQUFLLEVBQUUsQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDekIsS0FBSyxFQUFFLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3RCLEdBQUcsRUFBRSxFQUFFLENBQUM7Q0FDVDtBQUVEOzs7Ozs7Ozs7O0dBVUc7QUFDSCxxQkFBYSxlQUFnQixTQUFRLFlBQVksQ0FBQyxxQkFBcUIsQ0FBQztJQUsxRCxPQUFPLENBQUMsUUFBUSxDQUFDLGNBQWM7SUFKM0MsT0FBTyxDQUFDLE1BQU0sQ0FBeUI7SUFDdkMsT0FBTyxDQUFDLFVBQVUsQ0FBMkI7SUFDN0MsT0FBTyxDQUFDLE9BQU8sQ0FBUztJQUV4QixZQUE2QixjQUFjLFNBQW1CLEVBRTdEO0lBRUQsOERBQThEO0lBQzlELEtBQUssQ0FBQyxRQUFRLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FnQjVCO0lBRUQsNkRBQTZEO0lBQzdELGVBQWUsQ0FBQyxNQUFNLEVBQUUsUUFBUSxHQUFHLElBQUksQ0F1QnRDO0lBRUQsc0RBQXNEO0lBQ3RELElBQUksSUFBSSxJQUFJLENBTVg7SUFFRCx1REFBdUQ7SUFDdkQsT0FBTyxDQUFDLFdBQVc7Q0FtQnBCIn0=

package/dest/fifo/fifo_frame_reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fifo_frame_reader.d.ts","sourceRoot":"","sources":["../../src/fifo/fifo_frame_reader.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,aAAa,CAAC;AAGvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACzB,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtB,GAAG,EAAE,EAAE,CAAC;CACT;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,YAAY,CAAC,qBAAqB,CAAC;IAK1D,OAAO,CAAC,QAAQ,CAAC,cAAc;IAJ3C,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,OAAO,CAAS;IAExB,YAA6B,cAAc,SAAmB,EAE7D;IAED,8DAA8D;IAC9D,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAgB5B;IAED,6DAA6D;IAC7D,eAAe,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAuBtC;IAED,sDAAsD;IACtD,IAAI,IAAI,IAAI,CAMX;IAED,uDAAuD;IACvD,OAAO,CAAC,WAAW;CAmBpB"}