@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/tx/profiling.d.ts

@@ -0,0 +1,360 @@
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import type { AbiDecoded } from '../abi/decoder.js';
+import type { AztecNode } from '../interfaces/aztec-node.js';
+import { type PrivateExecutionStep } from '../kernel/private_kernel_prover_output.js';
+export type NodeStats = Partial<Record<keyof AztecNode, {
+    times: number[];
+}>>;
+type FunctionTiming = {
+    functionName: string;
+    time: number;
+    oracles?: Record<string, {
+        times: number[];
+    }>;
+};
+export type ProvingTimings = {
+    sync?: number;
+    proving?: number;
+    perFunction: FunctionTiming[];
+    unaccounted: number;
+    total: number;
+};
+export declare const ProvingTimingsSchema: z.ZodObject<{
+    sync: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    proving: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    perFunction: z.ZodArray<z.ZodObject<{
+        functionName: z.ZodString;
+        time: z.ZodNumber;
+        oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            times: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            times: number[];
+        }, {
+            times: number[];
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }>, "many">;
+    unaccounted: z.ZodNumber;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    sync?: number | undefined;
+    proving?: number | undefined;
+}, {
+    total: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    sync?: number | undefined;
+    proving?: number | undefined;
+}>;
+export interface ProvingStats {
+    timings: ProvingTimings;
+    nodeRPCCalls?: NodeStats;
+}
+export declare const ProvingStatsSchema: z.ZodObject<{
+    timings: z.ZodObject<{
+        sync: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        proving: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        perFunction: z.ZodArray<z.ZodObject<{
+            functionName: z.ZodString;
+            time: z.ZodNumber;
+            oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                times: z.ZodArray<z.ZodNumber, "many">;
+            }, "strip", z.ZodTypeAny, {
+                times: number[];
+            }, {
+                times: number[];
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }>, "many">;
+        unaccounted: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    }, {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    }>;
+    nodeRPCCalls: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        times: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        times: number[];
+    }, {
+        times: number[];
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    timings: {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    };
+    nodeRPCCalls?: Record<string, {
+        times: number[];
+    }> | undefined;
+}, {
+    timings: {
+        total: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        sync?: number | undefined;
+        proving?: number | undefined;
+    };
+    nodeRPCCalls?: Record<string, {
+        times: number[];
+    }> | undefined;
+}>;
+export interface SimulationTimings {
+    sync: number;
+    publicSimulation?: number;
+    validation?: number;
+    perFunction: FunctionTiming[];
+    unaccounted: number;
+    total: number;
+}
+export declare const SimulationTimingsSchema: z.ZodObject<{
+    sync: z.ZodNumber;
+    publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    validation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    perFunction: z.ZodArray<z.ZodObject<{
+        functionName: z.ZodString;
+        time: z.ZodNumber;
+        oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            times: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            times: number[];
+        }, {
+            times: number[];
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }, {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }>, "many">;
+    unaccounted: z.ZodNumber;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    sync: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    validation?: number | undefined;
+    publicSimulation?: number | undefined;
+}, {
+    total: number;
+    sync: number;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    validation?: number | undefined;
+    publicSimulation?: number | undefined;
+}>;
+export interface SimulationStats {
+    timings: SimulationTimings;
+    nodeRPCCalls: NodeStats;
+}
+export declare const SimulationStatsSchema: z.ZodObject<{
+    timings: z.ZodObject<{
+        sync: z.ZodNumber;
+        publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        validation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        perFunction: z.ZodArray<z.ZodObject<{
+            functionName: z.ZodString;
+            time: z.ZodNumber;
+            oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                times: z.ZodArray<z.ZodNumber, "many">;
+            }, "strip", z.ZodTypeAny, {
+                times: number[];
+            }, {
+                times: number[];
+            }>>>;
+        }, "strip", z.ZodTypeAny, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }, {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }>, "many">;
+        unaccounted: z.ZodNumber;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    }, {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    }>;
+    nodeRPCCalls: z.ZodRecord<z.ZodString, z.ZodObject<{
+        times: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        times: number[];
+    }, {
+        times: number[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    timings: {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    };
+    nodeRPCCalls: Record<string, {
+        times: number[];
+    }>;
+}, {
+    timings: {
+        total: number;
+        sync: number;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        validation?: number | undefined;
+        publicSimulation?: number | undefined;
+    };
+    nodeRPCCalls: Record<string, {
+        times: number[];
+    }>;
+}>;
+export declare class TxProfileResult {
+    executionSteps: PrivateExecutionStep[];
+    stats: ProvingStats;
+    constructor(executionSteps: PrivateExecutionStep[], stats: ProvingStats);
+    static get schema(): ZodFor<TxProfileResult>;
+    static random(): TxProfileResult;
+}
+export declare class UtilitySimulationResult {
+    result: AbiDecoded;
+    stats?: SimulationStats | undefined;
+    constructor(result: AbiDecoded, stats?: SimulationStats | undefined);
+    static get schema(): ZodFor<UtilitySimulationResult>;
+    static random(): UtilitySimulationResult;
+}
+export {};
+//# sourceMappingURL=profiling.d.ts.map

package/dest/tx/profiling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiling.d.ts","sourceRoot":"","sources":["../../src/tx/profiling.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,KAAK,oBAAoB,EAA8B,MAAM,2CAA2C,CAAC;AAGlH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC,CAAC;AAI9E,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC/C,CAAC;AAQF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AAEH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B,CAAC;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AAEH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,YAAY,EAAE,SAAS,CAAC;CACzB;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH,qBAAa,eAAe;IAEjB,cAAc,EAAE,oBAAoB,EAAE;IACtC,KAAK,EAAE,YAAY;gBADnB,cAAc,EAAE,oBAAoB,EAAE,EACtC,KAAK,EAAE,YAAY;IAE5B,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,CAO3C;IAED,MAAM,CAAC,MAAM,IAAI,eAAe;CA+BjC;AAED,qBAAa,uBAAuB;IAEzB,MAAM,EAAE,UAAU;IAClB,KAAK,CAAC,EAAE,eAAe;gBADvB,MAAM,EAAE,UAAU,EAClB,KAAK,CAAC,EAAE,eAAe,YAAA;IAGhC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,uBAAuB,CAAC,CAOnD;IAED,MAAM,CAAC,MAAM,IAAI,uBAAuB;CAkBzC"}

package/dest/tx/profiling.js

@@ -0,0 +1,129 @@
+import { Fr } from '@aztec/foundation/fields';
+import { optional } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+import { AbiDecodedSchema } from '../schemas/schemas.js';
+const NodeStatsSchema = z.record(z.string(), z.object({
+    times: z.array(z.number())
+}));
+const FunctionTimingSchema = z.object({
+    functionName: z.string(),
+    time: z.number(),
+    oracles: optional(z.record(z.string(), z.object({
+        times: z.array(z.number())
+    })))
+});
+export const ProvingTimingsSchema = z.object({
+    sync: optional(z.number()),
+    proving: optional(z.number()),
+    perFunction: z.array(FunctionTimingSchema),
+    unaccounted: z.number(),
+    total: z.number()
+});
+export const ProvingStatsSchema = z.object({
+    timings: ProvingTimingsSchema,
+    nodeRPCCalls: optional(NodeStatsSchema)
+});
+export const SimulationTimingsSchema = z.object({
+    sync: z.number(),
+    publicSimulation: optional(z.number()),
+    validation: optional(z.number()),
+    perFunction: z.array(FunctionTimingSchema),
+    unaccounted: z.number(),
+    total: z.number()
+});
+export const SimulationStatsSchema = z.object({
+    timings: SimulationTimingsSchema,
+    nodeRPCCalls: NodeStatsSchema
+});
+export class TxProfileResult {
+    executionSteps;
+    stats;
+    constructor(executionSteps, stats){
+        this.executionSteps = executionSteps;
+        this.stats = stats;
+    }
+    static get schema() {
+        return z.object({
+            executionSteps: z.array(PrivateExecutionStepSchema),
+            stats: ProvingStatsSchema
+        }).transform(({ executionSteps, stats })=>new TxProfileResult(executionSteps, stats));
+    }
+    static random() {
+        return new TxProfileResult([
+            {
+                functionName: 'random',
+                bytecode: Buffer.from('random'),
+                witness: new Map([
+                    [
+                        1,
+                        'random'
+                    ]
+                ]),
+                vk: Buffer.from('random'),
+                timings: {
+                    witgen: 1,
+                    gateCount: 1
+                }
+            }
+        ], {
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
+                }
+            },
+            timings: {
+                sync: 1,
+                proving: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 4
+            }
+        });
+    }
+}
+export class UtilitySimulationResult {
+    result;
+    stats;
+    constructor(result, stats){
+        this.result = result;
+        this.stats = stats;
+    }
+    static get schema() {
+        return z.object({
+            result: AbiDecodedSchema,
+            stats: optional(SimulationStatsSchema)
+        }).transform(({ result, stats })=>new UtilitySimulationResult(result, stats));
+    }
+    static random() {
+        return new UtilitySimulationResult(Fr.random().toBigInt(), {
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
+                }
+            },
+            timings: {
+                sync: 1,
+                publicSimulation: 1,
+                validation: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 5
+            }
+        });
+    }
+}

