@aztec/stdlib 3.0.0-nightly.20251216 → 3.0.0-nightly.20251218

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

@@ -1 +1 @@
-{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,gBAAgB,EAA0B,MAAM,eAAe,CAAC;AAC9E,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,6CAA6C,CAAC;AAErD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAE9G,OAAO,EAEL,sBAAsB,EAEvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,eAAe,EAAyB,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAClG,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAO7B,MAAM,MAAM,iBAAiB,GAAG,MAAM,CACpC,MAAM,EACN;IAAE,QAAQ,EAAE,2BAA2B,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CACtE,CAAC;AAMF,qBAAa,mBAAmB;IACX,SAAS,CAAC;IAA7B,YAAmB,SAAS,CAAC,+BAAmB,EAAI;IAEpD,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAahB;CACF;AAED,qBAAa,uBAAuB;IAEzB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAF3D,YACS,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EACvD;IAEJ,sBAAsB,8BAErB;IAEK,aAAa,IAAI,OAAO,CAAC,EAAE,CAAC,CASjC;CACF;AAED,qBAAa,kBAAkB;IAEpB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,YAAY,CAAC;IACb,KAAK,CAAC;IAJf,YACS,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,YAAY,CAAC,oCAAwB,EACrC,KAAK,CAAC,6BAAiB,EAC5B;IAEJ,IAAI,OAAO,IAAI,OAAO,CASrB;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAS9C;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,CAAC,sBAOhE;IAED,MAAM,CAAC,0CAA0C,CAC/C,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,CAAC,EAAE,sBAAsB,EACrC,KAAK,CAAC,EAAE,eAAe,sBAQxB;IAED,OAAa,MAAM,gCAMlB;IAED,sBAAsB,8BAErB;IAED,aAAa,IAAI,OAAO,CAAC,EAAE,CAAC,CAE3B;IAED,qBAAqB,gCAEpB;CACF;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,sBAAsB,GAAG,yBAAyB,CAWhH"}
+{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"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"}

package/dest/tx/validator/tx_validator.d.ts

@@ -19,13 +19,10 @@ export interface TxValidator<T extends AnyTx = AnyTx> {
 }
 export declare const TxValidationResultSchema: z.ZodDiscriminatedUnion<"result", [z.ZodObject<{
     result: z.ZodLiteral<"valid">;
-    reason: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     result: "valid";
-    reason?: string[] | undefined;
 }, {
     result: "valid";
-    reason?: string[] | undefined;
 }>, z.ZodObject<{
     result: z.ZodLiteral<"invalid">;
     reason: z.ZodArray<z.ZodString, "many">;
@@ -45,4 +42,4 @@ export declare const TxValidationResultSchema: z.ZodDiscriminatedUnion<"result",
     result: "skipped";
     reason: string[];
 }>]>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHgvdmFsaWRhdG9yL3R4X3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBR3hCLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUNuQyxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFNUMsTUFBTSxNQUFNLEtBQUssR0FBRyxFQUFFLEdBQUcsV0FBVyxDQUFDO0FBRXJDLHdCQUFnQixTQUFTLENBQUMsRUFBRSxFQUFFLEtBQUssR0FBRyxNQUFNLENBRTNDO0FBRUQsd0JBQWdCLGNBQWMsQ0FBQyxFQUFFLEVBQUUsS0FBSyxHQUFHLE9BQU8sQ0FFakQ7QUFFRCxNQUFNLE1BQU0sa0JBQWtCLEdBQzFCO0lBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQTtDQUFFLEdBQ25CO0lBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQTtDQUFFLEdBQ3ZDO0lBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQTtDQUFFLENBQUM7QUFFNUMsTUFBTSxXQUFXLFdBQVcsQ0FBQyxDQUFDLFNBQVMsS0FBSyxHQUFHLEtBQUs7SUFDbEQsVUFBVSxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBQUM7Q0FDaEQ7QUFFRCxlQUFPLE1BQU0sd0JBQXdCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7SUFJRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHgvdmFsaWRhdG9yL3R4X3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBR3hCLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUNuQyxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFNUMsTUFBTSxNQUFNLEtBQUssR0FBRyxFQUFFLEdBQUcsV0FBVyxDQUFDO0FBRXJDLHdCQUFnQixTQUFTLENBQUMsRUFBRSxFQUFFLEtBQUssR0FBRyxNQUFNLENBRTNDO0FBRUQsd0JBQWdCLGNBQWMsQ0FBQyxFQUFFLEVBQUUsS0FBSyxHQUFHLE9BQU8sQ0FFakQ7QUFFRCxNQUFNLE1BQU0sa0JBQWtCLEdBQzFCO0lBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQTtDQUFFLEdBQ25CO0lBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQTtDQUFFLEdBQ3ZDO0lBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBQztJQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQTtDQUFFLENBQUM7QUFFNUMsTUFBTSxXQUFXLFdBQVcsQ0FBQyxDQUFDLFNBQVMsS0FBSyxHQUFHLEtBQUs7SUFDbEQsVUFBVSxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBQUM7Q0FDaEQ7QUFFRCxlQUFPLE1BQU0sd0JBQXdCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7SUFNcEMsQ0FBQyJ9

package/dest/tx/validator/tx_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tx_validator.d.ts","sourceRoot":"","sources":["../../../src/tx/validator/tx_validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,MAAM,MAAM,KAAK,GAAG,EAAE,GAAG,WAAW,CAAC;AAErC,wBAAgB,SAAS,CAAC,EAAE,EAAE,KAAK,GAAG,MAAM,CAE3C;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,KAAK,GAAG,OAAO,CAEjD;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GACnB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GACvC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE5C,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK;IAClD,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAChD;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIE,CAAC"}
+{"version":3,"file":"tx_validator.d.ts","sourceRoot":"","sources":["../../../src/tx/validator/tx_validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C,MAAM,MAAM,KAAK,GAAG,EAAE,GAAG,WAAW,CAAC;AAErC,wBAAgB,SAAS,CAAC,EAAE,EAAE,KAAK,GAAG,MAAM,CAE3C;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,KAAK,GAAG,OAAO,CAEjD;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GACnB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GACvC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE5C,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK;IAClD,UAAU,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAChD;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;IAMpC,CAAC"}

package/dest/tx/validator/tx_validator.js

@@ -1,14 +1,14 @@
 import { z } from 'zod';
+import { zodFor } from '../../schemas/schemas.js';
 export function getTxHash(tx) {
     return 'txHash' in tx ? tx.txHash : tx.hash;
 }
 export function hasPublicCalls(tx) {
     return tx.data.numberOfPublicCallRequests() > 0;
 }
-export const TxValidationResultSchema = z.discriminatedUnion('result', [
+export const TxValidationResultSchema = zodFor()(z.discriminatedUnion('result', [
     z.object({
-        result: z.literal('valid'),
-        reason: z.array(z.string()).optional()
+        result: z.literal('valid')
     }),
     z.object({
         result: z.literal('invalid'),
@@ -18,4 +18,4 @@ export const TxValidationResultSchema = z.discriminatedUnion('result', [
         result: z.literal('skipped'),
         reason: z.array(z.string())
     })
-]);
+]));

package/dest/validators/schemas.d.ts

@@ -647,4 +647,4 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
     initialSlot?: string | number | bigint | undefined;
     slotWindow: string | number | bigint;
 }>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ZhbGlkYXRvcnMvc2NoZW1hcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBV3hCLGVBQU8sTUFBTSwyQkFBMkIsd0dBTUUsQ0FBQztBQUUzQyxlQUFPLE1BQU0sNEJBQTRCOzs7Ozs7Ozs7OztXQUtDLENBQUM7QUFFM0MsZUFBTyxNQUFNLGlDQUFpQzs7Ozs7Ozs7Ozs7b0JBQXdDLENBQUM7QUFFdkYsZUFBTyxNQUFNLCtCQUErQjs7Ozs7Ozs7Ozs7cUJBQThDLENBQUM7QUFlM0YsZUFBTyxNQUFNLG9CQUFvQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBUUUsQ0FBQztBQUVwQyxlQUFPLE1BQU0scUJBQXFCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBS0UsQ0FBQztBQUVyQyxlQUFPLE1BQU0sMEJBQTBCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBWUUsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ZhbGlkYXRvcnMvc2NoZW1hcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBV3hCLGVBQU8sTUFBTSwyQkFBMkIsd0dBRXZDLENBQUM7QUFFRixlQUFPLE1BQU0sNEJBQTRCOzs7Ozs7Ozs7OztXQU94QyxDQUFDO0FBRUYsZUFBTyxNQUFNLGlDQUFpQzs7Ozs7Ozs7Ozs7b0JBQXdDLENBQUM7QUFFdkYsZUFBTyxNQUFNLCtCQUErQjs7Ozs7Ozs7Ozs7cUJBQThDLENBQUM7QUFpQjNGLGVBQU8sTUFBTSxvQkFBb0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQVVoQyxDQUFDO0FBRUYsZUFBTyxNQUFNLHFCQUFxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQU9qQyxDQUFDO0FBRUYsZUFBTyxNQUFNLDBCQUEwQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQWN0QyxDQUFDIn0=

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,wGAME,CAAC;AAE3C,eAAO,MAAM,4BAA4B;;;;;;;;;;;WAKC,CAAC;AAE3C,eAAO,MAAM,iCAAiC;;;;;;;;;;;oBAAwC,CAAC;AAEvF,eAAO,MAAM,+BAA+B;;;;;;;;;;;qBAA8C,CAAC;AAe3F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQE,CAAC;AAEpC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKE,CAAC;AAErC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYE,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,wGAEvC,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"}

package/dest/validators/schemas.js

@@ -1,16 +1,16 @@
-import { schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 import { z } from 'zod';
-export const ValidatorStatusInSlotSchema = z.enum([
+export const ValidatorStatusInSlotSchema = zodFor()(z.enum([
     'block-mined',
     'block-proposed',
     'block-missed',
     'attestation-sent',
     'attestation-missed'
-]);
-export const ValidatorStatusHistorySchema = z.array(z.object({
+]));
+export const ValidatorStatusHistorySchema = zodFor()(z.array(z.object({
     slot: schemas.SlotNumber,
     status: ValidatorStatusInSlotSchema
-}));
+})));
 export const ValidatorStatusHistorySchemaArray = z.array(ValidatorStatusHistorySchema);
 export const ValidatorStatusHistorySchemaMap = z.record(ValidatorStatusHistorySchemaArray);
 const ValidatorTimeStatSchema = z.object({
@@ -18,13 +18,13 @@ const ValidatorTimeStatSchema = z.object({
     slot: schemas.SlotNumber,
     date: z.string()
 });
-const ValidatorMissedStatsSchema = z.object({
+const ValidatorMissedStatsSchema = zodFor()(z.object({
     currentStreak: schemas.Integer,
     rate: z.number().optional(),
     count: schemas.Integer,
     total: schemas.Integer
-});
-export const ValidatorStatsSchema = z.object({
+}));
+export const ValidatorStatsSchema = zodFor()(z.object({
     address: schemas.EthAddress,
     lastProposal: ValidatorTimeStatSchema.optional(),
     lastAttestation: ValidatorTimeStatSchema.optional(),
@@ -32,14 +32,14 @@ export const ValidatorStatsSchema = z.object({
     missedProposals: ValidatorMissedStatsSchema,
     missedAttestations: ValidatorMissedStatsSchema,
     history: ValidatorStatusHistorySchema
-});
-export const ValidatorsStatsSchema = z.object({
+}));
+export const ValidatorsStatsSchema = zodFor()(z.object({
     stats: z.record(ValidatorStatsSchema),
     lastProcessedSlot: schemas.SlotNumber.optional(),
     initialSlot: schemas.SlotNumber.optional(),
     slotWindow: schemas.Integer
-});
-export const SingleValidatorStatsSchema = z.object({
+}));
+export const SingleValidatorStatsSchema = zodFor()(z.object({
     validator: ValidatorStatsSchema,
     allTimeProvenPerformance: z.array(z.object({
         missed: schemas.Integer,
@@ -49,4 +49,4 @@ export const SingleValidatorStatsSchema = z.object({
     lastProcessedSlot: schemas.SlotNumber.optional(),
     initialSlot: schemas.SlotNumber.optional(),
     slotWindow: schemas.Integer
-});
+}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "3.0.0-nightly.20251216",
+  "version": "3.0.0-nightly.20251218",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -77,13 +77,13 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "3.0.0-nightly.20251216",
-    "@aztec/blob-lib": "3.0.0-nightly.20251216",
-    "@aztec/constants": "3.0.0-nightly.20251216",
-    "@aztec/ethereum": "3.0.0-nightly.20251216",
-    "@aztec/foundation": "3.0.0-nightly.20251216",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20251216",
-    "@aztec/noir-noirc_abi": "3.0.0-nightly.20251216",
+    "@aztec/bb.js": "3.0.0-nightly.20251218",
+    "@aztec/blob-lib": "3.0.0-nightly.20251218",
+    "@aztec/constants": "3.0.0-nightly.20251218",
+    "@aztec/ethereum": "3.0.0-nightly.20251218",
+    "@aztec/foundation": "3.0.0-nightly.20251218",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20251218",
+    "@aztec/noir-noirc_abi": "3.0.0-nightly.20251218",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.12.0",
     "json-stringify-deterministic": "1.0.12",

package/src/abi/abi.ts

@@ -1,7 +1,7 @@
 /* eslint-disable camelcase */
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { inflate } from 'pako';
 import { z } from 'zod';
@@ -154,11 +154,13 @@ export type AbiErrorType =
   | { error_kind: 'fmtstring'; length: number; item_types: AbiType[] }
   | ({ error_kind: 'custom' } & AbiType);
 
-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),
-]) satisfies ZodFor<AbiErrorType>;
+const AbiErrorTypeSchema = zodFor<AbiErrorType>()(
+  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 enum FunctionType {
@@ -242,14 +244,16 @@ export interface FunctionArtifactWithContractName extends FunctionArtifact {
   contractName: string;
 }
 
-export const FunctionArtifactSchema = FunctionAbiSchema.and(
-  z.object({
-    bytecode: schemas.Buffer,
-    verificationKey: z.string().optional(),
-    debugSymbols: z.string(),
-    debug: FunctionDebugMetadataSchema.optional(),
-  }),
-) satisfies ZodFor<FunctionArtifact>;
+export const FunctionArtifactSchema = zodFor<FunctionArtifact>()(
+  FunctionAbiSchema.and(
+    z.object({
+      bytecode: schemas.Buffer,
+      verificationKey: z.string().optional(),
+      debugSymbols: z.string(),
+      debug: FunctionDebugMetadataSchema.optional(),
+    }),
+  ),
+);
 
 /** A file ID. It's assigned during compilation. */
 type FileId = number;
@@ -342,28 +346,30 @@ export interface ContractArtifact {
   fileMap: DebugFileMap;
 }
 
-export const ContractArtifactSchema: ZodFor<ContractArtifact> = z.object({
-  name: z.string(),
-  functions: z.array(FunctionArtifactSchema),
-  nonDispatchPublicFunctions: z.array(FunctionAbiSchema),
-  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 as StructType[]).sort((a, b) => (a.path > b.path ? -1 : 1));
+export const ContractArtifactSchema = zodFor<ContractArtifact>()(
+  z.object({
+    name: z.string(),
+    functions: z.array(FunctionArtifactSchema),
+    nonDispatchPublicFunctions: z.array(FunctionAbiSchema),
+    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 as StructType[]).sort((a, b) => (a.path > b.path ? -1 : 1));
+          }
         }
-      }
-      return structs;
+        return structs;
+      }),
+      globals: z.record(z.array(AbiValueSchema)),
     }),
-    globals: z.record(z.array(AbiValueSchema)),
+    storageLayout: z.record(z.object({ slot: schemas.Fr })),
+    fileMap: z.record(z.coerce.number(), z.object({ source: z.string(), path: z.string() })),
   }),
-  storageLayout: z.record(z.object({ slot: schemas.Fr })),
-  fileMap: z.record(z.coerce.number(), z.object({ source: z.string(), path: z.string() })),
-});
+);
 
 export function getFunctionArtifactByName(artifact: ContractArtifact, functionName: string): FunctionArtifact {
   const functionArtifact = artifact.functions.find(f => f.name === functionName);

package/src/abi/function_selector.ts

@@ -39,6 +39,14 @@ export class FunctionSelector extends Selector {
     return new FunctionSelector(Number(fr.toBigInt()));
   }
 
+  static fromFieldOrUndefined(fr: Fr) {
+    try {
+      return FunctionSelector.fromField(fr);
+    } catch {
+      return undefined;
+    }
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return FunctionSelector.fromField(reader.readField());

package/src/avm/avm.ts

@@ -1148,7 +1148,7 @@ export class CallStackMetadata {
     const { stack, leaf } = failingCall;
     const aztecCallStack = stack.map(call => ({
       contractAddress: AztecAddress.fromField(call.contractAddress),
-      functionSelector: call.calldata.length > 0 ? FunctionSelector.fromField(call.calldata[0]) : undefined,
+      functionSelector: call.calldata.length > 0 ? FunctionSelector.fromFieldOrUndefined(call.calldata[0]) : undefined,
     }));
 
     // The Noir call stack is the internal call stack at exit of the failing call

package/src/block/{published_l2_block.ts → checkpointed_l2_block.ts}

@@ -1,4 +1,5 @@
 // Ignoring import issue to fix portable inferred type issue in zod schema
+import { CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -6,13 +7,67 @@ import { z } from 'zod';
 
 import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import { L2Block } from './l2_block.js';
+import { L2BlockNew } from './l2_block_new.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
- * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
- * L2 blocks do not need to link to L1PublishedData directly.
- * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
+ * Encapsulates an L2 Block along with the checkpoint data associated with it.
  */
+export class CheckpointedL2Block {
+  constructor(
+    public checkpointNumber: CheckpointNumber,
+    public block: L2BlockNew,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
+  static get schema() {
+    return z
+      .object({
+        checkpointNumber: CheckpointNumberSchema,
+        block: L2BlockNew.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => CheckpointedL2Block.fromFields(obj));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpointNumber = reader.readNumber();
+    const block = reader.readObject(L2BlockNew);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new CheckpointedL2Block(
+      CheckpointNumber(checkpointNumber),
+      block,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  static fromFields(fields: FieldsOf<CheckpointedL2Block>) {
+    return new CheckpointedL2Block(
+      CheckpointNumber(fields.checkpointNumber),
+      fields.block,
+      fields.l1,
+      fields.attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}
+
 export class PublishedL2Block {
   constructor(
     public block: L2Block,

package/src/block/index.ts

@@ -7,7 +7,7 @@ export * from './body.js';
 export * from './block_parameter.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
-export * from './published_l2_block.js';
+export * from './checkpointed_l2_block.js';
 export * from './proposal/index.js';
 export * from './validate_block_result.js';
 export * from './l2_block_info.js';

package/src/block/l2_block_source.ts

@@ -1,7 +1,7 @@
 import {
   BlockNumber,
   BlockNumberSchema,
-  type CheckpointNumber,
+  CheckpointNumber,
   type EpochNumber,
   type SlotNumber,
 } from '@aztec/foundation/branded-types';
@@ -18,8 +18,9 @@ import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
+import { type CheckpointedL2Block, PublishedL2Block } from './checkpointed_l2_block.js';
 import type { L2Block } from './l2_block.js';
-import { PublishedL2Block } from './published_l2_block.js';
+import type { L2BlockNew } from './l2_block_new.js';
 import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
 
 /**
@@ -50,13 +51,6 @@ export interface L2BlockSource {
    */
   getProvenBlockNumber(): Promise<BlockNumber>;
 
-  /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */
-  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
-
   /**
    * Gets an l2 block header.
    * @param number - The block number to return or 'latest' for the most recent one.
@@ -65,40 +59,26 @@ export interface L2BlockSource {
   getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined>;
 
   /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The maximum number of blocks to return.
-   * @param proven - If true, only return blocks that have been proven.
-   * @returns The requested L2 blocks.
+   * Gets a checkpointed L2 block by block number.
+   * Returns undefined if the block doesn't exist or hasn't been checkpointed yet.
+   * @param number - The block number to retrieve.
+   * @returns The requested checkpointed L2 block (or undefined if not found or not checkpointed).
    */
-  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
-
-  getPublishedCheckpoints(from: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
   /**
-   * Gets a checkpoint by the archive root, which should be the root of the archive tree after the requested checkpoint
-   * is applied.
-   * @param archive - The new archive root of the checkpoint.
-   * @returns The requested checkpoint (or undefined if not found).
+   * Retrieves a collection of published checkpoints
+   * @param checkpointNumber The first checkpoint to be retrieved
+   * @param limit The number of checkpoints to be retrieved
+   * @returns The collection of complete checkpoints
    */
-  getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined>;
-
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
 
   /**
-   * Gets a published block by its hash.
-   * @param blockHash - The block hash to retrieve.
-   * @returns The requested published block (or undefined if not found).
+   * Gets the checkpoints for a given epoch
+   * @param epochNumber - Epoch for which we want checkpoint data
    */
-  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
-
-  /**
-   * Gets a published block by its archive root.
-   * @param archive - The archive root to retrieve.
-   * @returns The requested published block (or undefined if not found).
-   */
-  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
 
   /**
    * Gets a block header by its hash.
@@ -138,20 +118,6 @@ export interface L2BlockSource {
    */
   getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
-  /**
-   * Returns all checkpoints for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the checkpoint list backwards.
-   * @param epochNumber - The epoch number to return checkpoints for.
-   */
-  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
-
-  /**
-   * Returns all blocks for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the block list backwards.
-   * @param epochNumber - The epoch number to return blocks for.
-   */
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
-
   /**
    * Returns all block headers for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
@@ -195,6 +161,60 @@ export interface L2BlockSource {
 
   /** Force a sync. */
   syncImmediate(): Promise<void>;
+
+  /* Legacy APIS */
+
+  /**
+   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+
+  /**
+   * Returns all blocks for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the block list backwards.
+   * @param epochNumber - The epoch number to return blocks for.
+   */
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
+
+  /**
+   * Gets a published block by its block hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested block (or undefined if not found).
+   */
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets a published block by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block (or undefined if not found).
+   */
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The maximum number of blocks to return.
+   * @param proven - If true, only return blocks that have been proven.
+   * @returns The requested L2 blocks.
+   */
+  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
+
+  /** Equivalent to getBlocks but includes publish data. */
+  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+}
+
+/**
+ * Interface for classes that can receive and store L2 blocks.
+ */
+export interface L2BlockSink {
+  /**
+   * Adds a block to the store.
+   * @param block - The L2 block to add.
+   * @throws If block number is not incremental (i.e., not exactly one more than the last stored block).
+   */
+  addBlock(block: L2BlockNew): Promise<void>;
 }
 
 /**

package/src/block/l2_block_stream/interfaces.ts

@@ -1,5 +1,5 @@
+import type { PublishedL2Block } from '../checkpointed_l2_block.js';
 import type { L2BlockId, L2Tips } from '../l2_block_source.js';
-import type { PublishedL2Block } from '../published_l2_block.js';
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
 export interface L2BlockStreamLocalDataProvider {

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -26,6 +26,10 @@ export class L2BlockStream {
       skipFinalized?: boolean;
     } = {},
   ) {
+    // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
+    // which makes it run periodically, or `sync`, which triggers it once.
+    // Users of L2BlockStream decide what mode to run it in (_periodically_ vs _manually triggered_).
+    // The default is _manually triggered_.
     this.runningPromise = new RunningPromise(() => this.work(), log, this.opts.pollIntervalMS ?? 1000);
   }
 
@@ -42,6 +46,11 @@ export class L2BlockStream {
     return this.runningPromise.isRunning();
   }
 
+  /**
+   * Runs the synchronization process once.
+   *
+   * If you want to run this process continuously use `start` and `stop` instead.
+   */
   public async sync() {
     this.isSyncing = true;
     await this.runningPromise.trigger();

package/src/block/test/l2_tips_store_test_suite.ts

@@ -3,6 +3,7 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
+import { L1PublishedData } from '@aztec/stdlib/checkpoint';
 
 import { jestExpect as expect } from '@jest/expect';
 
@@ -18,7 +19,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
   const makeBlock = (number: number): PublishedL2Block =>
     PublishedL2Block.fromFields({
       block: { number: BlockNumber(number), hash: () => Promise.resolve(new Fr(number)) } as L2Block,
-      l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
+      l1: new L1PublishedData(BigInt(number), BigInt(number), `0x${number}`),
       attestations: [],
     });