@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/abi/encoder.js

@@ -0,0 +1,287 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { isAddressStruct, isBoundedVecStruct, isFunctionSelectorStruct, isOptionStruct, isWrappedFieldStruct } from './utils.js';
+/**
+ * Encodes arguments for a function call.
+ * Missing support for integer and string.
+ */ class ArgumentEncoder {
+    abi;
+    args;
+    flattened;
+    constructor(abi, args){
+        this.abi = abi;
+        this.args = args;
+        this.flattened = [];
+    }
+    static typeSize(abiType) {
+        switch(abiType.kind){
+            case 'field':
+            case 'boolean':
+            case 'integer':
+                return 1;
+            case 'string':
+                return abiType.length;
+            case 'array':
+                return abiType.length * ArgumentEncoder.typeSize(abiType.type);
+            case 'struct':
+                return abiType.fields.reduce((acc, field)=>acc + ArgumentEncoder.typeSize(field.type), 0);
+            case 'tuple':
+                return abiType.fields.reduce((acc, field)=>acc + ArgumentEncoder.typeSize(field), 0);
+            default:
+                {
+                    const exhaustiveCheck = abiType;
+                    throw new Error(`Unhandled abi type: ${exhaustiveCheck}`);
+                }
+        }
+    }
+    /**
+   * Encodes a single argument from the given type to field.
+   * @param abiType - The abi type of the argument.
+   * @param arg - The value to encode.
+   * @param name - Name.
+   */ encodeArgument(abiType, arg, name) {
+        if (isOptionStruct(abiType)) {
+            const optionType = abiType;
+            const [isSomeField, valueField] = optionType.fields;
+            if (arg === undefined || arg === null) {
+                this.encodeArgument(isSomeField.type, false, `${name}._is_some`);
+                this.#encodeDefaultValue(valueField.type);
+                return;
+            }
+            if (typeof arg === 'object' && '_is_some' in arg) {
+                this.encodeArgument(isSomeField.type, arg._is_some, `${name}._is_some`);
+                if (arg._is_some) {
+                    this.encodeArgument(valueField.type, arg._value, `${name}._value`);
+                } else {
+                    this.#encodeDefaultValue(valueField.type);
+                }
+                return;
+            }
+            this.encodeArgument(isSomeField.type, true, `${name}._is_some`);
+            this.encodeArgument(valueField.type, arg, `${name}._value`);
+            return;
+        }
+        if (arg === undefined || arg == null) {
+            throw new Error(`Undefined argument ${name ?? 'unnamed'} of type ${abiType.kind}`);
+        }
+        switch(abiType.kind){
+            case 'field':
+                if (typeof arg === 'number') {
+                    this.flattened.push(new Fr(BigInt(arg)));
+                } else if (typeof arg === 'bigint') {
+                    this.flattened.push(new Fr(arg));
+                } else if (typeof arg === 'string') {
+                    this.flattened.push(Fr.fromString(arg));
+                } else if (typeof arg === 'boolean') {
+                    this.flattened.push(new Fr(arg ? 1n : 0n));
+                } else if (typeof arg === 'object') {
+                    if (Buffer.isBuffer(arg)) {
+                        this.flattened.push(Fr.fromBuffer(arg));
+                    } else if (typeof arg.toField === 'function') {
+                        this.flattened.push(arg.toField());
+                    } else if (typeof arg.value === 'string') {
+                        this.flattened.push(Fr.fromHexString(arg.value));
+                    } else {
+                        throw new Error(`Argument for ${name} cannot be serialized to a field`);
+                    }
+                } else {
+                    throw new Error(`Invalid argument "${arg}" of type ${abiType.kind}`);
+                }
+                break;
+            case 'boolean':
+                this.flattened.push(new Fr(arg ? 1n : 0n));
+                break;
+            case 'array':
+                if (!Array.isArray(arg)) {
+                    throw new Error(`Expected array for '${name ?? 'unnamed'}' but received ${typeof arg}`);
+                }
+                if (arg.length !== abiType.length) {
+                    throw new Error(`Expected array of length ${abiType.length} for '${name ?? 'unnamed'}' but received length ${arg.length}`);
+                }
+                for(let i = 0; i < abiType.length; i += 1){
+                    this.encodeArgument(abiType.type, arg[i], `${name}[${i}]`);
+                }
+                break;
+            case 'string':
+                if (typeof arg !== 'string') {
+                    throw new Error(`Expected string for '${name ?? 'unnamed'}' but received ${typeof arg}`);
+                }
+                if (arg.length > abiType.length) {
+                    throw new Error(`Expected string of max length ${abiType.length} for '${name ?? 'unnamed'}' but received length ${arg.length}`);
+                }
+                for(let i = 0; i < abiType.length; i += 1){
+                    const toInsert = i < arg.length ? BigInt(arg.charCodeAt(i)) : 0n;
+                    this.flattened.push(new Fr(toInsert));
+                }
+                break;
+            case 'struct':
+                {
+                    // If the type defines the encoding to noir, we use it
+                    if (arg.encodeToNoir !== undefined) {
+                        this.flattened.push(...arg.encodeToNoir());
+                        break;
+                    }
+                    // If the abi expects a struct like { address: Field } and the supplied arg does not have
+                    // an address field in it, we try to encode it as if it were a field directly.
+                    const isAddress = isAddressStruct(abiType);
+                    if (isAddress && typeof arg.address === 'undefined' && typeof arg.inner === 'undefined') {
+                        this.encodeArgument({
+                            kind: 'field'
+                        }, arg, `${name}.inner`);
+                        break;
+                    }
+                    // Or if the supplied argument does have an address field in it, like a CompleteAddress,
+                    // we encode it directly as a field.
+                    if (isAddress && typeof arg.address !== 'undefined') {
+                        this.encodeArgument({
+                            kind: 'field'
+                        }, arg.address, `${name}.address`);
+                        break;
+                    }
+                    if (isFunctionSelectorStruct(abiType)) {
+                        this.encodeArgument({
+                            kind: 'integer',
+                            sign: 'unsigned',
+                            width: 32
+                        }, arg.value ?? arg, `${name}.inner`);
+                        break;
+                    }
+                    if (isWrappedFieldStruct(abiType)) {
+                        this.encodeArgument({
+                            kind: 'field'
+                        }, arg.inner ?? arg, `${name}.inner`);
+                        break;
+                    }
+                    if (isBoundedVecStruct(abiType)) {
+                        this.#encodeBoundedVec(abiType, arg, name);
+                        break;
+                    }
+                    for (const field of abiType.fields){
+                        this.encodeArgument(field.type, arg[field.name], `${name}.${field.name}`);
+                    }
+                    break;
+                }
+            case 'integer':
+                {
+                    const value = BigInt(arg);
+                    if (abiType.sign === 'unsigned') {
+                        const maxValue = (1n << BigInt(abiType.width)) - 1n;
+                        if (value < 0n || value > maxValue) {
+                            throw new Error(`Value ${value} does not fit in u${abiType.width} for '${name ?? 'unnamed'}' (valid range: 0 to ${maxValue})`);
+                        }
+                        this.flattened.push(new Fr(value));
+                    } else {
+                        const minValue = -(1n << BigInt(abiType.width - 1));
+                        const maxValue = (1n << BigInt(abiType.width - 1)) - 1n;
+                        if (value < minValue || value > maxValue) {
+                            throw new Error(`Value ${value} does not fit in i${abiType.width} for '${name ?? 'unnamed'}' (valid range: ${minValue} to ${maxValue})`);
+                        }
+                        if (value < 0n) {
+                            const twosComplement = value + (1n << BigInt(abiType.width));
+                            this.flattened.push(new Fr(twosComplement));
+                        } else {
+                            this.flattened.push(new Fr(value));
+                        }
+                    }
+                    break;
+                }
+            default:
+                throw new Error(`Unsupported type: ${abiType.kind}`);
+        }
+    }
+    /**
+   * Encodes all the arguments for the given function ABI.
+   * @returns The encoded arguments.
+   */ encode() {
+        if (this.args.length !== this.abi.parameters.length) {
+            throw new Error(`Function '${this.abi.name}' expects ${this.abi.parameters.length} argument(s) but received ${this.args.length}`);
+        }
+        for(let i = 0; i < this.abi.parameters.length; i += 1){
+            const parameterAbi = this.abi.parameters[i];
+            this.encodeArgument(parameterAbi.type, this.args[i], parameterAbi.name);
+        }
+        return this.flattened;
+    }
+    /**
+   * Encodes an array as a BoundedVec struct.
+   * @dev BoundedVec is handled as a special case rather than a generic struct for two reasons:
+   * 1. It is a commonly used type
+   * 2. Manual encoding it is cumbersome
+   * Therefore, the input is simplified to accept a plain array of type T.
+   * @param abiType - The ABI type definition.
+   * @param arg - An array of items to encode.
+   * @param name - The name of the parameter.
+   *
+   * The BoundedVec struct is defined in Noir as:
+   *
+   * ```noir
+   * pub struct BoundedVec<T, let MaxLen: u32> {
+   *   storage: [T; MaxLen],
+   *   len: u32,
+   * }
+   * ```
+   *
+   * The encoding follows Noir's serialization format:
+   * 1. The storage array is encoded first
+   * 2. The length field is encoded second
+   */ #encodeBoundedVec(abiType, arg, name) {
+        // First we encode the storage array
+        {
+            // Get the storage array type from the BoundedVec struct
+            const storageField = abiType.fields.find((f)=>f.name === 'storage');
+            const maxLength = storageField.type.length;
+            if (arg.length > maxLength) {
+                // Create a preview of the array for the error message, limiting to first few elements
+                const preview = arg.slice(0, 3).map((x)=>{
+                    if (typeof x === 'object' && x !== null) {
+                        if (Array.isArray(x)) {
+                            return `[${x.join(', ')}]`;
+                        }
+                        // Convert object to string representation of its key-value pairs
+                        return `{${Object.entries(x).map(([k, v])=>`${k}: ${v}`).join(', ')}}`;
+                    }
+                    return `${x}`;
+                }).join(', ');
+                const suffix = arg.length > 3 ? ', ...' : '';
+                throw new Error(`Error encoding param '${name ?? 'unnamed'}': ` + `expected an array of maximum length ${maxLength} and got ${arg.length} instead: [ ${preview}${suffix} ]`);
+            }
+            const storageArrayItemType = storageField.type.type;
+            // Now we encode each item in the input array
+            for(let i = 0; i < arg.length; i++){
+                this.encodeArgument(storageArrayItemType, arg[i], `storage[${i}]`);
+            }
+            // Then we pad the storage array with zeros such that the BoundedVec max length is correct.
+            const numItemsToPad = maxLength - arg.length;
+            if (numItemsToPad > 0) {
+                const numFieldsToPad = numItemsToPad * ArgumentEncoder.typeSize(storageArrayItemType);
+                const paddingFields = new Array(numFieldsToPad).fill(Fr.ZERO);
+                this.flattened.push(...paddingFields);
+            }
+        }
+        // At last we encode the length field
+        {
+            const lenField = abiType.fields.find((f)=>f.name === 'len');
+            this.encodeArgument(lenField.type, arg.length, 'len');
+        }
+    }
+    /**
+   * Appends the flattened zero value for an ABI type.
+   * Option::None still serializes the wrapped value, so we need to zero-fill its footprint.
+   */ #encodeDefaultValue(abiType) {
+        this.flattened.push(...new Array(ArgumentEncoder.typeSize(abiType)).fill(Fr.ZERO));
+    }
+}
+/**
+ * Encodes all the arguments for a function call.
+ * @param abi - The function ABI entry.
+ * @param args - The arguments to encode.
+ * @returns The encoded arguments.
+ */ export function encodeArguments(abi, args) {
+    return new ArgumentEncoder(abi, args).encode();
+}
+/**
+ * Returns the size of the arguments for a function ABI.
+ * @param abi - The function ABI entry.
+ * @returns The size of the arguments.
+ */ export function countArgumentsSize(abi) {
+    return abi.parameters.reduce((acc, parameter)=>acc + ArgumentEncoder.typeSize(parameter.type), 0);
+}