package/dest/tx/protocol_contracts.d.ts

@@ -0,0 +1,29 @@
+import { MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, type Tuple } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+export declare class ProtocolContracts {
+    derivedAddresses: Tuple<AztecAddress, typeof MAX_PROTOCOL_CONTRACTS>;
+    constructor(derivedAddresses: Tuple<AztecAddress, typeof MAX_PROTOCOL_CONTRACTS>);
+    static from(fields: FieldsOf<ProtocolContracts>): ProtocolContracts;
+    static getFields(fields: FieldsOf<ProtocolContracts>): readonly [[AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress]];
+    static fromFields(fields: Fr[] | FieldReader): ProtocolContracts;
+    toFields(): Fr[];
+    static fromBuffer(buffer: Buffer | BufferReader): ProtocolContracts;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static empty(): ProtocolContracts;
+    getSize(): number;
+    hash(): Promise<Fr>;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        derivedAddresses: z.ZodArray<import("@aztec/foundation/schemas").ZodFor<AztecAddress>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        derivedAddresses: AztecAddress[];
+    }, {
+        derivedAddresses: any[];
+    }>, ProtocolContracts, {
+        derivedAddresses: any[];
+    }>;
+}
+//# sourceMappingURL=protocol_contracts.d.ts.map

package/dest/tx/protocol_contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol_contracts.d.ts","sourceRoot":"","sources":["../../src/tx/protocol_contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAI1E,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,KAAK,EAIX,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,qBAAa,iBAAiB;IACT,gBAAgB,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,sBAAsB,CAAC;gBAApE,gBAAgB,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,sBAAsB,CAAC;IAEvF,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC;IAI/C,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC;IAIpD,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,iBAAiB;IAKhE,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,iBAAiB;IAKnE,QAAQ;IAIR,MAAM,CAAC,KAAK;IAIZ,OAAO;IAIP,IAAI;IAIJ,MAAM,KAAK,MAAM;;;;;;;;OAQhB;CACF"}

