@aztec/stdlib 0.77.0-testnet-ignition.17

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

@@ -0,0 +1 @@
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../src/abi/abi.ts"],"names":[],"mappings":"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"}

package/dest/abi/abi.js

@@ -0,0 +1,279 @@
+/* eslint-disable camelcase */ import { createLogger } from '@aztec/foundation/log';
+import { schemas } from '@aztec/foundation/schemas';
+import { inflate } from 'pako';
+import { z } from 'zod';
+import { FunctionSelector } from './function_selector.js';
+import { NoteSelector } from './note_selector.js';
+const logger = createLogger('aztec:foundation:abi');
+export const AbiValueSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('boolean'),
+        value: z.boolean()
+    }),
+    z.object({
+        kind: z.literal('string'),
+        value: z.string()
+    }),
+    z.object({
+        kind: z.literal('array'),
+        value: z.array(z.lazy(()=>AbiValueSchema))
+    }),
+    z.object({
+        kind: z.literal('tuple'),
+        fields: z.array(z.lazy(()=>AbiValueSchema))
+    }),
+    z.object({
+        kind: z.literal('integer'),
+        value: z.string(),
+        sign: z.boolean()
+    }),
+    z.object({
+        kind: z.literal('struct'),
+        fields: z.array(z.object({
+            name: z.string(),
+            value: z.lazy(()=>AbiValueSchema)
+        }))
+    })
+]);
+/** Indicates whether a parameter is public or secret/private. */ export const ABIParameterVisibility = [
+    'public',
+    'private',
+    'databus'
+];
+/** Sign for numeric types. */ const Sign = [
+    'unsigned',
+    'signed'
+];
+export const AbiTypeSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('field')
+    }),
+    z.object({
+        kind: z.literal('boolean')
+    }),
+    z.object({
+        kind: z.literal('integer'),
+        sign: z.enum(Sign),
+        width: z.number()
+    }),
+    z.object({
+        kind: z.literal('array'),
+        length: z.number(),
+        type: z.lazy(()=>AbiTypeSchema)
+    }),
+    z.object({
+        kind: z.literal('string'),
+        length: z.number()
+    }),
+    z.object({
+        kind: z.literal('struct'),
+        fields: z.array(z.lazy(()=>ABIVariableSchema)),
+        path: z.string()
+    }),
+    z.object({
+        kind: z.literal('tuple'),
+        fields: z.array(z.lazy(()=>AbiTypeSchema))
+    })
+]);
+/** A named type. */ export const ABIVariableSchema = z.object({
+    /** The name of the variable. */ name: z.string(),
+    /** The type of the variable. */ type: AbiTypeSchema
+});
+/** A function parameter. */ export const ABIParameterSchema = ABIVariableSchema.and(z.object({
+    /** Visibility of the parameter in the function. */ visibility: z.enum(ABIParameterVisibility)
+}));
+const AbiErrorTypeSchema = z.union([
+    z.object({
+        error_kind: z.literal('string'),
+        string: z.string()
+    }),
+    z.object({
+        error_kind: z.literal('fmtstring'),
+        length: z.number(),
+        item_types: z.array(AbiTypeSchema)
+    }),
+    z.object({
+        error_kind: z.literal('custom')
+    }).and(AbiTypeSchema)
+]);
+/** Aztec.nr function types. */ export var FunctionType = /*#__PURE__*/ function(FunctionType) {
+    FunctionType["PRIVATE"] = "private";
+    FunctionType["PUBLIC"] = "public";
+    FunctionType["UNCONSTRAINED"] = "unconstrained";
+    return FunctionType;
+}({});
+export const FunctionAbiSchema = z.object({
+    name: z.string(),
+    functionType: z.nativeEnum(FunctionType),
+    isInternal: z.boolean(),
+    isStatic: z.boolean(),
+    isInitializer: z.boolean(),
+    parameters: z.array(z.object({
+        name: z.string(),
+        type: AbiTypeSchema,
+        visibility: z.enum(ABIParameterVisibility)
+    })),
+    returnTypes: z.array(AbiTypeSchema),
+    errorTypes: z.record(AbiErrorTypeSchema)
+});
+export const FunctionDebugMetadataSchema = z.object({
+    debugSymbols: z.object({
+        locations: z.record(z.array(z.object({
+            span: z.object({
+                start: z.number(),
+                end: z.number()
+            }),
+            file: z.number()
+        }))),
+        brillig_locations: z.record(z.record(z.array(z.object({
+            span: z.object({
+                start: z.number(),
+                end: z.number()
+            }),
+            file: z.number()
+        }))))
+    }),
+    files: z.record(z.object({
+        source: z.string(),
+        path: z.string()
+    }))
+});
+export const FunctionArtifactSchema = FunctionAbiSchema.and(z.object({
+    bytecode: schemas.Buffer,
+    verificationKey: z.string().optional(),
+    debugSymbols: z.string(),
+    debug: FunctionDebugMetadataSchema.optional()
+}));
+export const NoteFieldSchema = z.object({
+    name: z.string(),
+    index: z.number(),
+    nullable: z.boolean()
+});
+export const ContractNoteSchema = z.object({
+    id: NoteSelector.schema,
+    typ: z.string(),
+    fields: z.array(NoteFieldSchema)
+});
+export const ContractArtifactSchema = z.object({
+    name: z.string(),
+    aztecNrVersion: z.string().optional(),
+    functions: z.array(FunctionArtifactSchema),
+    outputs: z.object({
+        structs: z.record(z.array(AbiTypeSchema)).transform((structs)=>{
+            for (const [key, value] of Object.entries(structs)){
+                // We are manually ordering events and functions in the abi by path.
+                // The path ordering is arbitrary, and only needed to ensure deterministic order.
+                // These are the only arrays in the artifact with arbitrary order, and hence the only ones
+                // we need to sort.
+                if (key === 'events' || key === 'functions') {
+                    structs[key] = value.sort((a, b)=>a.path > b.path ? -1 : 1);
+                }
+            }
+            return structs;
+        }),
+        globals: z.record(z.array(AbiValueSchema))
+    }),
+    storageLayout: z.record(z.object({
+        slot: schemas.Fr
+    })),
+    notes: z.record(ContractNoteSchema),
+    fileMap: z.record(z.coerce.number(), z.object({
+        source: z.string(),
+        path: z.string()
+    }))
+});
+export function getFunctionArtifactByName(artifact, functionName) {
+    const functionArtifact = artifact.functions.find((f)=>f.name === functionName);
+    if (!functionArtifact) {
+        throw new Error(`Unknown function ${functionName}`);
+    }
+    const debugMetadata = getFunctionDebugMetadata(artifact, functionArtifact);
+    return {
+        ...functionArtifact,
+        debug: debugMetadata
+    };
+}
+/** Gets a function artifact including debug metadata given its name or selector. */ export async function getFunctionArtifact(artifact, functionNameOrSelector) {
+    let functionArtifact;
+    if (typeof functionNameOrSelector === 'string') {
+        functionArtifact = artifact.functions.find((f)=>f.name === functionNameOrSelector);
+    } else {
+        const functionsAndSelectors = await Promise.all(artifact.functions.map(async (fn)=>({
+                fn,
+                selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)
+            })));
+        functionArtifact = functionsAndSelectors.find((fnAndSelector)=>functionNameOrSelector.equals(fnAndSelector.selector))?.fn;
+    }
+    if (!functionArtifact) {
+        throw new Error(`Unknown function ${functionNameOrSelector}`);
+    }
+    const debugMetadata = getFunctionDebugMetadata(artifact, functionArtifact);
+    return {
+        ...functionArtifact,
+        debug: debugMetadata
+    };
+}
+/**
+ * Gets the debug metadata of a given function from the contract artifact
+ * @param artifact - The contract build artifact
+ * @param functionName - The name of the function
+ * @returns The debug metadata of the function
+ */ export function getFunctionDebugMetadata(contractArtifact, functionArtifact) {
+    try {
+        if (functionArtifact.debugSymbols && contractArtifact.fileMap) {
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/10546) investigate why debugMetadata is so big for some tests.
+            const programDebugSymbols = JSON.parse(inflate(Buffer.from(functionArtifact.debugSymbols, 'base64'), {
+                to: 'string',
+                raw: true
+            }));
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
+            // We only support handling debug info for the contract function entry point.
+            // So for now we simply index into the first debug info.
+            return {
+                debugSymbols: programDebugSymbols.debug_infos[0],
+                files: contractArtifact.fileMap
+            };
+        }
+    } catch (err) {
+        if (err instanceof RangeError && err.message.includes('Invalid string length')) {
+            logger.warn(`Caught RangeError: Invalid string length. This suggests the debug_symbols field of the contract ${contractArtifact.name} and function ${functionArtifact.name} is huge; too big to parse. We'll skip returning this info until this issue is resolved. Here's the error:\n${err.message}`);
+        // We'll return undefined.
+        } else {
+            // Rethrow unexpected errors
+            throw err;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns an initializer from the contract, assuming there is at least one. If there are multiple initializers,
+ * it returns the one named "constructor" or "initializer"; if there is none with that name, it returns the first
+ * initializer it finds, prioritizing initializers with no arguments and then private ones.
+ * @param contractArtifact - The contract artifact.
+ * @returns An initializer function, or none if there are no functions flagged as initializers in the contract.
+ */ export function getDefaultInitializer(contractArtifact) {
+    const initializers = contractArtifact.functions.filter((f)=>f.isInitializer);
+    return initializers.length > 1 ? initializers.find((f)=>f.name === 'constructor') ?? initializers.find((f)=>f.name === 'initializer') ?? initializers.find((f)=>f.parameters?.length === 0) ?? initializers.find((f)=>f.functionType === "private") ?? initializers[0] : initializers[0];
+}
+/**
+ * Returns an initializer from the contract.
+ * @param initializerNameOrArtifact - The name of the constructor, or the artifact of the constructor, or undefined
+ * to pick the default initializer.
+ */ export function getInitializer(contract, initializerNameOrArtifact) {
+    if (typeof initializerNameOrArtifact === 'string') {
+        const found = contract.functions.find((f)=>f.name === initializerNameOrArtifact);
+        if (!found) {
+            throw new Error(`Constructor method ${initializerNameOrArtifact} not found in contract artifact`);
+        } else if (!found.isInitializer) {
+            throw new Error(`Method ${initializerNameOrArtifact} is not an initializer`);
+        }
+        return found;
+    } else if (initializerNameOrArtifact === undefined) {
+        return getDefaultInitializer(contract);
+    } else {
+        if (!initializerNameOrArtifact.isInitializer) {
+            throw new Error(`Method ${initializerNameOrArtifact.name} is not an initializer`);
+        }
+        return initializerNameOrArtifact;
+    }
+}

package/dest/abi/buffer.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * Formats a buffer as an array of fields. Splits the input into 31-byte chunks, and stores each
+ * of them into a field, omitting the field's first byte, then adds zero-fields at the end until the max length.
+ * @param input - Input to format.
+ * @param targetLength - Length of the target array in number of fields.
+ * @returns A field with the total length in bytes, followed by an array of fields such that their concatenation is equal to the input buffer, followed by enough zeroes to reach targetLength.
+ */
+export declare function bufferAsFields(input: Buffer, targetLength: number): Fr[];
+/**
+ * Recovers a buffer from an array of fields.
+ * @param fields - An output from bufferAsFields.
+ * @returns The recovered buffer.
+ */
+export declare function bufferFromFields(fields: Fr[]): Buffer;
+//# sourceMappingURL=buffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../src/abi/buffer.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,EAAE,EAAE,CAcxE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,CAGrD"}

package/dest/abi/buffer.js

@@ -0,0 +1,34 @@
+import { Fr } from '@aztec/foundation/fields';
+import chunk from 'lodash.chunk';
+/**
+ * Formats a buffer as an array of fields. Splits the input into 31-byte chunks, and stores each
+ * of them into a field, omitting the field's first byte, then adds zero-fields at the end until the max length.
+ * @param input - Input to format.
+ * @param targetLength - Length of the target array in number of fields.
+ * @returns A field with the total length in bytes, followed by an array of fields such that their concatenation is equal to the input buffer, followed by enough zeroes to reach targetLength.
+ */ export function bufferAsFields(input, targetLength) {
+    const encoded = [
+        new Fr(input.length),
+        ...chunk(input, Fr.SIZE_IN_BYTES - 1).map((c)=>{
+            const fieldBytes = Buffer.alloc(Fr.SIZE_IN_BYTES);
+            Buffer.from(c).copy(fieldBytes, 1);
+            return Fr.fromBuffer(fieldBytes);
+        })
+    ];
+    if (encoded.length > targetLength) {
+        throw new Error(`Input buffer exceeds maximum size: got ${encoded.length} but max is ${targetLength}`);
+    }
+    // Fun fact: we cannot use padArrayEnd here since typescript cannot deal with a Tuple this big
+    return [
+        ...encoded,
+        ...Array(targetLength - encoded.length).fill(Fr.ZERO)
+    ];
+}
+/**
+ * Recovers a buffer from an array of fields.
+ * @param fields - An output from bufferAsFields.
+ * @returns The recovered buffer.
+ */ export function bufferFromFields(fields) {
+    const [length, ...payload] = fields;
+    return Buffer.concat(payload.map((f)=>f.toBuffer().subarray(1))).subarray(0, length.toNumber());
+}

package/dest/abi/contract_artifact.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type ContractArtifact } from '../abi/index.js';
+import { type NoirCompiledContract } from '../noir/index.js';
+/**
+ * Serializes a contract artifact to a buffer for storage.
+ * @param artifact - Artifact to serialize.
+ * @returns A buffer.
+ */
+export declare function contractArtifactToBuffer(artifact: ContractArtifact): Buffer;
+/**
+ * Deserializes a contract artifact from storage.
+ * @param buffer - Buffer to deserialize.
+ * @returns Deserialized artifact.
+ */
+export declare function contractArtifactFromBuffer(buffer: Buffer): Promise<ContractArtifact>;
+/**
+ * Gets nargo build output and returns a valid contract artifact instance.
+ * @param input - Input object as generated by nargo compile.
+ * @returns A valid contract artifact instance.
+ */
+export declare function loadContractArtifact(input: NoirCompiledContract): ContractArtifact;
+//# sourceMappingURL=contract_artifact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_artifact.d.ts","sourceRoot":"","sources":["../../src/abi/contract_artifact.ts"],"names":[],"mappings":";;AAEA,OAAO,EAKL,KAAK,gBAAgB,EAStB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAML,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAC;AAE1B;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAEpF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,oBAAoB,GAAG,gBAAgB,CAKlF"}

package/dest/abi/contract_artifact.js

@@ -0,0 +1,233 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { ContractArtifactSchema, FunctionType } from '../abi/index.js';
+import { AZTEC_INITIALIZER_ATTRIBUTE, AZTEC_INTERNAL_ATTRIBUTE, AZTEC_PRIVATE_ATTRIBUTE, AZTEC_PUBLIC_ATTRIBUTE, AZTEC_VIEW_ATTRIBUTE } from '../noir/index.js';
+/**
+ * Serializes a contract artifact to a buffer for storage.
+ * @param artifact - Artifact to serialize.
+ * @returns A buffer.
+ */ export function contractArtifactToBuffer(artifact) {
+    return Buffer.from(jsonStringify(artifact), 'utf-8');
+}
+/**
+ * Deserializes a contract artifact from storage.
+ * @param buffer - Buffer to deserialize.
+ * @returns Deserialized artifact.
+ */ export function contractArtifactFromBuffer(buffer) {
+    return jsonParseWithSchema(buffer.toString('utf-8'), ContractArtifactSchema);
+}
+/**
+ * Gets nargo build output and returns a valid contract artifact instance.
+ * @param input - Input object as generated by nargo compile.
+ * @returns A valid contract artifact instance.
+ */ export function loadContractArtifact(input) {
+    if (isContractArtifact(input)) {
+        return input;
+    }
+    return generateContractArtifact(input);
+}
+/**
+ * Checks if the given input looks like a valid ContractArtifact. The check is not exhaustive,
+ * and it's just meant to differentiate between nargo raw build artifacts and the ones
+ * produced by this compiler.
+ * @param input - Input object.
+ * @returns True if it looks like a ContractArtifact.
+ */ function isContractArtifact(input) {
+    if (typeof input !== 'object') {
+        return false;
+    }
+    const maybeContractArtifact = input;
+    if (typeof maybeContractArtifact.name !== 'string') {
+        return false;
+    }
+    if (!Array.isArray(maybeContractArtifact.functions)) {
+        return false;
+    }
+    for (const fn of maybeContractArtifact.functions){
+        if (typeof fn.name !== 'string') {
+            return false;
+        }
+        if (typeof fn.functionType !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Generates a function parameter out of one generated by a nargo build.
+ * @param param - Noir parameter.
+ * @returns A function parameter.
+ */ function generateFunctionParameter(param) {
+    const { visibility } = param;
+    if (visibility === 'databus') {
+        throw new Error(`Unsupported visibility ${param.visibility} for noir contract function parameter ${param.name}.`);
+    }
+    return {
+        ...param,
+        visibility: visibility
+    };
+}
+/**
+ * Generates a function build artifact.
+ * @param fn - Noir function entry.
+ * @param contract - Parent contract.
+ * @returns Function artifact.
+ */ function generateFunctionArtifact(fn, contract) {
+    if (fn.custom_attributes === undefined) {
+        throw new Error(`No custom attributes found for contract function ${fn.name}. Try rebuilding the contract with the latest nargo version.`);
+    }
+    const functionType = getFunctionType(fn);
+    const isInternal = fn.custom_attributes.includes(AZTEC_INTERNAL_ATTRIBUTE);
+    const isStatic = fn.custom_attributes.includes(AZTEC_VIEW_ATTRIBUTE);
+    // If the function is not unconstrained, the first item is inputs or CallContext which we should omit
+    let parameters = fn.abi.parameters.map(generateFunctionParameter);
+    if (hasKernelFunctionInputs(parameters)) {
+        parameters = parameters.slice(1);
+    }
+    let returnTypes = [];
+    if (functionType === FunctionType.UNCONSTRAINED) {
+        returnTypes = fn.abi.return_type ? [
+            fn.abi.return_type.abi_type
+        ] : returnTypes;
+    } else {
+        const pathToFind = `${contract.name}::${fn.name}_abi`;
+        const abiStructs = contract.outputs.structs['functions'];
+        const returnStruct = abiStructs.find((a)=>a.kind === 'struct' && a.path === pathToFind);
+        if (returnStruct) {
+            if (returnStruct.kind !== 'struct') {
+                throw new Error('Could not generate contract function artifact');
+            }
+            const returnTypeField = returnStruct.fields.find((field)=>field.name === 'return_type');
+            if (returnTypeField) {
+                returnTypes = [
+                    returnTypeField.type
+                ];
+            }
+        }
+    }
+    return {
+        name: fn.name,
+        functionType,
+        isInternal,
+        isStatic,
+        isInitializer: fn.custom_attributes.includes(AZTEC_INITIALIZER_ATTRIBUTE),
+        parameters,
+        returnTypes,
+        bytecode: fn.bytecode,
+        debugSymbols: fn.debug_symbols,
+        errorTypes: fn.abi.error_types,
+        ...fn.assert_messages ? {
+            assertMessages: fn.assert_messages
+        } : undefined,
+        ...fn.verification_key ? {
+            verificationKey: fn.verification_key
+        } : undefined
+    };
+}
+function getFunctionType(fn) {
+    if (fn.custom_attributes.includes(AZTEC_PRIVATE_ATTRIBUTE)) {
+        return FunctionType.PRIVATE;
+    } else if (fn.custom_attributes.includes(AZTEC_PUBLIC_ATTRIBUTE)) {
+        return FunctionType.PUBLIC;
+    } else if (fn.is_unconstrained) {
+        return FunctionType.UNCONSTRAINED;
+    } else {
+        // Default to a private function (see simple_macro_example_expanded for an example of this behavior)
+        return FunctionType.PRIVATE;
+    }
+}
+/**
+ * Returns true if the first parameter is kernel function inputs.
+ *
+ * Noir macros #[aztec(private|public)] inject the following code
+ * fn <name>(inputs: <Public|Private>ContextInputs, ...otherparams) {}
+ *
+ * Return true if this injected parameter is found
+ */ function hasKernelFunctionInputs(params) {
+    const firstParam = params[0];
+    return firstParam?.type.kind === 'struct' && firstParam.type.path.includes('ContextInputs');
+}
+/**
+ * Generates a storage layout for the contract artifact.
+ * @param input - The compiled noir contract to get storage layout for
+ * @returns A storage layout for the contract.
+ */ function getStorageLayout(input) {
+    // If another contract is imported by the main contract, its storage layout its going to also show up here.
+    // The layout export includes the contract name, so here we can find the one that belongs to the current one and
+    // ignore the rest.
+    const storageExports = input.outputs.globals.storage ? input.outputs.globals.storage : [];
+    const storageForContract = storageExports.find((storageExport)=>{
+        const contractNameField = storageExport.fields.find((field)=>field.name === 'contract_name')?.value;
+        return contractNameField.value === input.name;
+    });
+    const storageFields = storageForContract ? storageForContract.fields.find((field)=>field.name == 'fields').value.fields : [];
+    if (storageFields.length === 0) {
+        return {};
+    }
+    return storageFields.reduce((acc, field)=>{
+        const name = field.name;
+        const slot = field.value.fields[0].value;
+        acc[name] = {
+            slot: `0x${slot.value}`
+        };
+        return acc;
+    }, {});
+}
+/**
+ * Generates records of the notes with note type ids of the artifact.
+ * @param input - The compiled noir contract to get note types for
+ * @return A record of the note types and their ids
+ */ function getNoteTypes(input) {
+    // The type is useless here as it does not give us any guarantee (e.g. `AbiValue` can be one of many different
+    // types) so we nuke it and later we manually check the values are as we expect.
+    const notes = input.outputs.globals.notes;
+    if (!notes) {
+        return {};
+    }
+    return notes.reduce((acc, note)=>{
+        const noteFields = note.fields;
+        // We find note type id by looking for respective kinds as each of them is unique
+        const rawNoteTypeId = noteFields.find((field)=>field.kind === 'integer');
+        const rawName = noteFields.find((field)=>field.kind === 'string');
+        const rawNoteFields = noteFields.find((field)=>field.kind === 'struct');
+        if (!rawNoteTypeId || !rawName || !rawNoteFields) {
+            throw new Error(`Could not find note type id, name or fields for note ${note}`);
+        }
+        const noteTypeId = rawNoteTypeId.value;
+        const name = rawName.value;
+        // Note type id is encoded as a hex string
+        const fields = rawNoteFields.fields.map((field)=>{
+            return {
+                name: field.name,
+                index: parseInt(field.value.fields[0].value.value, 16),
+                nullable: field.value.fields[1].value.value
+            };
+        });
+        acc[name] = {
+            id: noteTypeId,
+            typ: name,
+            fields
+        };
+        return acc;
+    }, {});
+}
+/**
+ * Given a Nargo output generates an Aztec-compatible contract artifact.
+ * @param compiled - Noir build output.
+ * @returns Aztec contract build artifact.
+ */ function generateContractArtifact(contract, aztecNrVersion) {
+    try {
+        return ContractArtifactSchema.parse({
+            name: contract.name,
+            functions: contract.functions.map((f)=>generateFunctionArtifact(f, contract)),
+            outputs: contract.outputs,
+            storageLayout: getStorageLayout(contract),
+            notes: getNoteTypes(contract),
+            fileMap: contract.file_map,
+            ...aztecNrVersion ? {
+                aztecNrVersion
+            } : {}
+        });
+    } catch (err) {
+        throw new Error(`Could not generate contract artifact for ${contract.name}: ${err}`);
+    }
+}

package/dest/abi/decoder.d.ts

@@ -0,0 +1,58 @@
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { ABIParameter, AbiType } from './abi.js';
+/**
+ * The type of our decoded ABI.
+ */
+export type AbiDecoded = bigint | boolean | AztecAddress | AbiDecoded[] | {
+    [key: string]: AbiDecoded;
+};
+/**
+ * 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 declare function decodeFromAbi(typ: AbiType[], buffer: Fr[]): AbiDecoded;
+/**
+ * Decodes the signature of a function from the name and parameters.
+ */
+export declare class FunctionSignatureDecoder {
+    private name;
+    private parameters;
+    private includeNames;
+    private separator;
+    constructor(name: string, parameters: ABIParameter[], includeNames?: boolean);
+    /**
+     * Decodes a single function parameter type for the function signature.
+     * @param param - The parameter type to decode.
+     * @returns A string representing the parameter type.
+     */
+    private getParameterType;
+    /**
+     * 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.
+     */
+    private decodeParameter;
+    /**
+     * Decodes all the parameters and build the function signature
+     * @returns The function signature.
+     */
+    decode(): string;
+}
+/**
+ * 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 declare function decodeFunctionSignature(name: string, parameters: ABIParameter[]): string;
+/**
+ * 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 declare function decodeFunctionSignatureWithParameterNames(name: string, parameters: ABIParameter[]): string;
+//# sourceMappingURL=decoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../src/abi/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAe,OAAO,EAAE,MAAM,UAAU,CAAC;AAGnE;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,UAAU,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC;AA8FxG;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,cAEzD;AAED;;GAEG;AACH,qBAAa,wBAAwB;IAEvB,OAAO,CAAC,IAAI;IAAU,OAAO,CAAC,UAAU;IAAkB,OAAO,CAAC,YAAY;IAD1F,OAAO,CAAC,SAAS,CAAS;gBACN,IAAI,EAAE,MAAM,EAAU,UAAU,EAAE,YAAY,EAAE,EAAU,YAAY,UAAQ;IAIlG;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAKvB;;;OAGG;IACI,MAAM,IAAI,MAAM;CAGxB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,UAE/E;AAED;;;;;GAKG;AACH,wBAAgB,yCAAyC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,UAEjG"}