@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/abi/decoder.js

@@ -0,0 +1,170 @@
+import { AztecAddress } from '../aztec-address/index.js';
+import { isAztecAddressStruct, parseSignedInt } from './utils.js';
+/**
+ * Decodes values using a provided ABI.
+ */ class AbiDecoder {
+    types;
+    flattened;
+    constructor(types, flattened){
+        this.types = types;
+        this.flattened = flattened;
+    }
+    /**
+   * Decodes a single return value from field to the given type.
+   * @param abiType - The type of the return value.
+   * @returns The decoded return value.
+   */ decodeNext(abiType) {
+        switch(abiType.kind){
+            case 'field':
+                return this.getNextField().toBigInt();
+            case 'integer':
+                {
+                    const nextField = this.getNextField();
+                    if (abiType.sign === 'signed') {
+                        // We parse the buffer using 2's complement
+                        return parseSignedInt(nextField.toBuffer(), abiType.width);
+                    }
+                    return nextField.toBigInt();
+                }
+            case 'boolean':
+                return !this.getNextField().isZero();
+            case 'array':
+                {
+                    const array = [];
+                    for(let i = 0; i < abiType.length; i += 1){
+                        array.push(this.decodeNext(abiType.type));
+                    }
+                    return array;
+                }
+            case 'struct':
+                {
+                    const struct = {};
+                    if (isAztecAddressStruct(abiType)) {
+                        return new AztecAddress(this.getNextField().toBuffer());
+                    }
+                    for (const field of abiType.fields){
+                        struct[field.name] = this.decodeNext(field.type);
+                    }
+                    return struct;
+                }
+            case 'string':
+                {
+                    const array = [];
+                    for(let i = 0; i < abiType.length; i += 1){
+                        array.push(this.getNextField().toBigInt());
+                    }
+                    return array;
+                }
+            case 'tuple':
+                {
+                    const array = [];
+                    for (const tupleAbiType of abiType.fields){
+                        array.push(this.decodeNext(tupleAbiType));
+                    }
+                    return array;
+                }
+            default:
+                throw new Error(`Unsupported type: ${abiType}`);
+        }
+    }
+    /**
+   * Gets the next field in the flattened buffer.
+   * @returns The next field in the flattened buffer.
+   */ getNextField() {
+        const field = this.flattened.shift();
+        if (!field) {
+            throw new Error('Not enough return values');
+        }
+        return field;
+    }
+    /**
+   * Decodes all the values for the given ABI.
+   * The decided value can be simple types, structs or arrays
+   * @returns The decoded return values.
+   */ decode() {
+        if (this.types.length > 1) {
+            throw new Error('Multiple types not supported');
+        }
+        if (this.types.length === 0) {
+            return [];
+        }
+        return this.decodeNext(this.types[0]);
+    }
+}
+/**
+ * Decodes values in a flattened Field array using a provided ABI.
+ * @param abi - The ABI to use as reference.
+ * @param buffer - The flattened Field array to decode.
+ * @returns
+ */ export function decodeFromAbi(typ, buffer) {
+    return new AbiDecoder(typ, buffer.slice()).decode();
+}
+/**
+ * Decodes the signature of a function from the name and parameters.
+ */ export class FunctionSignatureDecoder {
+    name;
+    parameters;
+    includeNames;
+    separator;
+    constructor(name, parameters, includeNames = false){
+        this.name = name;
+        this.parameters = parameters;
+        this.includeNames = includeNames;
+        this.separator = includeNames ? ', ' : ',';
+    }
+    /**
+   * Decodes a single function parameter type for the function signature.
+   * @param param - The parameter type to decode.
+   * @returns A string representing the parameter type.
+   */ getParameterType(param) {
+        switch(param.kind){
+            case 'field':
+                return 'Field';
+            case 'integer':
+                if (param.sign === 'signed') {
+                    throw new Error('Unsupported type: signed integer');
+                }
+                return `u${param.width}`;
+            case 'boolean':
+                return 'bool';
+            case 'array':
+                return `[${this.getParameterType(param.type)};${param.length}]`;
+            case 'string':
+                return `str<${param.length}>`;
+            case 'struct':
+                return `(${param.fields.map((field)=>`${this.decodeParameter(field)}`).join(this.separator)})`;
+            default:
+                throw new Error(`Unsupported type: ${param}`);
+        }
+    }
+    /**
+   * Decodes a single function parameter for the function signature.
+   * @param param - The parameter to decode.
+   * @returns A string representing the parameter type and optionally its name.
+   */ decodeParameter(param) {
+        const type = this.getParameterType(param.type);
+        return this.includeNames ? `${param.name}: ${type}` : type;
+    }
+    /**
+   * Decodes all the parameters and build the function signature
+   * @returns The function signature.
+   */ decode() {
+        return `${this.name}(${this.parameters.map((param)=>this.decodeParameter(param)).join(this.separator)})`;
+    }
+}
+/**
+ * Decodes a function signature from the name and parameters.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The function signature.
+ */ export function decodeFunctionSignature(name, parameters) {
+    return new FunctionSignatureDecoder(name, parameters).decode();
+}
+/**
+ * Decodes a function signature from the name and parameters including parameter names.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The user-friendly function signature.
+ */ export function decodeFunctionSignatureWithParameterNames(name, parameters) {
+    return new FunctionSignatureDecoder(name, parameters, true).decode();
+}