package/dest/abi/event_metadata_definition.d.ts

@@ -0,0 +1,10 @@
+import type { AbiType } from './abi.js';
+import type { EventSelector } from './event_selector.js';
+/** Metadata for a contract event, used to decode emitted event logs back into structured data. */
+export type EventMetadataDefinition = {
+    eventSelector: EventSelector;
+    abiType: AbiType;
+    /** Names of the event's struct members (not serialized Noir Field elements). */
+    fieldNames: string[];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRfbWV0YWRhdGFfZGVmaW5pdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FiaS9ldmVudF9tZXRhZGF0YV9kZWZpbml0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUN4QyxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV6RCxrR0FBa0c7QUFDbEcsTUFBTSxNQUFNLHVCQUF1QixHQUFHO0lBQ3BDLGFBQWEsRUFBRSxhQUFhLENBQUM7SUFDN0IsT0FBTyxFQUFFLE9BQU8sQ0FBQztJQUNqQixnRkFBZ0Y7SUFDaEYsVUFBVSxFQUFFLE1BQU0sRUFBRSxDQUFDO0NBQ3RCLENBQUMifQ==

package/dest/abi/event_metadata_definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_metadata_definition.d.ts","sourceRoot":"","sources":["../../src/abi/event_metadata_definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,kGAAkG;AAClG,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,gFAAgF;IAChF,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC"}

package/dest/abi/event_metadata_definition.js

@@ -0,0 +1 @@
+/** Metadata for a contract event, used to decode emitted event logs back into structured data. */ export { };

package/dest/abi/event_selector.d.ts

@@ -0,0 +1,47 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import { Selector } from './selector.js';
+/** An event selector is the first 4 bytes of the hash of an event signature. */
+export declare class EventSelector extends Selector {
+    /** Branding for nominal typing. */
+    private readonly _branding;
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer  or BufferReader to read from.
+     * @returns The Selector.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): EventSelector;
+    /**
+     * Converts a field to selector.
+     * @param fr - The field to convert.
+     * @returns The selector.
+     */
+    static fromField(fr: Fr): EventSelector;
+    /**
+     * Creates a selector from a signature.
+     * @param signature - Signature to generate the selector for (e.g. "transfer(field,field)").
+     * @returns selector.
+     */
+    static fromSignature(signature: string): Promise<EventSelector>;
+    /**
+     * Create a Selector instance from a hex-encoded string.
+     *
+     * @param selector - The hex-encoded string representing the Selector.
+     * @returns An Selector instance.
+     * @throws If the selector length is invalid.
+     */
+    static fromString(selector: string): EventSelector;
+    /**
+     * Creates an empty selector.
+     * @returns An empty selector.
+     */
+    static empty(): EventSelector;
+    /**
+     * Creates a random selector.
+     * @returns A random selector.
+     */
+    static random(): EventSelector;
+    toJSON(): string;
+    static get schema(): import("zod").ZodType<EventSelector, string, import("zod/v4/core").$ZodTypeInternals<EventSelector, string>>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRfc2VsZWN0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hYmkvZXZlbnRfc2VsZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFOUQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRWhFLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsZ0ZBQWdGO0FBQ2hGLHFCQUFhLGFBQWMsU0FBUSxRQUFRO0lBQ3pDLG1DQUFtQztJQUNuQyxpQkFBeUIsU0FBUyxDQUFrQjtJQUNwRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksaUJBSTlDO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsaUJBRXRCO0lBRUQ7Ozs7T0FJRztJQUNILE9BQWEsYUFBYSxDQUFDLFNBQVMsRUFBRSxNQUFNLDBCQVMzQztJQUVEOzs7Ozs7T0FNRztJQUNILE1BQU0sQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLE1BQU0saUJBTWpDO0lBRUQ7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLEtBQUssa0JBRVg7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsTUFBTSxrQkFFWjtJQUVELE1BQU0sV0FFTDtJQUVELE1BQU0sS0FBSyxNQUFNLGlIQUVoQjtDQUNGIn0=

package/dest/abi/event_selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_selector.d.ts","sourceRoot":"","sources":["../../src/abi/event_selector.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAE9D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,gFAAgF;AAChF,qBAAa,aAAc,SAAQ,QAAQ;IACzC,mCAAmC;IACnC,iBAAyB,SAAS,CAAkB;IACpD;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,iBAI9C;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,iBAEtB;IAED;;;;OAIG;IACH,OAAa,aAAa,CAAC,SAAS,EAAE,MAAM,0BAS3C;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,iBAMjC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,kBAEX;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,kBAEZ;IAED,MAAM,WAEL;IAED,MAAM,KAAK,MAAM,iHAEhB;CACF"}

package/dest/abi/event_selector.js

@@ -0,0 +1,69 @@
+import { fromHex, toBigIntBE } from '@aztec-labs/foundation/bigint-buffer';
+import { poseidon2HashBytes } from '@aztec-labs/foundation/crypto/poseidon';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { hexSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import { Selector } from './selector.js';
+/** An event selector is the first 4 bytes of the hash of an event signature. */ export class EventSelector extends Selector {
+    /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer  or BufferReader to read from.
+   * @returns The Selector.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const value = Number(toBigIntBE(reader.readBytes(Selector.SIZE)));
+        return new EventSelector(value);
+    }
+    /**
+   * Converts a field to selector.
+   * @param fr - The field to convert.
+   * @returns The selector.
+   */ static fromField(fr) {
+        return new EventSelector(Number(fr.toBigInt()));
+    }
+    /**
+   * Creates a selector from a signature.
+   * @param signature - Signature to generate the selector for (e.g. "transfer(field,field)").
+   * @returns selector.
+   */ static async fromSignature(signature) {
+        // throw if signature contains whitespace
+        if (/\s/.test(signature)) {
+            throw new Error('Signature cannot contain whitespace');
+        }
+        const hash = await poseidon2HashBytes(Buffer.from(signature));
+        // We take the last Selector.SIZE big endian bytes
+        const bytes = hash.toBuffer().slice(-Selector.SIZE);
+        return EventSelector.fromBuffer(bytes);
+    }
+    /**
+   * Create a Selector instance from a hex-encoded string.
+   *
+   * @param selector - The hex-encoded string representing the Selector.
+   * @returns An Selector instance.
+   * @throws If the selector length is invalid.
+   */ static fromString(selector) {
+        const buf = fromHex(selector);
+        if (buf.length !== Selector.SIZE) {
+            throw new Error(`Invalid EventSelector length ${buf.length} (expected ${Selector.SIZE}).`);
+        }
+        return EventSelector.fromBuffer(buf);
+    }
+    /**
+   * Creates an empty selector.
+   * @returns An empty selector.
+   */ static empty() {
+        return new EventSelector(0);
+    }
+    /**
+   * Creates a random selector.
+   * @returns A random selector.
+   */ static random() {
+        return EventSelector.fromBuffer(randomBytes(Selector.SIZE));
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(EventSelector);
+    }
+}

package/dest/abi/function_call.d.ts

@@ -0,0 +1,79 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+import { type AbiType, FunctionType } from './abi.js';
+import { FunctionSelector } from './function_selector.js';
+/** A request to call a function on a contract. */
+export declare class FunctionCall {
+    /** The name of the function to call */
+    name: string;
+    /** The recipient contract */
+    to: AztecAddress;
+    /** The function being called */
+    selector: FunctionSelector;
+    /** Type of the function */
+    type: FunctionType;
+    /** Only applicable for enqueued public function calls. `hideMsgSender = true` will set the msg_sender field (the caller's address) to "null", meaning the public function (and observers around the world) won't know which smart contract address made the call. */
+    hideMsgSender: boolean;
+    /** Whether this call can make modifications to state or not */
+    isStatic: boolean;
+    /** The encoded args */
+    args: Fr[];
+    /** The type the call returns, for decoding, or undefined if it returns nothing */
+    returnType?: AbiType | undefined;
+    constructor(
+    /** The name of the function to call */
+    name: string, 
+    /** The recipient contract */
+    to: AztecAddress, 
+    /** The function being called */
+    selector: FunctionSelector, 
+    /** Type of the function */
+    type: FunctionType, 
+    /** Only applicable for enqueued public function calls. `hideMsgSender = true` will set the msg_sender field (the caller's address) to "null", meaning the public function (and observers around the world) won't know which smart contract address made the call. */
+    hideMsgSender: boolean, 
+    /** Whether this call can make modifications to state or not */
+    isStatic: boolean, 
+    /** The encoded args */
+    args: Fr[], 
+    /** The type the call returns, for decoding, or undefined if it returns nothing */
+    returnType?: AbiType | undefined);
+    static getFields(fields: FieldsOf<FunctionCall>): readonly [string, AztecAddress, FunctionSelector, FunctionType, boolean, boolean, Fr[], AbiType | undefined];
+    static from(fields: FieldsOf<FunctionCall>): FunctionCall;
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        name: z.ZodString;
+        to: import("../schemas/index.js").ZodFor<AztecAddress>;
+        selector: import("../schemas/index.js").ZodFor<FunctionSelector>;
+        type: z.ZodEnum<typeof FunctionType>;
+        isStatic: z.ZodBoolean;
+        hideMsgSender: z.ZodBoolean;
+        args: z.ZodArray<import("../schemas/index.js").ZodFor<Fr>>;
+        returnType: z.ZodOptional<z.ZodType<AbiType, unknown, z.core.$ZodTypeInternals<AbiType, unknown>>>;
+        returnTypes: z.ZodOptional<z.ZodArray<z.ZodType<AbiType, unknown, z.core.$ZodTypeInternals<AbiType, unknown>>>>;
+    }, z.core.$strip>, z.ZodTransform<FunctionCall, {
+        name: string;
+        to: AztecAddress;
+        selector: FunctionSelector;
+        type: FunctionType;
+        isStatic: boolean;
+        hideMsgSender: boolean;
+        args: Fr[];
+        returnType?: AbiType | undefined;
+        returnTypes?: AbiType[] | undefined;
+    }>>;
+    /**
+     * Serializes the deprecated `returnTypes` alongside `returnType`, so that peers that still require the old field can
+     * parse calls sent by this version.
+     */
+    toJSON(): this & {
+        returnTypes: AbiType[];
+    };
+    isPublicStatic(): boolean;
+    /**
+     * Creates an empty function call.
+     * @returns an empty function call.
+     */
+    static empty(): FunctionCall;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25fY2FsbC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FiaS9mdW5jdGlvbl9jYWxsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzdELE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRXpELE9BQU8sRUFBRSxLQUFLLE9BQU8sRUFBaUIsWUFBWSxFQUF5QixNQUFNLFVBQVUsQ0FBQztBQUM1RixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUxRCxrREFBa0Q7QUFDbEQscUJBQWEsWUFBWTtJQUVyQix1Q0FBdUM7SUFDaEMsSUFBSSxFQUFFLE1BQU07SUFDbkIsNkJBQTZCO0lBQ3RCLEVBQUUsRUFBRSxZQUFZO0lBQ3ZCLGdDQUFnQztJQUN6QixRQUFRLEVBQUUsZ0JBQWdCO0lBQ2pDLDJCQUEyQjtJQUNwQixJQUFJLEVBQUUsWUFBWTtJQUN6QixxUUFBcVE7SUFDOVAsYUFBYSxFQUFFLE9BQU87SUFDN0IsK0RBQStEO0lBQ3hELFFBQVEsRUFBRSxPQUFPO0lBQ3hCLHVCQUF1QjtJQUNoQixJQUFJLEVBQUUsRUFBRSxFQUFFO0lBQ2pCLGtGQUFrRjtJQUMzRSxVQUFVLENBQUM7SUFoQnBCO0lBQ0UsdUNBQXVDO0lBQ2hDLElBQUksRUFBRSxNQUFNO0lBQ25CLDZCQUE2QjtJQUN0QixFQUFFLEVBQUUsWUFBWTtJQUN2QixnQ0FBZ0M7SUFDekIsUUFBUSxFQUFFLGdCQUFnQjtJQUNqQywyQkFBMkI7SUFDcEIsSUFBSSxFQUFFLFlBQVk7SUFDekIscVFBQXFRO0lBQzlQLGFBQWEsRUFBRSxPQUFPO0lBQzdCLCtEQUErRDtJQUN4RCxRQUFRLEVBQUUsT0FBTztJQUN4Qix1QkFBdUI7SUFDaEIsSUFBSSxFQUFFLEVBQUUsRUFBRTtJQUNqQixrRkFBa0Y7SUFDM0UsVUFBVSxDQUFDLHFCQUFTLEVBQ3pCO0lBRUosTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLFlBQVksQ0FBQyxnSEFXOUM7SUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsWUFBWSxDQUFDLEdBQUcsWUFBWSxDQUV4RDtJQUVELE1BQU0sS0FBSyxNQUFNOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztRQWtCaEI7SUFFRDs7O09BR0c7SUFDSSxNQUFNOztNQUVaO0lBRU0sY0FBYyxJQUFJLE9BQU8sQ0FFL0I7SUFFRDs7O09BR0c7SUFDSCxPQUFjLEtBQUssaUJBVWxCO0NBQ0YifQ==

package/dest/abi/function_call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function_call.d.ts","sourceRoot":"","sources":["../../src/abi/function_call.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,KAAK,OAAO,EAAiB,YAAY,EAAyB,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,kDAAkD;AAClD,qBAAa,YAAY;IAErB,uCAAuC;IAChC,IAAI,EAAE,MAAM;IACnB,6BAA6B;IACtB,EAAE,EAAE,YAAY;IACvB,gCAAgC;IACzB,QAAQ,EAAE,gBAAgB;IACjC,2BAA2B;IACpB,IAAI,EAAE,YAAY;IACzB,qQAAqQ;IAC9P,aAAa,EAAE,OAAO;IAC7B,+DAA+D;IACxD,QAAQ,EAAE,OAAO;IACxB,uBAAuB;IAChB,IAAI,EAAE,EAAE,EAAE;IACjB,kFAAkF;IAC3E,UAAU,CAAC;IAhBpB;IACE,uCAAuC;IAChC,IAAI,EAAE,MAAM;IACnB,6BAA6B;IACtB,EAAE,EAAE,YAAY;IACvB,gCAAgC;IACzB,QAAQ,EAAE,gBAAgB;IACjC,2BAA2B;IACpB,IAAI,EAAE,YAAY;IACzB,qQAAqQ;IAC9P,aAAa,EAAE,OAAO;IAC7B,+DAA+D;IACxD,QAAQ,EAAE,OAAO;IACxB,uBAAuB;IAChB,IAAI,EAAE,EAAE,EAAE;IACjB,kFAAkF;IAC3E,UAAU,CAAC,qBAAS,EACzB;IAEJ,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,gHAW9C;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,YAAY,CAExD;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;QAkBhB;IAED;;;OAGG;IACI,MAAM;;MAEZ;IAEM,cAAc,IAAI,OAAO,CAE/B;IAED;;;OAGG;IACH,OAAc,KAAK,iBAUlB;CACF"}

package/dest/abi/function_call.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/index.js';
+import { AbiTypeSchema, FunctionType, getFunctionReturnType } from './abi.js';
+import { FunctionSelector } from './function_selector.js';
+/** A request to call a function on a contract. */ export class FunctionCall {
+    name;
+    to;
+    selector;
+    type;
+    hideMsgSender;
+    isStatic;
+    args;
+    returnType;
+    constructor(/** The name of the function to call */ name, /** The recipient contract */ to, /** The function being called */ selector, /** Type of the function */ type, /** Only applicable for enqueued public function calls. `hideMsgSender = true` will set the msg_sender field (the caller's address) to "null", meaning the public function (and observers around the world) won't know which smart contract address made the call. */ hideMsgSender, /** Whether this call can make modifications to state or not */ isStatic, /** The encoded args */ args, /** The type the call returns, for decoding, or undefined if it returns nothing */ returnType){
+        this.name = name;
+        this.to = to;
+        this.selector = selector;
+        this.type = type;
+        this.hideMsgSender = hideMsgSender;
+        this.isStatic = isStatic;
+        this.args = args;
+        this.returnType = returnType;
+    }
+    static getFields(fields) {
+        return [
+            fields.name,
+            fields.to,
+            fields.selector,
+            fields.type,
+            fields.hideMsgSender,
+            fields.isStatic,
+            fields.args,
+            fields.returnType
+        ];
+    }
+    static from(fields) {
+        return new FunctionCall(...FunctionCall.getFields(fields));
+    }
+    static get schema() {
+        return z.object({
+            name: z.string(),
+            to: schemas.AztecAddress,
+            selector: schemas.FunctionSelector,
+            type: z.nativeEnum(FunctionType),
+            isStatic: z.boolean(),
+            hideMsgSender: z.boolean(),
+            args: z.array(schemas.Fr),
+            returnType: AbiTypeSchema.optional(),
+            // Old consumers send `returnTypes`, not `returnType`. So we accept both for now, until we can safely remove
+            // the old version.
+            returnTypes: z.array(AbiTypeSchema).optional()
+        }).transform(({ returnType, returnTypes, ...fields })=>FunctionCall.from({
+                ...fields,
+                returnType: getFunctionReturnType({
+                    returnType,
+                    returnTypes
+                })
+            }));
+    }
+    /**
+   * Serializes the deprecated `returnTypes` alongside `returnType`, so that peers that still require the old field can
+   * parse calls sent by this version.
+   */ toJSON() {
+        return {
+            ...this,
+            returnTypes: this.returnType ? [
+                this.returnType
+            ] : []
+        };
+    }
+    isPublicStatic() {
+        return this.type === FunctionType.PUBLIC && this.isStatic;
+    }
+    /**
+   * Creates an empty function call.
+   * @returns an empty function call.
+   */ static empty() {
+        return FunctionCall.from({
+            name: '',
+            to: AztecAddress.ZERO,
+            selector: FunctionSelector.empty(),
+            type: FunctionType.PUBLIC,
+            hideMsgSender: false,
+            isStatic: false,
+            args: []
+        });
+    }
+}

package/dest/abi/function_selector.d.ts

@@ -0,0 +1,61 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type ZodFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { ABIParameter } from './abi.js';
+import { Selector } from './selector.js';
+/** A function selector is the first 4 bytes of the hash of a function signature. */
+export declare class FunctionSelector extends Selector {
+    /** Branding for nominal typing. */
+    private readonly _branding;
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer  or BufferReader to read from.
+     * @returns The Selector.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): FunctionSelector;
+    /**
+     * Converts a field to selector.
+     * @param fr - The field to convert.
+     * @returns The selector.
+     */
+    static fromField(fr: Fr): FunctionSelector;
+    static fromFieldOrUndefined(fr: Fr): FunctionSelector | undefined;
+    static fromFields(fields: Fr[] | FieldReader): FunctionSelector;
+    /**
+     * Creates a selector from a signature.
+     * @param signature - Signature to generate the selector for (e.g. "transfer(field,field)").
+     * @returns selector.
+     */
+    static fromSignature(signature: string): Promise<FunctionSelector>;
+    /**
+     * Create a Selector instance from a hex-encoded string.
+     *
+     * @param selector - The hex-encoded string representing the Selector.
+     * @returns An Selector instance.
+     * @throws If the selector length is invalid.
+     */
+    static fromString(selector: string): FunctionSelector;
+    /**
+     * Creates an empty selector.
+     * @returns An empty selector.
+     */
+    static empty(): FunctionSelector;
+    /**
+     * Creates a function selector for a given function name and parameters.
+     * @param name - The name of the function.
+     * @param parameters - An array of ABIParameter objects, each containing the type information of a function parameter.
+     * @returns A Buffer containing the 4-byte selector.
+     */
+    static fromNameAndParameters(args: {
+        name: string;
+        parameters: ABIParameter[];
+    }): Promise<FunctionSelector>;
+    static fromNameAndParameters(name: string, parameters: ABIParameter[]): Promise<FunctionSelector>;
+    /**
+     * Creates a random instance.
+     */
+    static random(): FunctionSelector;
+    toJSON(): string;
+    static get schema(): ZodFor<FunctionSelector>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25fc2VsZWN0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hYmkvZnVuY3Rpb25fc2VsZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDOUQsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLGdDQUFnQyxDQUFDO0FBQzNFLE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFN0UsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBRTdDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsb0ZBQW9GO0FBQ3BGLHFCQUFhLGdCQUFpQixTQUFRLFFBQVE7SUFDNUMsbUNBQW1DO0lBQ25DLGlCQUF5QixTQUFTLENBQXFCO0lBQ3ZEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxvQkFJOUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFNBQVMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxvQkFFdEI7SUFFRCxNQUFNLENBQUMsb0JBQW9CLENBQUMsRUFBRSxFQUFFLEVBQUUsZ0NBTWpDO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxvQkFHM0M7SUFFRDs7OztPQUlHO0lBQ0gsT0FBYSxhQUFhLENBQUMsU0FBUyxFQUFFLE1BQU0sNkJBUzNDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsTUFBTSxvQkFNakM7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsS0FBSyxxQkFFWDtJQUVEOzs7OztPQUtHO0lBQ0gsTUFBTSxDQUFDLHFCQUFxQixDQUFDLElBQUksRUFBRTtRQUFFLElBQUksRUFBRSxNQUFNLENBQUM7UUFBQyxVQUFVLEVBQUUsWUFBWSxFQUFFLENBQUE7S0FBRSxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQzVHLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQWNsRzs7T0FFRztJQUNILE1BQU0sQ0FBQyxNQUFNLHFCQUVaO0lBRUQsTUFBTSxXQUVMO0lBRUQsTUFBTSxLQUFLLE1BQU0sSUFBSSxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FFNUM7Q0FDRiJ9