@aztec/foundation 0.0.0-test.0

package/dest/crypto/sync/poseidon/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable } from '../../../serialize/serialize.js';
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */
+export declare function poseidon2Hash(input: Fieldable[]): Fr;
+/**
+ * Create a poseidon hash (field) from an array of input fields and a domain separator.
+ * @param input - The input fields to hash.
+ * @param separator - The domain separator.
+ * @returns The poseidon hash.
+ */
+export declare function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr;
+export declare function poseidon2HashAccumulate(input: Fieldable[]): Fr;
+/**
+ * Runs a Poseidon2 permutation.
+ * @param input the input state. Expected to be of size 4.
+ * @returns the output state, size 4.
+ */
+export declare function poseidon2Permutation(input: Fieldable[]): Fr[];
+export declare function poseidon2HashBytes(input: Buffer): Fr;
+//# sourceMappingURL=index.d.ts.map

package/dest/crypto/sync/poseidon/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crypto/sync/poseidon/index.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,2BAA2B,CAAC;AAC/C,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,iCAAiC,CAAC;AAEpF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,CAMpD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,EAAE,CAQpF;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,CAU7D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAgBpD"}

package/dest/crypto/sync/poseidon/index.js

@@ -0,0 +1,53 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { Fr } from '../../../fields/fields.js';
+import { serializeToFields } from '../../../serialize/serialize.js';
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */ export function poseidon2Hash(input) {
+    const inputFields = serializeToFields(input);
+    const hash = BarretenbergSync.getSingleton().poseidon2Hash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+/**
+ * Create a poseidon hash (field) from an array of input fields and a domain separator.
+ * @param input - The input fields to hash.
+ * @param separator - The domain separator.
+ * @returns The poseidon hash.
+ */ export function poseidon2HashWithSeparator(input, separator) {
+    const inputFields = serializeToFields(input);
+    inputFields.unshift(new Fr(separator));
+    const hash = BarretenbergSync.getSingleton().poseidon2Hash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+export function poseidon2HashAccumulate(input) {
+    const inputFields = serializeToFields(input);
+    const result = BarretenbergSync.getSingleton().poseidon2HashAccumulate(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+}
+/**
+ * Runs a Poseidon2 permutation.
+ * @param input the input state. Expected to be of size 4.
+ * @returns the output state, size 4.
+ */ export function poseidon2Permutation(input) {
+    const inputFields = serializeToFields(input);
+    // We'd like this assertion but it's not possible to use it in the browser.
+    // assert(input.length === 4, 'Input state must be of size 4');
+    const res = BarretenbergSync.getSingleton().poseidon2Permutation(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    // We'd like this assertion but it's not possible to use it in the browser.
+    // assert(res.length === 4, 'Output state must be of size 4');
+    return res.map((o)=>Fr.fromBuffer(Buffer.from(o.toBuffer())));
+}
+export function poseidon2HashBytes(input) {
+    const inputFields = [];
+    for(let i = 0; i < input.length; i += 31){
+        const fieldBytes = Buffer.alloc(32, 0);
+        input.slice(i, i + 31).copy(fieldBytes);
+        // Noir builds the bytes as little-endian, so we need to reverse them.
+        fieldBytes.reverse();
+        inputFields.push(Fr.fromBuffer(fieldBytes));
+    }
+    const res = BarretenbergSync.getSingleton().poseidon2Hash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+}

package/dest/decorators/index.d.ts

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

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

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

package/dest/decorators/index.js

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

package/dest/decorators/memoize.d.ts

@@ -0,0 +1,2 @@
+export declare function memoize<This extends object, Result>(fn: () => Result, context: ClassMethodDecoratorContext): (this: This) => Result;
+//# sourceMappingURL=memoize.d.ts.map

package/dest/decorators/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/decorators/memoize.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,IAAI,SAAS,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,MAAM,EAAE,OAAO,EAAE,2BAA2B,UAClF,IAAI,YAS5B"}

package/dest/decorators/memoize.js

@@ -0,0 +1,11 @@
+export function memoize(fn, context) {
+    return function() {
+        const key = `__${String(context.name)}_value`;
+        const thisWithKey = this;
+        if (!(key in this)) {
+            const result = fn.call(this);
+            thisWithKey[key] = result;
+        }
+        return thisWithKey[key];
+    };
+}

package/dest/error/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 declare class InterruptError extends Error {
+    readonly name = "InterruptError";
+}
+/**
+ * An error thrown when an action times out.
+ */
+export declare class TimeoutError extends Error {
+    readonly name = "TimeoutError";
+}
+/**
+ * Represents an error thrown when an operation is aborted.
+ */
+export declare class AbortError extends Error {
+    readonly name = "AbortError";
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/error/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAyB,IAAI,oBAAoB;CAClD;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,SAAyB,IAAI,kBAAkB;CAChD;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAyB,IAAI,gBAAgB;CAC9C"}

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,134 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { inspect } from 'util';
+import { Fr } from '../fields/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;
+    /**
+     * 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): 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(): string;
+    /**
+     * Returns a 20-byte buffer representation of the Ethereum address.
+     * @returns A 20-byte Buffer containing the Ethereum address.
+     */
+    toBuffer(): 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(): Buffer;
+    /**
+     * 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;
+    toJSON(): `0x${string}`;
+    static get schema(): import("zod").ZodType<EthAddress, any, string>;
+}
+//# sourceMappingURL=index.d.ts.map

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,oBAAoB,CAAC;AAExC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIlE;;;;;GAKG;AACH,qBAAa,UAAU;IAMT,OAAO,CAAC,MAAM;IAL1B,gDAAgD;IAChD,OAAc,aAAa,SAAM;IACjC,0EAA0E;IAC1E,OAAc,IAAI,aAA0D;gBAExD,MAAM,EAAE,MAAM;IAMlC;;;;;;;OAOG;WACW,UAAU,CAAC,OAAO,EAAE,MAAM;IAOxC;;;;;;OAMG;WACW,MAAM;IAIpB;;;;;;;;OAQG;WACW,SAAS,CAAC,OAAO,EAAE,MAAM;IAYvC;;;;;OAKG;IACI,MAAM;IAIb;;;;;;;OAOG;WACW,oBAAoB,CAAC,OAAO,EAAE,MAAM;IAgBlD;;;;;;;;;OASG;WACW,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAoB/C;;;;;;OAMG;IACI,MAAM,CAAC,GAAG,EAAE,UAAU;IAI7B;;;;;;OAMG;IACI,QAAQ;IAIf,CAAC,OAAO,CAAC,MAAM,CAAC;IAIhB;;;;;;OAMG;IACI,gBAAgB;IAIvB;;;OAGG;IACI,QAAQ;IAIf;;;;;;OAMG;IACI,UAAU;IAMjB;;;;OAIG;IACI,OAAO;IAId;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,UAAU;IAIpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU;IAK5D,MAAM;IAIN,MAAM,KAAK,MAAM,mDAEhB;CACF"}

package/dest/eth-address/index.js

@@ -0,0 +1,198 @@
+import { inspect } from 'util';
+import { keccak256String } from '../crypto/keccak/index.js';
+import { randomBytes } from '../crypto/random/index.js';
+import { Fr } from '../fields/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
+import { BufferReader, FieldReader } from '../serialize/index.js';
+import { TypeRegistry } from '../serialize/type_registry.js';
+import { bufferToHex } from '../string/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 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'));
+    }
+    /**
+   * 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);
+    }
+    [inspect.custom]() {
+        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));
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(EthAddress, EthAddress.isAddress);
+    }
+}
+// For deserializing JSON.
+TypeRegistry.register('EthAddress', EthAddress);

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

@@ -0,0 +1,62 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+/**Viem Signature
+ *
+ * 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;
+    isEmpty: boolean;
+};
+/**
+ * Signature
+ *
+ * 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;
+    /** Does this struct store an empty signature */
+    readonly isEmpty: boolean;
+    private size;
+    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, 
+    /** Does this struct store an empty signature */
+    isEmpty?: boolean);
+    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 random(): Signature;
+    static empty(): Signature;
+    equals(other: Signature): boolean;
+    toBuffer(): Buffer;
+    getSize(): number;
+    toString(): `0x${string}`;
+    /**
+     * Return the signature with `0x${string}` encodings for r and s
+     */
+    toViemSignature(): ViemSignature;
+    toJSON(): `0x${string}`;
+    static get schema(): z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, `0x${string}`, string>, Signature, string>;
+}
+//# sourceMappingURL=eth_signature.d.ts.map

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,0BAA0B,CAAC;AACpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,SAAS;IAKlB,mCAAmC;aACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;aACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;aACnB,CAAC,EAAE,MAAM;IACzB,gDAAgD;aAChC,OAAO,EAAE,OAAO;IAVlC,OAAO,CAAC,IAAI,CAAqB;;IAG/B,mCAAmC;IACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;IACnB,CAAC,EAAE,QAAQ;IAC3B,mCAAmC;IACnB,CAAC,EAAE,MAAM;IACzB,gDAAgD;IAChC,OAAO,GAAE,OAAe;IAG1C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAYxD,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,MAAM,EAAE,GAAG,OAAO;IAIjD;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS;IAYhD,MAAM,CAAC,MAAM,IAAI,SAAS;IAI1B,MAAM,CAAC,KAAK,IAAI,SAAS;IAIzB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAIjC,QAAQ,IAAI,MAAM;IAMlB,OAAO,IAAI,MAAM;IAUjB,QAAQ,IAAI,KAAK,MAAM,EAAE;IAIzB;;OAEG;IACH,eAAe,IAAI,aAAa;IAShC,MAAM;IAIN,MAAM,KAAK,MAAM,2HAMhB;CACF"}

package/dest/eth-signature/eth_signature.js

@@ -0,0 +1,91 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { hasHexPrefix, hexToBuffer } from '../string/index.js';
+/**
+ * Signature
+ *
+ * Contains a signature split into it's primary components (r,s,v)
+ */ export class Signature {
+    r;
+    s;
+    v;
+    isEmpty;
+    // Cached values
+    size;
+    constructor(/** The r value of the signature */ r, /** The s value of the signature */ s, /** The v value of the signature */ v, /** Does this struct store an empty signature */ isEmpty = false){
+        this.r = r;
+        this.s = s;
+        this.v = v;
+        this.isEmpty = isEmpty;
+    }
+    static fromBuffer(buf) {
+        const reader = BufferReader.asReader(buf);
+        const r = reader.readObject(Buffer32);
+        const s = reader.readObject(Buffer32);
+        const v = reader.readNumber();
+        const isEmpty = r.isZero() && s.isZero();
+        return new Signature(r, s, v, isEmpty);
+    }
+    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);
+        const isEmpty = r.isZero() && s.isZero();
+        return new Signature(r, s, v, isEmpty);
+    }
+    static random() {
+        return new Signature(Buffer32.random(), Buffer32.random(), Math.floor(Math.random() * 2), false);
+    }
+    static empty() {
+        return new Signature(Buffer32.ZERO, Buffer32.ZERO, 0, true);
+    }
+    equals(other) {
+        return this.r.equals(other.r) && this.s.equals(other.s) && this.v === other.v && this.isEmpty === other.isEmpty;
+    }
+    toBuffer() {
+        const buffer = serializeToBuffer([
+            this.r,
+            this.s,
+            this.v
+        ]);
+        this.size = buffer.length;
+        return buffer;
+    }
+    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,
+            isEmpty: this.isEmpty
+        };
+    }
+    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=index.d.ts.map

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';