package/dest/abi/encoder.d.ts

@@ -0,0 +1,16 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { FunctionAbi } from './abi.js';
+/**
+ * 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 declare function encodeArguments(abi: FunctionAbi, args: any[]): Fr[];
+/**
+ * Returns the size of the arguments for a function ABI.
+ * @param abi - The function ABI entry.
+ * @returns The size of the arguments.
+ */
+export declare function countArgumentsSize(abi: FunctionAbi): number;
+//# sourceMappingURL=encoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../src/abi/encoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,UAAU,CAAC;AA6IrD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,EAAE,QAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,WAAW,UAElD"}

package/dest/abi/encoder.js

@@ -0,0 +1,164 @@
+import { Fr } from '@aztec/foundation/fields';
+import { isAddressStruct, isFunctionSelectorStruct, 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 (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':
+                for(let i = 0; i < abiType.length; i += 1){
+                    this.encodeArgument(abiType.type, arg[i], `${name}[${i}]`);
+                }
+                break;
+            case 'string':
+                for(let i = 0; i < abiType.length; i += 1){
+                    // If the string is shorter than the defined length, pad it with 0s.
+                    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;
+                    }
+                    for (const field of abiType.fields){
+                        this.encodeArgument(field.type, arg[field.name], `${name}.${field.name}`);
+                    }
+                    break;
+                }
+            case 'integer':
+                if (typeof arg === 'string') {
+                    const value = BigInt(arg);
+                    this.flattened.push(new Fr(value));
+                } else {
+                    this.flattened.push(new Fr(arg));
+                }
+                break;
+            default:
+                throw new Error(`Unsupported type: ${abiType}`);
+        }
+    }
+    /**
+   * Encodes all the arguments for the given function ABI.
+   * @returns The encoded arguments.
+   */ encode() {
+        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 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_selector.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { Selector } from './selector.js';
+/** Event selector branding */
+export interface EventSelector {
+    /** Brand. */
+    _branding: 'EventSelector';
+}
+/** An event selector is the first 4 bytes of the hash of an event signature. */
+export declare 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: 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, any, string>;
+}
+//# sourceMappingURL=event_selector.d.ts.map

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":";;AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,8BAA8B;AAC9B,MAAM,WAAW,aAAa;IAC5B,aAAa;IACb,SAAS,EAAE,eAAe,CAAC;CAC5B;AAED,gFAAgF;AAChF,qBAAa,aAAc,SAAQ,QAAQ;IACzC;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAM/C;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE;IAIvB;;;;OAIG;WACU,aAAa,CAAC,SAAS,EAAE,MAAM;IAW5C;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM;IAQlC;;;OAGG;IACH,MAAM,CAAC,KAAK;IAIZ;;;OAGG;IACH,MAAM,CAAC,MAAM;IAIb,MAAM;IAIN,MAAM,KAAK,MAAM,sDAEhB;CACF"}

package/dest/abi/event_selector.js

