@aztec/stdlib 2.0.0-nightly.20250903 → 2.0.0-rc.10

package/dest/tx/tree_snapshots.d.ts

@@ -7,10 +7,10 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
  * Stores snapshots of all the trees but archive.
  */
 export declare class TreeSnapshots {
-    readonly l1ToL2MessageTree: AppendOnlyTreeSnapshot;
-    readonly noteHashTree: AppendOnlyTreeSnapshot;
-    readonly nullifierTree: AppendOnlyTreeSnapshot;
-    readonly publicDataTree: AppendOnlyTreeSnapshot;
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    noteHashTree: AppendOnlyTreeSnapshot;
+    nullifierTree: AppendOnlyTreeSnapshot;
+    publicDataTree: AppendOnlyTreeSnapshot;
     constructor(l1ToL2MessageTree: AppendOnlyTreeSnapshot, noteHashTree: AppendOnlyTreeSnapshot, nullifierTree: AppendOnlyTreeSnapshot, publicDataTree: AppendOnlyTreeSnapshot);
     static get schema(): z.ZodEffects<z.ZodObject<{
         l1ToL2MessageTree: z.ZodEffects<z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"tree_snapshots.d.ts","sourceRoot":"","sources":["../../src/tx/tree_snapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;GAEG;AACH,qBAAa,aAAa;aAEN,iBAAiB,EAAE,sBAAsB;aACzC,YAAY,EAAE,sBAAsB;aACpC,aAAa,EAAE,sBAAsB;aACrC,cAAc,EAAE,sBAAsB;gBAHtC,iBAAiB,EAAE,sBAAsB,EACzC,YAAY,EAAE,sBAAsB,EACpC,aAAa,EAAE,sBAAsB,EACrC,cAAc,EAAE,sBAAsB;IAGxD,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAYhB;IAED,OAAO;IASP,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAU/D,QAAQ;IAKR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAW5C,QAAQ,IAAI,EAAE,EAAE;IAehB,MAAM,CAAC,KAAK,IAAI,aAAa;IAS7B,OAAO,IAAI,OAAO;IASlB,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB"}
+{"version":3,"file":"tree_snapshots.d.ts","sourceRoot":"","sources":["../../src/tx/tree_snapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;GAEG;AACH,qBAAa,aAAa;IAEf,iBAAiB,EAAE,sBAAsB;IACzC,YAAY,EAAE,sBAAsB;IACpC,aAAa,EAAE,sBAAsB;IACrC,cAAc,EAAE,sBAAsB;gBAHtC,iBAAiB,EAAE,sBAAsB,EACzC,YAAY,EAAE,sBAAsB,EACpC,aAAa,EAAE,sBAAsB,EACrC,cAAc,EAAE,sBAAsB;IAG/C,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAYhB;IAED,OAAO;IASP,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAU/D,QAAQ;IAKR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAW5C,QAAQ,IAAI,EAAE,EAAE;IAehB,MAAM,CAAC,KAAK,IAAI,aAAa;IAS7B,OAAO,IAAI,OAAO;IASlB,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB"}

package/dest/validators/schemas.d.ts

@@ -63,26 +63,32 @@ export declare const ValidatorStatsSchema: z.ZodObject<{
         currentStreak: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
         rate: z.ZodOptional<z.ZodNumber>;
         count: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        total: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         currentStreak: number;
         count: number;
+        total: number;
         rate?: number | undefined;
     }, {
         currentStreak: string | number | bigint;
         count: string | number | bigint;
+        total: string | number | bigint;
         rate?: number | undefined;
     }>;
     missedAttestations: z.ZodObject<{
         currentStreak: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
         rate: z.ZodOptional<z.ZodNumber>;
         count: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        total: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         currentStreak: number;
         count: number;
+        total: number;
         rate?: number | undefined;
     }, {
         currentStreak: string | number | bigint;
         count: string | number | bigint;
+        total: string | number | bigint;
         rate?: number | undefined;
     }>;
     history: z.ZodArray<z.ZodObject<{
@@ -101,11 +107,13 @@ export declare const ValidatorStatsSchema: z.ZodObject<{
     missedProposals: {
         currentStreak: number;
         count: number;
+        total: number;
         rate?: number | undefined;
     };
     missedAttestations: {
         currentStreak: number;
         count: number;
+        total: number;
         rate?: number | undefined;
     };
     history: {
@@ -128,11 +136,13 @@ export declare const ValidatorStatsSchema: z.ZodObject<{
     missedProposals: {
         currentStreak: string | number | bigint;
         count: string | number | bigint;
+        total: string | number | bigint;
         rate?: number | undefined;
     };
     missedAttestations: {
         currentStreak: string | number | bigint;
         count: string | number | bigint;
+        total: string | number | bigint;
         rate?: number | undefined;
     };
     history: {
@@ -184,26 +194,32 @@ export declare const ValidatorsStatsSchema: z.ZodObject<{
             currentStreak: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
             rate: z.ZodOptional<z.ZodNumber>;
             count: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            total: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         }, {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         }>;
         missedAttestations: z.ZodObject<{
             currentStreak: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
             rate: z.ZodOptional<z.ZodNumber>;
             count: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            total: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         }, {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         }>;
         history: z.ZodArray<z.ZodObject<{
@@ -222,11 +238,13 @@ export declare const ValidatorsStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         history: {
@@ -249,11 +267,13 @@ export declare const ValidatorsStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         history: {
@@ -281,11 +301,13 @@ export declare const ValidatorsStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         history: {
@@ -313,11 +335,13 @@ export declare const ValidatorsStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         history: {
@@ -373,26 +397,32 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
             currentStreak: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
             rate: z.ZodOptional<z.ZodNumber>;
             count: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            total: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         }, {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         }>;
         missedAttestations: z.ZodObject<{
             currentStreak: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
             rate: z.ZodOptional<z.ZodNumber>;
             count: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+            total: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         }, {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         }>;
         history: z.ZodArray<z.ZodObject<{
@@ -411,11 +441,13 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         history: {
@@ -438,11 +470,13 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         history: {
@@ -466,12 +500,12 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
         epoch: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     }, "strip", z.ZodTypeAny, {
         epoch: bigint;
-        missed: number;
         total: number;
+        missed: number;
     }, {
         epoch: string | number | bigint;
-        missed: string | number | bigint;
         total: string | number | bigint;
+        missed: string | number | bigint;
     }>, "many">;
     lastProcessedSlot: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>>;
     initialSlot: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>>;
@@ -484,11 +518,13 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: number;
             count: number;
+            total: number;
             rate?: number | undefined;
         };
         history: {
@@ -508,8 +544,8 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
     };
     allTimeProvenPerformance: {
         epoch: bigint;
-        missed: number;
         total: number;
+        missed: number;
     }[];
     lastProcessedSlot?: bigint | undefined;
     initialSlot?: bigint | undefined;
@@ -521,11 +557,13 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
         missedProposals: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         missedAttestations: {
             currentStreak: string | number | bigint;
             count: string | number | bigint;
+            total: string | number | bigint;
             rate?: number | undefined;
         };
         history: {
@@ -545,8 +583,8 @@ export declare const SingleValidatorStatsSchema: z.ZodObject<{
     };
     allTimeProvenPerformance: {
         epoch: string | number | bigint;
-        missed: string | number | bigint;
         total: string | number | bigint;
+        missed: string | number | bigint;
     }[];
     lastProcessedSlot?: string | number | bigint | undefined;
     initialSlot?: string | number | bigint | undefined;

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;AAUxB,eAAO,MAAM,2BAA2B,wGAME,CAAC;AAE3C,eAAO,MAAM,4BAA4B;;;;;;;;;WAKC,CAAC;AAE3C,eAAO,MAAM,iCAAiC;;;;;;;;;oBAAwC,CAAC;AAEvF,eAAO,MAAM,+BAA+B;;;;;;;;;qBAA8C,CAAC;AAc3F,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,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"}

package/dest/validators/schemas.js

@@ -18,18 +18,19 @@ const ValidatorTimeStatSchema = z.object({
     slot: schemas.BigInt,
     date: z.string()
 });
-const ValidatorFilteredHistorySchema = z.object({
+const ValidatorMissedStatsSchema = z.object({
     currentStreak: schemas.Integer,
     rate: z.number().optional(),
-    count: schemas.Integer
+    count: schemas.Integer,
+    total: schemas.Integer
 });
 export const ValidatorStatsSchema = z.object({
     address: schemas.EthAddress,
     lastProposal: ValidatorTimeStatSchema.optional(),
     lastAttestation: ValidatorTimeStatSchema.optional(),
     totalSlots: schemas.Integer,
-    missedProposals: ValidatorFilteredHistorySchema,
-    missedAttestations: ValidatorFilteredHistorySchema,
+    missedProposals: ValidatorMissedStatsSchema,
+    missedAttestations: ValidatorMissedStatsSchema,
     history: ValidatorStatusHistorySchema
 });
 export const ValidatorsStatsSchema = z.object({

package/dest/validators/types.d.ts

@@ -5,6 +5,12 @@ export type ValidatorStatusHistory = {
     slot: bigint;
     status: ValidatorStatusInSlot;
 }[];
+export type ValidatorMissedStats = {
+    currentStreak: number;
+    rate?: number;
+    count: number;
+    total: number;
+};
 export type ValidatorStats = {
     address: EthAddress;
     lastProposal?: {
@@ -18,16 +24,8 @@ export type ValidatorStats = {
         date: string;
     };
     totalSlots: number;
-    missedProposals: {
-        currentStreak: number;
-        rate?: number;
-        count: number;
-    };
-    missedAttestations: {
-        currentStreak: number;
-        rate?: number;
-        count: number;
-    };
+    missedProposals: ValidatorMissedStats;
+    missedAttestations: ValidatorMissedStats;
     history: ValidatorStatusHistory;
 };
 export type ValidatorsStats = {

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/validators/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,aAAa,CAAC;AAE1D,MAAM,MAAM,qBAAqB,GAC7B,aAAa,GACb,gBAAgB,GAChB,cAAc,GACd,kBAAkB,GAClB,oBAAoB,CAAC;AAEzB,MAAM,MAAM,sBAAsB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,EAAE,CAAC;AAEvF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,UAAU,CAAC;IACpB,YAAY,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACjE,eAAe,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACpE,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE;QACf,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,kBAAkB,EAAE;QAClB,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,OAAO,EAAE,sBAAsB,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,KAAK,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElG,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,cAAc,CAAC;IAC1B,wBAAwB,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/validators/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,aAAa,CAAC;AAE1D,MAAM,MAAM,qBAAqB,GAC7B,aAAa,GACb,gBAAgB,GAChB,cAAc,GACd,kBAAkB,GAClB,oBAAoB,CAAC;AAEzB,MAAM,MAAM,sBAAsB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,EAAE,CAAC;AAEvF,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,UAAU,CAAC;IACpB,YAAY,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACjE,eAAe,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACpE,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,oBAAoB,CAAC;IACtC,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,OAAO,EAAE,sBAAsB,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,KAAK,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElG,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,cAAc,CAAC;IAC1B,wBAAwB,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "2.0.0-nightly.20250903",
+  "version": "2.0.0-rc.10",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -69,13 +69,13 @@
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "dependencies": {
-    "@aztec/bb.js": "2.0.0-nightly.20250903",
-    "@aztec/blob-lib": "2.0.0-nightly.20250903",
-    "@aztec/constants": "2.0.0-nightly.20250903",
-    "@aztec/ethereum": "2.0.0-nightly.20250903",
-    "@aztec/foundation": "2.0.0-nightly.20250903",
-    "@aztec/l1-artifacts": "2.0.0-nightly.20250903",
-    "@aztec/noir-noirc_abi": "2.0.0-nightly.20250903",
+    "@aztec/bb.js": "2.0.0-rc.10",
+    "@aztec/blob-lib": "2.0.0-rc.10",
+    "@aztec/constants": "2.0.0-rc.10",
+    "@aztec/ethereum": "2.0.0-rc.10",
+    "@aztec/foundation": "2.0.0-rc.10",
+    "@aztec/l1-artifacts": "2.0.0-rc.10",
+    "@aztec/noir-noirc_abi": "2.0.0-rc.10",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.9.0",
     "json-stringify-deterministic": "1.0.12",
@@ -92,6 +92,7 @@
   "devDependencies": {
     "@jest/expect": "^30.0.0",
     "@jest/globals": "^30.0.0",
+    "@libp2p/interface": "1.3.1",
     "@types/jest": "^30.0.0",
     "@types/lodash.chunk": "^4.2.9",
     "@types/lodash.isequal": "^4.5.8",

package/src/avm/avm.ts

@@ -408,15 +408,12 @@ export class AvmTxHint {
     public readonly feePayer: AztecAddress,
   ) {}
 
-  static fromTx(tx: Tx): AvmTxHint {
+  static fromTx(tx: Tx, gasFees: GasFees): AvmTxHint {
     const setupCallRequests = tx.getNonRevertiblePublicCallRequestsWithCalldata();
     const appLogicCallRequests = tx.getRevertiblePublicCallRequestsWithCalldata();
     const teardownCallRequest = tx.getTeardownPublicCallRequestWithCalldata();
     const gasSettings = tx.data.constants.txContext.gasSettings;
-    const effectiveGasFees = computeEffectiveGasFees(
-      tx.data.constants.historicalHeader.globalVariables.gasFees,
-      gasSettings,
-    );
+    const effectiveGasFees = computeEffectiveGasFees(gasFees, gasSettings);
 
     // For informational purposes. Assumed quick because it should be cached.
     const txHash = tx.getTxHash();

package/src/epoch-helpers/index.ts

@@ -56,7 +56,10 @@ export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants,
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
-export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
+export function getSlotRangeForEpoch(
+  epochNumber: bigint,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): [bigint, bigint] {
   const startSlot = epochNumber * BigInt(constants.epochDuration);
   return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
 }
@@ -68,7 +71,7 @@ export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1Roll
 export function getTimestampRangeForEpoch(
   epochNumber: bigint,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
-) {
+): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
   const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
   return [
@@ -79,6 +82,17 @@ export function getTimestampRangeForEpoch(
   ];
 }
 
+/**
+ * Returns the start timestamp for a given epoch number.
+ */
+export function getStartTimestampForEpoch(
+  epochNumber: bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>,
+) {
+  const [startSlot] = getSlotRangeForEpoch(epochNumber, constants);
+  return getTimestampForSlot(startSlot, constants);
+}
+
 /**
  * Returns the epoch number at which proofs are no longer accepted for a given epoch.
  * See l1-contracts/src/core/libraries/TimeLib.sol

package/src/fees/transaction_fee.ts

@@ -1,5 +1,7 @@
 import type { Fr } from '@aztec/foundation/fields';
 
+import { strict as assert } from 'assert';
+
 import type { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
 import type { GasSettings } from '../gas/gas_settings.js';
@@ -11,6 +13,15 @@ import type { GasSettings } from '../gas/gas_settings.js';
 export function computeEffectiveGasFees(gasFees: GasFees, gasSettings: GasSettings): GasFees {
   const { maxFeesPerGas, maxPriorityFeesPerGas } = gasSettings;
   const minBigInt = (f1: bigint, f2: bigint) => (f1 < f2 ? f1 : f2);
+
+  assert(
+    maxFeesPerGas.feePerDaGas >= gasFees.feePerDaGas,
+    `maxFeesPerGas.feePerDaGas must be greater than or equal to gasFees.feePerDaGas, but got maxFeesPerGas.feePerDaGas=${maxFeesPerGas.feePerDaGas} and gasFees.feePerDaGas=${gasFees.feePerDaGas}`,
+  );
+  assert(
+    maxFeesPerGas.feePerL2Gas >= gasFees.feePerL2Gas,
+    `maxFeesPerGas.feePerL2Gas must be greater than or equal to gasFees.feePerL2Gas, but got maxFeesPerGas.feePerL2Gas=${maxFeesPerGas.feePerL2Gas} and gasFees.feePerL2Gas=${gasFees.feePerL2Gas}`,
+  );
   const priorityFees = new GasFees(
     minBigInt(maxPriorityFeesPerGas.feePerDaGas, maxFeesPerGas.feePerDaGas - gasFees.feePerDaGas),
     minBigInt(maxPriorityFeesPerGas.feePerL2Gas, maxFeesPerGas.feePerL2Gas - gasFees.feePerL2Gas),

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

@@ -8,6 +8,7 @@ import { type ComponentsVersions, getVersioningResponseHandler } from '../versio
 import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
 import { type ProverConfig, ProverConfigSchema } from './prover-client.js';
 import { type SlasherConfig, SlasherConfigSchema } from './slasher.js';
+import { ValidatorClientConfigSchema, type ValidatorClientFullConfig } from './validator.js';
 
 /**
  * Aztec node admin API.
@@ -50,10 +51,14 @@ export interface AztecNodeAdmin {
   getSlashOffenses(round: bigint | 'all' | 'current'): Promise<Offense[]>;
 }
 
-export type AztecNodeAdminConfig = SequencerConfig & ProverConfig & SlasherConfig & { maxTxPoolSize: number };
+export type AztecNodeAdminConfig = ValidatorClientFullConfig &
+  SequencerConfig &
+  ProverConfig &
+  SlasherConfig & { maxTxPoolSize: number };
 
 export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
   .merge(SlasherConfigSchema)
+  .merge(ValidatorClientConfigSchema)
   .merge(z.object({ maxTxPoolSize: z.number() }));
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {

package/src/interfaces/server.ts

@@ -21,4 +21,5 @@ export * from './server_circuit_prover.js';
 export * from './service.js';
 export * from './slasher.js';
 export * from './tx_provider.js';
+export * from './validator.js';
 export * from './world_state.js';

package/src/interfaces/slasher.ts

@@ -13,6 +13,7 @@ export interface SlasherConfig {
   slashValidatorsAlways: EthAddress[]; // Array of validator addresses
   slashValidatorsNever: EthAddress[]; // Array of validator addresses
   slashInactivityTargetPercentage: number; // 0-1, 0.9 means 90%. Must be greater than 0
+  slashInactivityConsecutiveEpochThreshold: number; // Number of consecutive epochs a validator must be inactive before slashing
   slashPrunePenalty: bigint;
   slashDataWithholdingPenalty: bigint;
   slashInactivityPenalty: bigint;
@@ -34,6 +35,7 @@ export const SlasherConfigSchema = z.object({
   slashPrunePenalty: schemas.BigInt,
   slashDataWithholdingPenalty: schemas.BigInt,
   slashInactivityTargetPercentage: z.number(),
+  slashInactivityConsecutiveEpochThreshold: z.number(),
   slashInactivityPenalty: schemas.BigInt,
   slashProposeInvalidAttestationsPenalty: schemas.BigInt,
   slashAttestDescendantOfInvalidPenalty: schemas.BigInt,

package/src/interfaces/validator.ts

@@ -0,0 +1,70 @@
+import type { SecretValue } from '@aztec/foundation/config';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
+import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+import { z } from 'zod';
+
+/**
+ * Validator client configuration
+ */
+export interface ValidatorClientConfig {
+  /** The private keys of the validators participating in attestation duties */
+  validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
+
+  /** The addresses of the validators to use with remote signers */
+  validatorAddresses?: EthAddress[];
+
+  /** Do not run the validator */
+  disableValidator: boolean;
+
+  /** Temporarily disable these specific validator addresses */
+  disabledValidators: EthAddress[];
+
+  /** Interval between polling for new attestations from peers */
+  attestationPollingIntervalMs: number;
+
+  /** Re-execute transactions before attesting */
+  validatorReexecute: boolean;
+
+  /** Will re-execute until this many milliseconds are left in the slot */
+  validatorReexecuteDeadlineMs: number;
+}
+
+export type ValidatorClientFullConfig = ValidatorClientConfig &
+  Pick<SequencerConfig, 'txPublicSetupAllowList'> &
+  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'>;
+
+export const ValidatorClientConfigSchema = z.object({
+  validatorAddresses: z.array(schemas.EthAddress).optional(),
+  disableValidator: z.boolean(),
+  disabledValidators: z.array(schemas.EthAddress),
+  attestationPollingIntervalMs: z.number().min(0),
+  validatorReexecute: z.boolean(),
+  validatorReexecuteDeadlineMs: z.number().min(0),
+}) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
+
+export interface Validator {
+  start(): Promise<void>;
+  registerBlockProposalHandler(): void;
+  updateConfig(config: Partial<ValidatorClientFullConfig>): void;
+
+  // Block validation responsibilities
+  createBlockProposal(
+    blockNumber: number,
+    header: ProposedBlockHeader,
+    archive: Fr,
+    stateReference: StateReference,
+    txs: Tx[],
+    proposerAddress: EthAddress | undefined,
+    options: BlockProposalOptions,
+  ): Promise<BlockProposal | undefined>;
+  attestToProposal(proposal: BlockProposal, sender: PeerId): Promise<BlockAttestation[] | undefined>;
+
+  broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
+  collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+}

package/src/rollup/block_constant_data.ts

@@ -12,8 +12,8 @@ export class BlockConstantData {
   constructor(
     /** Archive tree snapshot at the very beginning of the entire rollup. */
     public lastArchive: AppendOnlyTreeSnapshot,
-    /** L1 to L2 message tree snapshot at the very beginning of the entire rollup. */
-    public lastL1ToL2: AppendOnlyTreeSnapshot,
+    /** L1 to L2 message tree snapshot after this block lands. */
+    public newL1ToL2: AppendOnlyTreeSnapshot,
     /** Root of the verification key tree. */
     public vkTreeRoot: Fr,
     /** Root of the protocol contract tree. */
@@ -40,7 +40,7 @@ export class BlockConstantData {
   static getFields(fields: FieldsOf<BlockConstantData>) {
     return [
       fields.lastArchive,
-      fields.lastL1ToL2,
+      fields.newL1ToL2,
       fields.vkTreeRoot,
       fields.protocolContractTreeRoot,
       fields.globalVariables,

package/src/tests/factories.ts

@@ -1607,6 +1607,7 @@ export async function makeBloatedProcessedTx({
   vkTreeRoot = Fr.ZERO,
   protocolContractTreeRoot = Fr.ZERO,
   globalVariables = GlobalVariables.empty(),
+  newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(),
   feePayer,
   feePaymentPublicDataWrite,
   privateOnly = false,
@@ -1619,6 +1620,7 @@ export async function makeBloatedProcessedTx({
   gasSettings?: GasSettings;
   vkTreeRoot?: Fr;
   globalVariables?: GlobalVariables;
+  newL1ToL2Snapshot?: AppendOnlyTreeSnapshot;
   protocolContractTreeRoot?: Fr;
   feePayer?: AztecAddress;
   feePaymentPublicDataWrite?: PublicDataWrite;
@@ -1672,6 +1674,9 @@ export async function makeBloatedProcessedTx({
 
     // Create avm output.
     const avmOutput = AvmCircuitPublicInputs.empty();
+    // Assign data from hints.
+    avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+    avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
     // Assign data from private.
     avmOutput.globalVariables = globalVariables;
     avmOutput.startGasUsed = tx.data.gasUsed;
@@ -1715,6 +1720,7 @@ export async function makeBloatedProcessedTx({
     avmOutput.gasSettings = gasSettings;
 
     const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
+    avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;
 
     const gasUsed = {
       totalGas: Gas.empty(),