@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/dest/update-checker/update-checker.js

@@ -23,7 +23,7 @@ export class UpdateChecker extends EventEmitter {
     runningPromise;
     lastPatchedConfig;
     lastPatchedPublicTelemetryConfig;
-    constructor(updatesUrl, nodeVersion, rollupVersion, fetch1, getLatestRollupVersion, checkIntervalMs = 60_000, log = createLogger('foundation:update-check')){
+    constructor(updatesUrl, nodeVersion, rollupVersion, fetch1, getLatestRollupVersion, checkIntervalMs = 10 * 60_000, log = createLogger('foundation:update-check')){
         super(), this.updatesUrl = updatesUrl, this.nodeVersion = nodeVersion, this.rollupVersion = rollupVersion, this.fetch = fetch1, this.getLatestRollupVersion = getLatestRollupVersion, this.checkIntervalMs = checkIntervalMs, this.log = log, this.lastPatchedConfig = {}, this.lastPatchedPublicTelemetryConfig = {}, this.runChecks = async ()=>{
             await Promise.all([
                 this.checkRollupVersion(),

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/dest/versioning/versioning.d.ts

@@ -7,11 +7,11 @@ export type ComponentsVersions = {
     l1ChainId: number;
     l1RollupAddress: EthAddress;
     rollupVersion: number;
-    l2ProtocolContractsTreeRoot: string;
+    l2ProtocolContractsHash: string;
     l2CircuitsVkTreeRoot: string;
 };
 /** Returns components versions from chain config. */
-export declare function getComponentsVersionsFromConfig(config: ChainConfig, l2ProtocolContractsTreeRoot: string | Fr, l2CircuitsVkTreeRoot: string | Fr): ComponentsVersions;
+export declare function getComponentsVersionsFromConfig(config: ChainConfig, l2ProtocolContractsHash: string | Fr, l2CircuitsVkTreeRoot: string | Fr): ComponentsVersions;
 /** Returns a compressed string representation of the version (around 32 chars). Used in p2p ENRs. */
 export declare function compressComponentVersions(versions: ComponentsVersions): string;
 export declare class ComponentsVersionsError extends Error {

package/dest/versioning/versioning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"versioning.d.ts","sourceRoot":"","sources":["../../src/versioning/versioning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAE3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,8IAA8I;AAC9I,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAC;IAIlB,eAAe,EAAE,UAAU,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,2BAA2B,EAAE,MAAM,CAAC;IACpC,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,qDAAqD;AACrD,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,WAAW,EACnB,2BAA2B,EAAE,MAAM,GAAG,EAAE,EACxC,oBAAoB,EAAE,MAAM,GAAG,EAAE,GAChC,kBAAkB,CAQpB;AAED,qGAAqG;AACrG,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAiB9E;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAIzD;AAED,iGAAiG;AACjG,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,QA6B/F;AAED,8EAA8E;AAC9E,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,QAiBpC;AAED,4EAA4E;AAC5E,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,IAC7D,KAAK,GAAG,CAAC,OAAO,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,mBAS1D;AAED,0FAA0F;AAC1F,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,IACxE,aAAa;IAAE,OAAO,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAA;CAAE,mBAYzF"}
+{"version":3,"file":"versioning.d.ts","sourceRoot":"","sources":["../../src/versioning/versioning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAE3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,8IAA8I;AAC9I,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAC;IAIlB,eAAe,EAAE,UAAU,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB,EAAE,MAAM,CAAC;IAChC,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,qDAAqD;AACrD,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,WAAW,EACnB,uBAAuB,EAAE,MAAM,GAAG,EAAE,EACpC,oBAAoB,EAAE,MAAM,GAAG,EAAE,GAChC,kBAAkB,CAQpB;AAED,qGAAqG;AACrG,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAiB9E;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAIzD;AAED,iGAAiG;AACjG,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,QA6B/F;AAED,8EAA8E;AAC9E,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,QAiBpC;AAED,4EAA4E;AAC5E,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,IAC7D,KAAK,GAAG,CAAC,OAAO,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,mBAc1D;AAED,0FAA0F;AAC1F,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,IACxE,aAAa;IAAE,OAAO,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAA;CAAE,mBAYzF"}

package/dest/versioning/versioning.js

@@ -1,15 +1,15 @@
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-/** Returns components versions from chain config. */ export function getComponentsVersionsFromConfig(config, l2ProtocolContractsTreeRoot, l2CircuitsVkTreeRoot) {
+/** Returns components versions from chain config. */ export function getComponentsVersionsFromConfig(config, l2ProtocolContractsHash, l2CircuitsVkTreeRoot) {
     return {
         l1ChainId: config.l1ChainId,
         l1RollupAddress: config.l1Contracts?.rollupAddress,
         rollupVersion: config.rollupVersion,
-        l2ProtocolContractsTreeRoot: l2ProtocolContractsTreeRoot.toString(),
+        l2ProtocolContractsHash: l2ProtocolContractsHash.toString(),
         l2CircuitsVkTreeRoot: l2CircuitsVkTreeRoot.toString()
     };
 }
 /** Returns a compressed string representation of the version (around 32 chars). Used in p2p ENRs. */ export function compressComponentVersions(versions) {
-    if (versions.l1RollupAddress === undefined || versions.l2ProtocolContractsTreeRoot === undefined || versions.l2CircuitsVkTreeRoot === undefined) {
+    if (versions.l1RollupAddress === undefined || versions.l2ProtocolContractsHash === undefined || versions.l2CircuitsVkTreeRoot === undefined) {
         throw new Error(`Component versions are not set: ${jsonStringify(versions)}`);
     }
     return [
@@ -17,7 +17,7 @@ import { jsonStringify } from '@aztec/foundation/json-rpc';
         versions.l1ChainId,
         versions.l1RollupAddress.toString().slice(2, 10),
         versions.rollupVersion,
-        versions.l2ProtocolContractsTreeRoot.toString().slice(2, 10),
+        versions.l2ProtocolContractsHash.toString().slice(2, 10),
         versions.l2CircuitsVkTreeRoot.toString().slice(2, 10)
     ].join('-');
 }
@@ -28,7 +28,7 @@ export class ComponentsVersionsError extends Error {
     }
 }
 /** Checks if the compressed string matches against the expected versions. Throws on mismatch. */ export function checkCompressedComponentVersion(compressed, expected) {
-    const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsTreeRoot, l2CircuitsVkTreeRoot] = compressed.split('-');
+    const [versionVersion, l1ChainId, l1RollupAddress, rollupVersion, l2ProtocolContractsHash, l2CircuitsVkTreeRoot] = compressed.split('-');
     if (versionVersion !== '00') {
         throw new ComponentsVersionsError('version', '00', versionVersion);
     }
@@ -41,8 +41,8 @@ export class ComponentsVersionsError extends Error {
     if (rollupVersion !== expected.rollupVersion.toString()) {
         throw new ComponentsVersionsError('L2 chain version', expected.rollupVersion.toString(), rollupVersion);
     }
-    if (l2ProtocolContractsTreeRoot !== expected.l2ProtocolContractsTreeRoot.toString().slice(2, 10)) {
-        throw new ComponentsVersionsError(`L2 protocol contracts vk tree root`, expected.l2ProtocolContractsTreeRoot.toString(), l2ProtocolContractsTreeRoot);
+    if (l2ProtocolContractsHash !== expected.l2ProtocolContractsHash.toString().slice(2, 10)) {
+        throw new ComponentsVersionsError(`L2 protocol contracts vk tree root`, expected.l2ProtocolContractsHash.toString(), l2ProtocolContractsHash);
     }
     if (l2CircuitsVkTreeRoot !== expected.l2CircuitsVkTreeRoot.toString().slice(2, 10)) {
         throw new ComponentsVersionsError('L2 circuits vk tree root', expected.l2CircuitsVkTreeRoot.toString(), l2CircuitsVkTreeRoot);
@@ -51,7 +51,7 @@ export class ComponentsVersionsError extends Error {
 /** Checks that two component versions match. Undefined fields are ignored. */ export function validatePartialComponentVersionsMatch(expected, actual) {
     for (const key of [
         'l1RollupAddress',
-        'l2ProtocolContractsTreeRoot',
+        'l2ProtocolContractsHash',
         'l2CircuitsVkTreeRoot',
         'l1ChainId',
         'rollupVersion'
@@ -67,11 +67,16 @@ export class ComponentsVersionsError extends Error {
 }
 /** Returns a Koa middleware that injects the versioning info as headers. */ export function getVersioningMiddleware(versions) {
     return async (ctx, next)=>{
-        await next();
-        for(const key in versions){
-            const value = versions[key];
-            if (value !== undefined) {
-                ctx.set(`x-aztec-${key}`, value.toString());
+        try {
+            await next();
+        } finally{
+            // Always add version headers, even if there was an error
+            // This allows the client to detect version mismatches before processing other errors
+            for(const key in versions){
+                const value = versions[key];
+                if (value !== undefined) {
+                    ctx.set(`x-aztec-${key}`, value.toString());
+                }
             }
         }
     };

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

@@ -0,0 +1,2 @@
+export * from './world_state_revision.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world-state/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dest/world-state/index.js

@@ -0,0 +1 @@
+export * from './world_state_revision.js';

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare class WorldStateRevision {
+    readonly forkId: number;
+    readonly blockNumber: number;
+    readonly includeUncommitted: boolean;
+    constructor(forkId: number, blockNumber: number, includeUncommitted: boolean);
+    static empty(): WorldStateRevision;
+    static get schema(): z.ZodObject<{
+        forkId: z.ZodNumber;
+        blockNumber: z.ZodNumber;
+        includeUncommitted: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        blockNumber: number;
+        forkId: number;
+        includeUncommitted: boolean;
+    }, {
+        blockNumber: number;
+        forkId: number;
+        includeUncommitted: boolean;
+    }>;
+}
+//# sourceMappingURL=world_state_revision.d.ts.map

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

@@ -0,0 +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;aAEX,MAAM,EAAE,MAAM;aACd,WAAW,EAAE,MAAM;aACnB,kBAAkB,EAAE,OAAO;gBAF3B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,OAAO;IAG7C,MAAM,CAAC,KAAK;IAIZ,MAAM,KAAK,MAAM;;;;;;;;;;;;OAMhB;CACF"}

package/dest/world-state/world_state_revision.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export class WorldStateRevision {
+    forkId;
+    blockNumber;
+    includeUncommitted;
+    constructor(forkId, blockNumber, includeUncommitted){
+        this.forkId = forkId;
+        this.blockNumber = blockNumber;
+        this.includeUncommitted = includeUncommitted;
+    }
+    static empty() {
+        return new WorldStateRevision(0, 0, false);
+    }
+    static get schema() {
+        return z.object({
+            forkId: z.number(),
+            blockNumber: z.number(),
+            includeUncommitted: z.boolean()
+        });
+    }
+}

package/dest/zkpassport/index.d.ts

@@ -1,15 +1,21 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/fields';
 export type ViemZkPassportProofParams = {
-    vkeyHash: `0x${string}`;
-    proof: `0x${string}`;
-    publicInputs: `0x${string}`[];
-    committedInputs: `0x${string}`;
-    committedInputCounts: bigint[];
-    validityPeriodInDays: bigint;
-    domain: string;
-    scope: string;
-    devMode: boolean;
+    proofVerificationData: {
+        vkeyHash: `0x${string}`;
+        proof: `0x${string}`;
+        publicInputs: `0x${string}`[];
+    };
+    commitments: {
+        committedInputs: `0x${string}`;
+        committedInputCounts: bigint[];
+    };
+    serviceConfig: {
+        validityPeriodInSeconds: bigint;
+        domain: string;
+        scope: string;
+        devMode: boolean;
+    };
 };
 export declare class ZkPassportProofParams {
     devMode: boolean;
@@ -18,10 +24,10 @@ export declare class ZkPassportProofParams {
     publicInputs: Fr[];
     committedInputs: Buffer;
     committedInputCounts: bigint[];
-    validityPeriodInDays: bigint;
+    validityPeriodInSeconds: bigint;
     domain: string;
     scope: string;
-    constructor(devMode: boolean, vkeyHash: Buffer32, proof: Buffer, publicInputs: Fr[], committedInputs: Buffer, committedInputCounts: bigint[], validityPeriodInDays: bigint, domain: string, scope: string);
+    constructor(devMode: boolean, vkeyHash: Buffer32, proof: Buffer, publicInputs: Fr[], committedInputs: Buffer, committedInputCounts: bigint[], validityPeriodInSeconds: bigint, domain: string, scope: string);
     toBuffer(): Buffer<ArrayBufferLike>;
     static random(): ZkPassportProofParams;
     static fromBuffer(buffer: Buffer): ZkPassportProofParams;

package/dest/zkpassport/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zkpassport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACxB,KAAK,EAAE,KAAK,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,KAAK,MAAM,EAAE,EAAE,CAAC;IAC9B,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAIF,qBAAa,qBAAqB;IAEvB,OAAO,EAAE,OAAO;IAChB,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,MAAM;IACb,YAAY,EAAE,EAAE,EAAE;IAClB,eAAe,EAAE,MAAM;IACvB,oBAAoB,EAAE,MAAM,EAAE;IAC9B,oBAAoB,EAAE,MAAM;IAC5B,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,MAAM;gBARb,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,EAAE,EAAE,EAClB,eAAe,EAAE,MAAM,EACvB,oBAAoB,EAAE,MAAM,EAAE,EAC9B,oBAAoB,EAAE,MAAM,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM;IAGtB,QAAQ;IAkBR,MAAM,CAAC,MAAM;IAqBb,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM;IAehC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,yBAAyB;IAcjD,MAAM,IAAI,yBAAyB;CAapC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/zkpassport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,MAAM,MAAM,yBAAyB,GAAG;IACtC,qBAAqB,EAAE;QACrB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;QACxB,KAAK,EAAE,KAAK,MAAM,EAAE,CAAC;QACrB,YAAY,EAAE,KAAK,MAAM,EAAE,EAAE,CAAC;KAC/B,CAAC;IACF,WAAW,EAAE;QACX,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;QAC/B,oBAAoB,EAAE,MAAM,EAAE,CAAC;KAChC,CAAC;IACF,aAAa,EAAE;QACb,uBAAuB,EAAE,MAAM,CAAC;QAChC,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH,CAAC;AAIF,qBAAa,qBAAqB;IAEvB,OAAO,EAAE,OAAO;IAChB,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,MAAM;IACb,YAAY,EAAE,EAAE,EAAE;IAClB,eAAe,EAAE,MAAM;IACvB,oBAAoB,EAAE,MAAM,EAAE;IAC9B,uBAAuB,EAAE,MAAM;IAC/B,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,MAAM;gBARb,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,EAAE,EAAE,EAClB,eAAe,EAAE,MAAM,EACvB,oBAAoB,EAAE,MAAM,EAAE,EAC9B,uBAAuB,EAAE,MAAM,EAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM;IAGtB,QAAQ;IAkBR,MAAM,CAAC,MAAM;IAqBb,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM;IAehC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,yBAAyB;IAcjD,MAAM,IAAI,yBAAyB;CAmBpC"}

package/dest/zkpassport/index.js

@@ -12,17 +12,17 @@ export class ZkPassportProofParams {
     publicInputs;
     committedInputs;
     committedInputCounts;
-    validityPeriodInDays;
+    validityPeriodInSeconds;
     domain;
     scope;
-    constructor(devMode, vkeyHash, proof, publicInputs, committedInputs, committedInputCounts, validityPeriodInDays, domain, scope){
+    constructor(devMode, vkeyHash, proof, publicInputs, committedInputs, committedInputCounts, validityPeriodInSeconds, domain, scope){
         this.devMode = devMode;
         this.vkeyHash = vkeyHash;
         this.proof = proof;
         this.publicInputs = publicInputs;
         this.committedInputs = committedInputs;
         this.committedInputCounts = committedInputCounts;
-        this.validityPeriodInDays = validityPeriodInDays;
+        this.validityPeriodInSeconds = validityPeriodInSeconds;
         this.domain = domain;
         this.scope = scope;
     }
@@ -38,7 +38,7 @@ export class ZkPassportProofParams {
             this.committedInputs,
             this.committedInputCounts.length,
             this.committedInputCounts,
-            this.validityPeriodInDays,
+            this.validityPeriodInSeconds,
             this.domain,
             this.scope
         ]);
@@ -56,26 +56,32 @@ export class ZkPassportProofParams {
         const publicInputs = Array.from({
             length: Number(publicInputsCount)
         }, ()=>Fr.random());
-        return new ZkPassportProofParams(false, Buffer32.random(), randomBytes(1024), publicInputs, committedInputs, committedInputCounts, BigInt(100), 'sequencer.alpha-testnet.aztec.network', 'personhood');
+        return new ZkPassportProofParams(false, Buffer32.random(), randomBytes(1024), publicInputs, committedInputs, committedInputCounts, BigInt(7 * 24 * 60 * 60), 'sequencer.alpha-testnet.aztec.network', 'personhood');
     }
     static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
         return new ZkPassportProofParams(reader.readBoolean(), reader.readObject(Buffer32), reader.readBuffer(), reader.readVector(Fr), reader.readBuffer(), reader.readUint256Vector(), reader.readUInt256(), reader.readString(), reader.readString());
     }
     static fromViem(params) {
-        return new ZkPassportProofParams(params.devMode, Buffer32.fromString(params.vkeyHash), Buffer.from(withoutHexPrefix(params.proof), 'hex'), params.publicInputs.map((input)=>Fr.fromString(input)), Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'), params.committedInputCounts, params.validityPeriodInDays, params.domain, params.scope);
+        return new ZkPassportProofParams(params.serviceConfig.devMode, Buffer32.fromString(params.proofVerificationData.vkeyHash), Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'), params.proofVerificationData.publicInputs.map((input)=>Fr.fromString(input)), Buffer.from(withoutHexPrefix(params.commitments.committedInputs), 'hex'), params.commitments.committedInputCounts, params.serviceConfig.validityPeriodInSeconds, params.serviceConfig.domain, params.serviceConfig.scope);
     }
     toViem() {
         return {
-            devMode: this.devMode,
-            vkeyHash: this.vkeyHash.toString(),
-            proof: `0x${this.proof.toString('hex')}`,
-            publicInputs: this.publicInputs.map((input)=>input.toString()),
-            committedInputs: `0x${this.committedInputs.toString('hex')}`,
-            committedInputCounts: this.committedInputCounts,
-            validityPeriodInDays: this.validityPeriodInDays,
-            domain: this.domain,
-            scope: this.scope
+            serviceConfig: {
+                devMode: this.devMode,
+                validityPeriodInSeconds: this.validityPeriodInSeconds,
+                domain: this.domain,
+                scope: this.scope
+            },
+            proofVerificationData: {
+                vkeyHash: this.vkeyHash.toString(),
+                proof: `0x${this.proof.toString('hex')}`,
+                publicInputs: this.publicInputs.map((input)=>input.toString())
+            },
+            commitments: {
+                committedInputs: `0x${this.committedInputs.toString('hex')}`,
+                committedInputCounts: this.committedInputCounts
+            }
         };
     }
 }