@@ -0,0 +1,68 @@
+import { fromHex, toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { poseidon2HashBytes, randomBytes } from '@aztec/foundation/crypto';
+import { hexSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/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,53 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
+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 from a given address. */
+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;
+    /** Whether this call can make modifications to state or not */
+    isStatic: boolean;
+    /** The encoded args */
+    args: Fr[];
+    /** The return type for decoding */
+    returnTypes: AbiType[];
+    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, 
+    /** Whether this call can make modifications to state or not */
+    isStatic: boolean, 
+    /** The encoded args */
+    args: Fr[], 
+    /** The return type for decoding */
+    returnTypes: AbiType[]);
+    static getFields(fields: FieldsOf<FunctionCall>): readonly [string, AztecAddress, FunctionSelector, FunctionType, boolean, Fr[], AbiType[]];
+    static from(fields: FieldsOf<FunctionCall>): FunctionCall;
+    /**
+     * Creates an empty function call.
+     * @returns an empty function call.
+     */
+    static empty(): {
+        name: string;
+        to: AztecAddress;
+        selector: FunctionSelector;
+        type: FunctionType;
+        isStatic: boolean;
+        args: never[];
+        returnTypes: never[];
+    };
+}
+//# sourceMappingURL=function_call.d.ts.map

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,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,KAAK,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,uEAAuE;AACvE,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,+DAA+D;IACxD,QAAQ,EAAE,OAAO;IACxB,uBAAuB;IAChB,IAAI,EAAE,EAAE,EAAE;IACjB,mCAAmC;IAC5B,WAAW,EAAE,OAAO,EAAE;;IAb7B,uCAAuC;IAChC,IAAI,EAAE,MAAM;IACnB,6BAA6B;IACtB,EAAE,EAAE,YAAY;IACvB,gCAAgC;IACzB,QAAQ,EAAE,gBAAgB;IACjC,2BAA2B;IACpB,IAAI,EAAE,YAAY;IACzB,+DAA+D;IACxD,QAAQ,EAAE,OAAO;IACxB,uBAAuB;IAChB,IAAI,EAAE,EAAE,EAAE;IACjB,mCAAmC;IAC5B,WAAW,EAAE,OAAO,EAAE;IAG/B,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC;IAY/C,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,YAAY;IAIzD;;;OAGG;WACW,KAAK;;;;;;;;;CAWpB"}

package/dest/abi/function_call.js

@@ -0,0 +1,49 @@
+import { AztecAddress } from '../aztec-address/index.js';
+import { FunctionType } from './abi.js';
+import { FunctionSelector } from './function_selector.js';
+/** A request to call a function on a contract from a given address. */ export class FunctionCall {
+    name;
+    to;
+    selector;
+    type;
+    isStatic;
+    args;
+    returnTypes;
+    constructor(/** The name of the function to call */ name, /** The recipient contract */ to, /** The function being called */ selector, /** Type of the function */ type, /** Whether this call can make modifications to state or not */ isStatic, /** The encoded args */ args, /** The return type for decoding */ returnTypes){
+        this.name = name;
+        this.to = to;
+        this.selector = selector;
+        this.type = type;
+        this.isStatic = isStatic;
+        this.args = args;
+        this.returnTypes = returnTypes;
+    }
+    static getFields(fields) {
+        return [
+            fields.name,
+            fields.to,
+            fields.selector,
+            fields.type,
+            fields.isStatic,
+            fields.args,
+            fields.returnTypes
+        ];
+    }
+    static from(fields) {
+        return new FunctionCall(...FunctionCall.getFields(fields));
+    }
+    /**
+   * Creates an empty function call.
+   * @returns an empty function call.
+   */ static empty() {
+        return {
+            name: '',
+            to: AztecAddress.ZERO,
+            selector: FunctionSelector.empty(),
+            type: FunctionType.PUBLIC,
+            isStatic: false,
+            args: [],
+            returnTypes: []
+        };
+    }
+}

package/dest/abi/function_selector.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import type { ABIParameter } from './abi.js';
+import { Selector } from './selector.js';
+/** Function selector branding */
+export interface FunctionSelector {
+    /** Brand. */
+    _branding: 'FunctionSelector';
+}
+/** A function selector is the first 4 bytes of the hash of a function signature. */
+export declare class FunctionSelector 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: Buffer | BufferReader): FunctionSelector;
+    /**
+     * Converts a field to selector.
+     * @param fr - The field to convert.
+     * @returns The selector.
+     */
+    static fromField(fr: Fr): FunctionSelector;
+    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=function_selector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"function_selector.d.ts","sourceRoot":"","sources":["../../src/abi/function_selector.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAgB,MAAM,6BAA6B,CAAC;AAEtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,iCAAiC;AACjC,MAAM,WAAW,gBAAgB;IAC/B,aAAa;IACb,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED,oFAAoF;AACpF,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAM/C;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE;IAIvB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C;;;;OAIG;WACU,aAAa,CAAC,SAAS,EAAE,MAAM;IAW5C;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM;IAQlC;;;OAGG;IACH,MAAM,CAAC,KAAK;IAIZ;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,YAAY,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAC3G,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAcjG;;OAEG;IACH,MAAM,CAAC,MAAM;IAIb,MAAM;IAIN,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE5C;CACF"}