@aztec/stdlib 5.0.0-nightly.20260518 → 5.0.0-nightly.20260521

package/dest/validators/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/validators/schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,2BAA2B,wIASvC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;WAOxC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;oBAAwC,CAAC;AAEvF,eAAO,MAAM,+BAA+B;;;;;;;;;;;qBAA8C,CAAC;AAiB3F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUhC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOjC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EActC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/validators/schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,2BAA2B;;;;;;;EASvC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;kBAOxC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;mBAAwC,CAAC;AAEvF,eAAO,MAAM,+BAA+B;;;;;;;;;;oBAA0D,CAAC;AAiBvG,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUhC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOjC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBActC,CAAC"}

package/dest/validators/schemas.js

@@ -13,7 +13,7 @@ export const ValidatorStatusHistorySchema = zodFor()(z.array(z.object({
     status: ValidatorStatusInSlotSchema
 })));
 export const ValidatorStatusHistorySchemaArray = z.array(ValidatorStatusHistorySchema);
-export const ValidatorStatusHistorySchemaMap = z.record(ValidatorStatusHistorySchemaArray);
+export const ValidatorStatusHistorySchemaMap = z.record(z.string(), ValidatorStatusHistorySchemaArray);
 const ValidatorTimeStatSchema = z.object({
     timestamp: schemas.BigInt,
     slot: schemas.SlotNumber,
@@ -35,7 +35,7 @@ export const ValidatorStatsSchema = zodFor()(z.object({
     history: ValidatorStatusHistorySchema
 }));
 export const ValidatorsStatsSchema = zodFor()(z.object({
-    stats: z.record(ValidatorStatsSchema),
+    stats: z.record(z.string(), ValidatorStatsSchema),
     lastProcessedSlot: schemas.SlotNumber.optional(),
     initialSlot: schemas.SlotNumber.optional(),
     slotWindow: schemas.Integer

package/dest/vks/verification_key.d.ts

@@ -12,7 +12,7 @@ export declare class VerificationKeyAsFields {
     static fromKey(key: Fr[]): Promise<VerificationKeyAsFields>;
     get numPublicInputs(): number;
     get circuitSize(): number;
-    static get schema(): import("zod").ZodType<VerificationKeyAsFields, any, string>;
+    static get schema(): import("zod").ZodType<VerificationKeyAsFields, string, import("zod/v4/core").$ZodTypeInternals<VerificationKeyAsFields, string>>;
     toJSON(): Buffer<ArrayBufferLike>;
     /**
      * Serialize as a buffer.
@@ -62,6 +62,6 @@ export declare class VerificationKeyData {
     /** Returns a hex representation for JSON serialization. */
     toJSON(): Buffer<ArrayBufferLike>;
     /** Creates an instance from a hex string. */
-    static get schema(): import("zod").ZodType<VerificationKeyData, any, string>;
+    static get schema(): import("zod").ZodType<VerificationKeyData, string, import("zod/v4/core").$ZodTypeInternals<VerificationKeyData, string>>;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/vks/verification_key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verification_key.d.ts","sourceRoot":"","sources":["../../src/vks/verification_key.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAM9E,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C;;GAEG;AACH,qBAAa,uBAAuB;IAEzB,GAAG,EAAE,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IAFjB,YACS,GAAG,EAAE,EAAE,EAAE,EACT,IAAI,EAAE,EAAE,EACb;IAEJ,OAAa,OAAO,CAAC,GAAG,EAAE,EAAE,EAAE,oCAG7B;IAED,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,KAAK,MAAM,gEAGhB;IAED,MAAM,4BAEL;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED,QAAQ,oBAEP;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,uBAAuB,CAGxE;IAED,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAKrE;IAED;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,uBAAuB,CAE/D;IAED,MAAM,CAAC,YAAY,CAAC,IAAI,SAAI,GAAG,uBAAuB,CAErD;IAED,MAAM,CAAC,kBAAkB,CAAC,IAAI,SAAI,GAAG,uBAAuB,CAK3D;IAED;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB,CAEtD;CACF;AAED,qBAAa,mBAAmB;aAEZ,WAAW,EAAE,uBAAuB;aACpC,UAAU,EAAE,MAAM;IAFpC,YACkB,WAAW,EAAE,uBAAuB,EACpC,UAAU,EAAE,MAAM,EAChC;IAEJ,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,CAAC,KAAK,wBAEX;IAED,MAAM,CAAC,YAAY,IAAI,mBAAmB,CAGzC;IAED,MAAM,CAAC,kBAAkB,IAAI,mBAAmB,CAG/C;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED,QAAQ,kBAEP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAMpE;IAED,OAAa,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAEvE;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAElD;IAEM,KAAK,wBAEX;IAED,2DAA2D;IAC3D,MAAM,4BAEL;IAED,6CAA6C;IAC7C,MAAM,KAAK,MAAM,4DAEhB;CACF"}
+{"version":3,"file":"verification_key.d.ts","sourceRoot":"","sources":["../../src/vks/verification_key.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAM9E,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C;;GAEG;AACH,qBAAa,uBAAuB;IAEzB,GAAG,EAAE,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IAFjB,YACS,GAAG,EAAE,EAAE,EAAE,EACT,IAAI,EAAE,EAAE,EACb;IAEJ,OAAa,OAAO,CAAC,GAAG,EAAE,EAAE,EAAE,oCAG7B;IAED,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,KAAK,MAAM,qIAGhB;IAED,MAAM,4BAEL;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED,QAAQ,oBAEP;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,uBAAuB,CAGxE;IAED,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAKrE;IAED;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,uBAAuB,CAE/D;IAED,MAAM,CAAC,YAAY,CAAC,IAAI,SAAI,GAAG,uBAAuB,CAErD;IAED,MAAM,CAAC,kBAAkB,CAAC,IAAI,SAAI,GAAG,uBAAuB,CAK3D;IAED;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB,CAEtD;CACF;AAED,qBAAa,mBAAmB;aAEZ,WAAW,EAAE,uBAAuB;aACpC,UAAU,EAAE,MAAM;IAFpC,YACkB,WAAW,EAAE,uBAAuB,EACpC,UAAU,EAAE,MAAM,EAChC;IAEJ,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,CAAC,KAAK,wBAEX;IAED,MAAM,CAAC,YAAY,IAAI,mBAAmB,CAGzC;IAED,MAAM,CAAC,kBAAkB,IAAI,mBAAmB,CAG/C;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED,QAAQ,kBAEP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB,CAMpE;IAED,OAAa,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAEvE;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAElD;IAEM,KAAK,wBAEX;IAED,2DAA2D;IAC3D,MAAM,4BAEL;IAED,6CAA6C;IAC7C,MAAM,KAAK,MAAM,6HAEhB;CACF"}

package/dest/world-state/world_state_revision.d.ts

@@ -13,49 +13,31 @@ export declare class WorldStateRevision {
     constructor(forkId: number, blockNumber: number, includeUncommitted: boolean);
     toString(): string;
     static empty(): WorldStateRevision;
-    static get schema(): z.ZodEffects<z.ZodObject<{
+    static get schema(): z.ZodPipe<z.ZodObject<{
         forkId: z.ZodNumber;
         blockNumber: z.ZodNumber;
         includeUncommitted: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
+    }, z.core.$strip>, z.ZodTransform<WorldStateRevision, {
         forkId: number;
         blockNumber: number;
         includeUncommitted: boolean;
-    }, {
-        forkId: number;
-        blockNumber: number;
-        includeUncommitted: boolean;
-    }>, WorldStateRevision, {
-        forkId: number;
-        blockNumber: number;
-        includeUncommitted: boolean;
-    }>;
+    }>>;
 }
 export declare class WorldStateRevisionWithHandle extends WorldStateRevision {
     readonly handle: any;
     constructor(forkId: number, blockNumber: number, includeUncommitted: boolean, handle: any);
     toWorldStateRevision(): WorldStateRevision;
     static fromWorldStateRevision(revision: WorldStateRevision, handle: any): WorldStateRevisionWithHandle;
-    static get schema(): z.ZodEffects<z.ZodObject<{
+    static get schema(): z.ZodPipe<z.ZodObject<{
         forkId: z.ZodNumber;
         blockNumber: z.ZodNumber;
         includeUncommitted: z.ZodBoolean;
         handle: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        forkId: number;
-        blockNumber: number;
-        includeUncommitted: boolean;
-        handle?: any;
-    }, {
-        forkId: number;
-        blockNumber: number;
-        includeUncommitted: boolean;
-        handle?: any;
-    }>, WorldStateRevisionWithHandle, {
+    }, z.core.$strip>, z.ZodTransform<WorldStateRevisionWithHandle, {
         forkId: number;
         blockNumber: number;
         includeUncommitted: boolean;
-        handle?: any;
-    }>;
+        handle: any;
+    }>>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfcmV2aXNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93b3JsZC1zdGF0ZS93b3JsZF9zdGF0ZV9yZXZpc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLHFCQUFhLGtCQUFrQjthQVVYLE1BQU0sRUFBRSxNQUFNO2FBQ2QsV0FBVyxFQUFFLE1BQU07YUFDbkIsa0JBQWtCLEVBQUUsT0FBTztJQVg3Qzs7Ozs7T0FLRztJQUNILGdCQUF1QixNQUFNLGNBQWM7SUFFM0MsWUFDa0IsTUFBTSxFQUFFLE1BQU0sRUFDZCxXQUFXLEVBQUUsTUFBTSxFQUNuQixrQkFBa0IsRUFBRSxPQUFPLEVBQ3pDO0lBRUcsUUFBUSxXQUVkO0lBRUQsTUFBTSxDQUFDLEtBQUssdUJBRVg7SUFFRCxNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7Ozs7Ozs7OztPQVdoQjtDQUNGO0FBRUQscUJBQWEsNEJBQTZCLFNBQVEsa0JBQWtCO2FBS2hELE1BQU0sRUFBRSxHQUFHO0lBSjdCLFlBQ0UsTUFBTSxFQUFFLE1BQU0sRUFDZCxXQUFXLEVBQUUsTUFBTSxFQUNuQixrQkFBa0IsRUFBRSxPQUFPLEVBQ1gsTUFBTSxFQUFFLEdBQUcsRUFHNUI7SUFFTSxvQkFBb0IsdUJBRTFCO0lBRUQsTUFBTSxDQUFDLHNCQUFzQixDQUFDLFFBQVEsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLEVBQUUsR0FBRyxnQ0FFdEU7SUFFRCxXQUFvQixNQUFNOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztPQVl6QjtDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGRfc3RhdGVfcmV2aXNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93b3JsZC1zdGF0ZS93b3JsZF9zdGF0ZV9yZXZpc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLHFCQUFhLGtCQUFrQjthQVVYLE1BQU0sRUFBRSxNQUFNO2FBQ2QsV0FBVyxFQUFFLE1BQU07YUFDbkIsa0JBQWtCLEVBQUUsT0FBTztJQVg3Qzs7Ozs7T0FLRztJQUNILGdCQUF1QixNQUFNLGNBQWM7SUFFM0MsWUFDa0IsTUFBTSxFQUFFLE1BQU0sRUFDZCxXQUFXLEVBQUUsTUFBTSxFQUNuQixrQkFBa0IsRUFBRSxPQUFPLEVBQ3pDO0lBRUcsUUFBUSxXQUVkO0lBRUQsTUFBTSxDQUFDLEtBQUssdUJBRVg7SUFFRCxNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7UUFXaEI7Q0FDRjtBQUVELHFCQUFhLDRCQUE2QixTQUFRLGtCQUFrQjthQUtoRCxNQUFNLEVBQUUsR0FBRztJQUo3QixZQUNFLE1BQU0sRUFBRSxNQUFNLEVBQ2QsV0FBVyxFQUFFLE1BQU0sRUFDbkIsa0JBQWtCLEVBQUUsT0FBTyxFQUNYLE1BQU0sRUFBRSxHQUFHLEVBRzVCO0lBRU0sb0JBQW9CLHVCQUUxQjtJQUVELE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxRQUFRLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxFQUFFLEdBQUcsZ0NBRXRFO0lBRUQsV0FBb0IsTUFBTTs7Ozs7Ozs7OztRQVl6QjtDQUNGIn0=

package/dest/world-state/world_state_revision.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world_state_revision.d.ts","sourceRoot":"","sources":["../../src/world-state/world_state_revision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,qBAAa,kBAAkB;aAUX,MAAM,EAAE,MAAM;aACd,WAAW,EAAE,MAAM;aACnB,kBAAkB,EAAE,OAAO;IAX7C;;;;;OAKG;IACH,gBAAuB,MAAM,cAAc;IAE3C,YACkB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,OAAO,EACzC;IAEG,QAAQ,WAEd;IAED,MAAM,CAAC,KAAK,uBAEX;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAWhB;CACF;AAED,qBAAa,4BAA6B,SAAQ,kBAAkB;aAKhD,MAAM,EAAE,GAAG;IAJ7B,YACE,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,OAAO,EACX,MAAM,EAAE,GAAG,EAG5B;IAEM,oBAAoB,uBAE1B;IAED,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,gCAEtE;IAED,WAAoB,MAAM;;;;;;;;;;;;;;;;;;;;OAYzB;CACF"}
+{"version":3,"file":"world_state_revision.d.ts","sourceRoot":"","sources":["../../src/world-state/world_state_revision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,qBAAa,kBAAkB;aAUX,MAAM,EAAE,MAAM;aACd,WAAW,EAAE,MAAM;aACnB,kBAAkB,EAAE,OAAO;IAX7C;;;;;OAKG;IACH,gBAAuB,MAAM,cAAc;IAE3C,YACkB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,OAAO,EACzC;IAEG,QAAQ,WAEd;IAED,MAAM,CAAC,KAAK,uBAEX;IAED,MAAM,KAAK,MAAM;;;;;;;;QAWhB;CACF;AAED,qBAAa,4BAA6B,SAAQ,kBAAkB;aAKhD,MAAM,EAAE,GAAG;IAJ7B,YACE,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,OAAO,EACX,MAAM,EAAE,GAAG,EAG5B;IAEM,oBAAoB,uBAE1B;IAED,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,gCAEtE;IAED,WAAoB,MAAM;;;;;;;;;;QAYzB;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "5.0.0-nightly.20260518",
+  "version": "5.0.0-nightly.20260521",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -92,13 +92,13 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "5.0.0-nightly.20260518",
-    "@aztec/blob-lib": "5.0.0-nightly.20260518",
-    "@aztec/constants": "5.0.0-nightly.20260518",
-    "@aztec/ethereum": "5.0.0-nightly.20260518",
-    "@aztec/foundation": "5.0.0-nightly.20260518",
-    "@aztec/l1-artifacts": "5.0.0-nightly.20260518",
-    "@aztec/noir-noirc_abi": "5.0.0-nightly.20260518",
+    "@aztec/bb.js": "5.0.0-nightly.20260521",
+    "@aztec/blob-lib": "5.0.0-nightly.20260521",
+    "@aztec/constants": "5.0.0-nightly.20260521",
+    "@aztec/ethereum": "5.0.0-nightly.20260521",
+    "@aztec/foundation": "5.0.0-nightly.20260521",
+    "@aztec/l1-artifacts": "5.0.0-nightly.20260521",
+    "@aztec/noir-noirc_abi": "5.0.0-nightly.20260521",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.15.1",
     "json-stringify-deterministic": "1.0.12",
@@ -110,7 +110,7 @@
     "pako": "^2.1.0",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2",
-    "zod": "^3.23.8"
+    "zod": "^4"
   },
   "devDependencies": {
     "@jest/expect": "^30.0.0",

package/src/abi/abi.ts

@@ -222,10 +222,11 @@ export const FunctionDebugMetadataSchema = z.object({
         }),
       ),
     }),
-    acir_locations: z.record(z.number()),
-    brillig_locations: z.record(z.record(z.number())),
+    acir_locations: z.record(z.string(), z.number()),
+    brillig_locations: z.record(z.string(), z.record(z.string(), z.number())),
   }),
   files: z.record(
+    z.string(),
     z.object({
       source: z.string(),
       path: z.string(),
@@ -376,7 +377,7 @@ export const ContractArtifactSchema = zodFor<ContractArtifact>()(
     functions: z.array(FunctionArtifactSchema),
     nonDispatchPublicFunctions: z.array(FunctionAbiSchema),
     outputs: z.object({
-      structs: z.record(z.array(AbiTypeSchema)).transform(structs => {
+      structs: z.record(z.string(), 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.
@@ -388,9 +389,9 @@ export const ContractArtifactSchema = zodFor<ContractArtifact>()(
         }
         return structs;
       }),
-      globals: z.record(z.array(AbiValueSchema)),
+      globals: z.record(z.string(), z.array(AbiValueSchema)),
     }),
-    storageLayout: z.record(z.object({ slot: schemas.Fr })),
+    storageLayout: z.record(z.string(), z.object({ slot: schemas.Fr })),
     fileMap: z.record(
       z.coerce.number(),
       z.object({

package/src/block/block_parameter.ts

@@ -36,7 +36,7 @@ export type NormalizedBlockParameter =
   | { archive: Fr }
   | { tag: Exclude<BlockTag, 'latest'> };
 
-export const NormalizedBlockParameterSchema: z.ZodType<NormalizedBlockParameter, z.ZodTypeDef, unknown> = z.union([
+export const NormalizedBlockParameterSchema: z.ZodType<NormalizedBlockParameter, unknown> = z.union([
   z.object({ number: BlockNumberSchema }).strict(),
   z.object({ hash: BlockHash.schema }).strict(),
   z.object({ archive: schemas.Fr }).strict(),
@@ -52,7 +52,7 @@ export const NormalizedBlockParameterSchema: z.ZodType<NormalizedBlockParameter,
  */
 export type BlockParameter = NormalizedBlockParameter | BlockNumber | BlockHash | BlockTag;
 
-export const BlockParameterSchema: z.ZodType<BlockParameter, z.ZodTypeDef, unknown> = z.union([
+export const BlockParameterSchema: z.ZodType<BlockParameter, unknown> = z.union([
   NormalizedBlockParameterSchema,
   BlockHash.schema,
   BlockTagSchema,

package/src/block/l2_block_source.ts

@@ -42,14 +42,14 @@ export type BlocksQuery =
   | { from: BlockNumber; limit: number; onlyCheckpointed?: boolean }
   | { epoch: EpochNumber; onlyCheckpointed: true };
 
-export const BlockQuerySchema: z.ZodType<BlockQuery, z.ZodTypeDef, unknown> = z.union([
+export const BlockQuerySchema: z.ZodType<BlockQuery, unknown> = z.union([
   z.object({ number: BlockNumberSchema }).strict(),
   z.object({ hash: BlockHash.schema }).strict(),
   z.object({ archive: schemas.Fr }).strict(),
   z.object({ tag: BlockTagWithoutLatestSchema }).strict(),
 ]);
 
-export const BlocksQuerySchema: z.ZodType<BlocksQuery, z.ZodTypeDef, unknown> = z.union([
+export const BlocksQuerySchema: z.ZodType<BlocksQuery, unknown> = z.union([
   z
     .object({ from: BlockNumberSchema, limit: z.number().int().min(1), onlyCheckpointed: z.boolean().optional() })
     .strict(),
@@ -72,18 +72,18 @@ export type CheckpointsQuery = { from: CheckpointNumber; limit: number } | { epo
  */
 export type ProposedCheckpointQuery = { number: CheckpointNumber } | { slot: SlotNumber } | { tag: 'proposed' };
 
-export const CheckpointQuerySchema: z.ZodType<CheckpointQuery, z.ZodTypeDef, unknown> = z.union([
+export const CheckpointQuerySchema: z.ZodType<CheckpointQuery, unknown> = z.union([
   z.object({ number: CheckpointNumberSchema }).strict(),
   z.object({ slot: SlotNumberSchema }).strict(),
   z.object({ tag: z.union([z.literal('checkpointed'), z.literal('proven'), z.literal('finalized')]) }).strict(),
 ]);
 
-export const CheckpointsQuerySchema: z.ZodType<CheckpointsQuery, z.ZodTypeDef, unknown> = z.union([
+export const CheckpointsQuerySchema: z.ZodType<CheckpointsQuery, unknown> = z.union([
   z.object({ from: CheckpointNumberSchema, limit: z.number().int().min(1) }).strict(),
   z.object({ epoch: EpochNumberSchema }).strict(),
 ]);
 
-export const ProposedCheckpointQuerySchema: z.ZodType<ProposedCheckpointQuery, z.ZodTypeDef, unknown> = z.union([
+export const ProposedCheckpointQuerySchema: z.ZodType<ProposedCheckpointQuery, unknown> = z.union([
   z.object({ number: CheckpointNumberSchema }).strict(),
   z.object({ slot: SlotNumberSchema }).strict(),
   z.object({ tag: z.literal('proposed') }).strict(),

package/src/interfaces/archiver.ts

@@ -89,58 +89,63 @@ export type ArchiverApi = Omit<
 >;
 
 export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
-  getRollupAddress: z.function().args().returns(schemas.EthAddress),
-  getRegistryAddress: z.function().args().returns(schemas.EthAddress),
-  getBlockNumber: z.function().args(optional(BlockQuerySchema)).returns(BlockNumberSchema.optional()),
-  getCheckpointNumber: z.function().args().returns(CheckpointNumberSchema),
-  getCheckpoint: z.function().args(CheckpointQuerySchema).returns(PublishedCheckpoint.schema.optional()),
-  getCheckpoints: z.function().args(CheckpointsQuerySchema).returns(z.array(PublishedCheckpoint.schema)),
-  getCheckpointData: z.function().args(CheckpointQuerySchema).returns(CheckpointDataSchema.optional()),
-  getCheckpointsData: z.function().args(CheckpointsQuerySchema).returns(z.array(CheckpointDataSchema)),
-  getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
-  getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
-  getSyncedL2SlotNumber: z.function().args().returns(schemas.SlotNumber.optional()),
-  getSyncedL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
-  getBlocksForSlot: z.function().args(schemas.SlotNumber).returns(z.array(L2Block.schema)),
-  isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
-  getL2Tips: z.function().args().returns(L2TipsSchema),
-  getPrivateLogsByTags: z
-    .function()
-    .args(z.array(SiloedTag.schema), optional(z.number().gte(0)))
-    .returns(z.array(z.array(TxScopedL2Log.schema))),
-  getPublicLogsByTagsFromContract: z
-    .function()
-    .args(schemas.AztecAddress, z.array(Tag.schema), optional(z.number().gte(0)))
-    .returns(z.array(z.array(TxScopedL2Log.schema))),
-  getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
-  getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
-  getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
-  getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
-  getContract: z
-    .function()
-    .args(schemas.AztecAddress, optional(schemas.BigInt))
-    .returns(ContractInstanceWithAddressSchema.optional()),
-  getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
-  registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),
-  getL1ToL2Messages: z.function().args(CheckpointNumberSchema).returns(z.array(schemas.Fr)),
-  getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
-  getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
-  getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
-  isPruneDueAtSlot: z.function().args(schemas.SlotNumber).returns(z.boolean()),
-  getGenesisValues: z
-    .function()
-    .args()
-    .returns(z.object({ genesisArchiveRoot: schemas.Fr })),
-  getL1Timestamp: z.function().args().returns(schemas.BigInt.optional()),
-  getProposedCheckpointData: z
-    .function()
-    .args(optional(ProposedCheckpointQuerySchema))
-    .returns(ProposedCheckpointDataSchema.optional()),
-  syncImmediate: z.function().args().returns(z.void()),
-  isPendingChainInvalid: z.function().args().returns(z.boolean()),
-  getPendingChainValidationStatus: z.function().args().returns(ValidateCheckpointResultSchema),
-  getBlock: z.function().args(BlockQuerySchema).returns(L2Block.schema.optional()),
-  getBlocks: z.function().args(BlocksQuerySchema).returns(z.array(L2Block.schema)),
-  getBlockData: z.function().args(BlockQuerySchema).returns(BlockDataSchema.optional()),
-  getBlocksData: z.function().args(BlocksQuerySchema).returns(z.array(BlockDataSchema)),
+  getRollupAddress: z.function({ input: z.tuple([]), output: schemas.EthAddress }),
+  getRegistryAddress: z.function({ input: z.tuple([]), output: schemas.EthAddress }),
+  getBlockNumber: z.function({ input: z.tuple([optional(BlockQuerySchema)]), output: BlockNumberSchema.optional() }),
+  getCheckpointNumber: z.function({ input: z.tuple([]), output: CheckpointNumberSchema }),
+  getCheckpoint: z.function({ input: z.tuple([CheckpointQuerySchema]), output: PublishedCheckpoint.schema.optional() }),
+  getCheckpoints: z.function({ input: z.tuple([CheckpointsQuerySchema]), output: z.array(PublishedCheckpoint.schema) }),
+  getCheckpointData: z.function({ input: z.tuple([CheckpointQuerySchema]), output: CheckpointDataSchema.optional() }),
+  getCheckpointsData: z.function({ input: z.tuple([CheckpointsQuerySchema]), output: z.array(CheckpointDataSchema) }),
+  getTxEffect: z.function({ input: z.tuple([TxHash.schema]), output: indexedTxSchema().optional() }),
+  getSettledTxReceipt: z.function({ input: z.tuple([TxHash.schema]), output: TxReceipt.schema.optional() }),
+  getSyncedL2SlotNumber: z.function({ input: z.tuple([]), output: schemas.SlotNumber.optional() }),
+  getSyncedL2EpochNumber: z.function({ input: z.tuple([]), output: EpochNumberSchema.optional() }),
+  getBlocksForSlot: z.function({ input: z.tuple([schemas.SlotNumber]), output: z.array(L2Block.schema) }),
+  isEpochComplete: z.function({ input: z.tuple([EpochNumberSchema]), output: z.boolean() }),
+  getL2Tips: z.function({ input: z.tuple([]), output: L2TipsSchema }),
+  getPrivateLogsByTags: z.function({
+    input: z.tuple([z.array(SiloedTag.schema), optional(z.number().gte(0)), optional(BlockNumberSchema)]),
+    output: z.array(z.array(TxScopedL2Log.schema)),
+  }),
+  getPublicLogsByTagsFromContract: z.function({
+    input: z.tuple([
+      schemas.AztecAddress,
+      z.array(Tag.schema),
+      optional(z.number().gte(0)),
+      optional(BlockNumberSchema),
+    ]),
+    output: z.array(z.array(TxScopedL2Log.schema)),
+  }),
+  getPublicLogs: z.function({ input: z.tuple([LogFilterSchema]), output: GetPublicLogsResponseSchema }),
+  getContractClassLogs: z.function({ input: z.tuple([LogFilterSchema]), output: GetContractClassLogsResponseSchema }),
+  getContractClass: z.function({ input: z.tuple([schemas.Fr]), output: ContractClassPublicSchema.optional() }),
+  getBytecodeCommitment: z.function({ input: z.tuple([schemas.Fr]), output: schemas.Fr }),
+  getContract: z.function({
+    input: z.tuple([schemas.AztecAddress, optional(schemas.BigInt)]),
+    output: ContractInstanceWithAddressSchema.optional(),
+  }),
+  getContractClassIds: z.function({ input: z.tuple([]), output: z.array(schemas.Fr) }),
+  registerContractFunctionSignatures: z.function({ input: z.tuple([z.array(z.string())]), output: z.void() }),
+  getL1ToL2Messages: z.function({ input: z.tuple([CheckpointNumberSchema]), output: z.array(schemas.Fr) }),
+  getL1ToL2MessageIndex: z.function({ input: z.tuple([schemas.Fr]), output: schemas.BigInt.optional() }),
+  getDebugFunctionName: z.function({
+    input: z.tuple([schemas.AztecAddress, schemas.FunctionSelector]),
+    output: optional(z.string()),
+  }),
+  getL1Constants: z.function({ input: z.tuple([]), output: L1RollupConstantsSchema }),
+  isPruneDueAtSlot: z.function({ input: z.tuple([schemas.SlotNumber]), output: z.boolean() }),
+  getGenesisValues: z.function({ input: z.tuple([]), output: z.object({ genesisArchiveRoot: schemas.Fr }) }),
+  getL1Timestamp: z.function({ input: z.tuple([]), output: schemas.BigInt.optional() }),
+  getProposedCheckpointData: z.function({
+    input: z.tuple([optional(ProposedCheckpointQuerySchema)]),
+    output: ProposedCheckpointDataSchema.optional(),
+  }),
+  syncImmediate: z.function({ input: z.tuple([]), output: z.void() }),
+  isPendingChainInvalid: z.function({ input: z.tuple([]), output: z.boolean() }),
+  getPendingChainValidationStatus: z.function({ input: z.tuple([]), output: ValidateCheckpointResultSchema }),
+  getBlock: z.function({ input: z.tuple([BlockQuerySchema]), output: L2Block.schema.optional() }),
+  getBlocks: z.function({ input: z.tuple([BlocksQuerySchema]), output: z.array(L2Block.schema) }),
+  getBlockData: z.function({ input: z.tuple([BlockQuerySchema]), output: BlockDataSchema.optional() }),
+  getBlocksData: z.function({ input: z.tuple([BlocksQuerySchema]), output: z.array(BlockDataSchema) }),
 };

package/src/interfaces/aztec-node-admin.ts

@@ -99,17 +99,20 @@ export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConf
   .merge(z.object({ maxPendingTxCount: z.number(), skipIncomingProposals: z.boolean().optional() }));
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
-  getConfig: z.function().returns(AztecNodeAdminConfigSchema),
-  setConfig: z.function().args(AztecNodeAdminConfigSchema.partial()).returns(z.void()),
-  startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
-  rollbackTo: z.function().args(z.number(), optional(z.boolean()), optional(z.boolean())).returns(z.void()),
-  pauseSync: z.function().returns(z.void()),
-  resumeSync: z.function().returns(z.void()),
-  getSlashOffenses: z
-    .function()
-    .args(z.union([z.bigint(), z.literal('all'), z.literal('current')]))
-    .returns(z.array(OffenseSchema)),
-  reloadKeystore: z.function().returns(z.void()),
+  getConfig: z.function({ input: z.tuple([]), output: AztecNodeAdminConfigSchema }),
+  setConfig: z.function({ input: z.tuple([AztecNodeAdminConfigSchema.partial()]), output: z.void() }),
+  startSnapshotUpload: z.function({ input: z.tuple([z.string()]), output: z.void() }),
+  rollbackTo: z.function({
+    input: z.tuple([z.number(), optional(z.boolean()), optional(z.boolean())]),
+    output: z.void(),
+  }),
+  pauseSync: z.function({ input: z.tuple([]), output: z.void() }),
+  resumeSync: z.function({ input: z.tuple([]), output: z.void() }),
+  getSlashOffenses: z.function({
+    input: z.tuple([z.union([z.bigint(), z.literal('all'), z.literal('current')])]),
+    output: z.array(OffenseSchema),
+  }),
+  reloadKeystore: z.function({ input: z.tuple([]), output: z.void() }),
 };
 
 export function createAztecNodeAdminClient(

package/src/interfaces/aztec-node-debug.ts

@@ -22,7 +22,7 @@ export interface AztecNodeDebug {
 }
 
 export const AztecNodeDebugApiSchema: ApiSchemaFor<AztecNodeDebug> = {
-  mineBlock: z.function().returns(z.void()),
+  mineBlock: z.function({ input: z.tuple([]), output: z.void() }),
 };
 
 export function createAztecNodeDebugClient(