package/dest/tx/protocol_contracts.js

@@ -0,0 +1,49 @@
+import { GeneratorIndex, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { BufferReader, FieldReader, assertLength, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+export class ProtocolContracts {
+    derivedAddresses;
+    constructor(derivedAddresses){
+        this.derivedAddresses = derivedAddresses;
+    }
+    static from(fields) {
+        return new ProtocolContracts(...ProtocolContracts.getFields(fields));
+    }
+    static getFields(fields) {
+        return [
+            fields.derivedAddresses
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+    }
+    toFields() {
+        return serializeToFields(...ProtocolContracts.getFields(this));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+    }
+    toBuffer() {
+        return serializeToBuffer(...ProtocolContracts.getFields(this));
+    }
+    static empty() {
+        return new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, ()=>AztecAddress.zero()));
+    }
+    getSize() {
+        return arraySerializedSizeOfNonEmpty(this.derivedAddresses);
+    }
+    hash() {
+        return poseidon2HashWithSeparator(this.derivedAddresses, GeneratorIndex.PROTOCOL_CONTRACTS);
+    }
+    static get schema() {
+        return z.object({
+            derivedAddresses: AztecAddress.schema.array().min(MAX_PROTOCOL_CONTRACTS).max(MAX_PROTOCOL_CONTRACTS)
+        }).transform(({ derivedAddresses })=>new ProtocolContracts(assertLength(derivedAddresses, MAX_PROTOCOL_CONTRACTS)));
+    }
+}