@xyo-network/xl1-protocol 5.0.2 → 5.0.3

package/dist/neutral/modules/network-model/staticRest/layout/index.d.ts

@@ -2,4 +2,5 @@ export * from './chainContractManifest.js';
 export * from './chainManifest.js';
 export * from './evmEventIndex.js';
 export * from './indexManifest.js';
+export * from './networkStakeRewardsIndex.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA"}

package/dist/neutral/modules/network-model/staticRest/layout/networkStakeRewardsIndex.d.ts

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+/** Version of the durable network-stake rewards index layout. */
+export declare const NETWORK_STAKE_REWARDS_INDEX_LAYOUT: "network-stake-rewards-v1";
+/** Default reward policy identifier for unmultiplied protocol rewards. */
+export declare const NETWORK_STAKE_REWARDS_BASE_POLICY: "base-v1";
+/** Path-safe identifier for a deterministic reward policy. */
+export declare const NetworkStakeRewardsPolicyIdZod: z.ZodString;
+/** Static policy and source description for one rewards index tree. */
+export declare const NetworkStakeRewardsIndexManifestZod: z.ZodObject<{
+    evmAddress: z.ZodString;
+    evmChainId: z.ZodString;
+    layout: z.ZodLiteral<"network-stake-rewards-v1">;
+    policyId: z.ZodString;
+    stepLevels: z.ZodArray<z.ZodNumber>;
+    timeAnchor: z.ZodOptional<z.ZodObject<{
+        externalGenesisTime: z.ZodOptional<z.ZodNumber>;
+        maxScanBlocks: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Static policy and source description for one rewards index tree. */
+export type NetworkStakeRewardsIndexManifest = z.infer<typeof NetworkStakeRewardsIndexManifestZod>;
+/** Immutable reward allocation for one completed XL1 reward step. */
+export declare const NetworkStakeRewardsIndexStepZod: z.ZodObject<{
+    denominator: z.ZodString;
+    externalRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    layout: z.ZodLiteral<"network-stake-rewards-v1">;
+    policyId: z.ZodString;
+    positionRewards: z.ZodRecord<z.ZodString, z.ZodString>;
+    step: z.ZodObject<{
+        block: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>;
+    totalReward: z.ZodString;
+    xl1Range: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strip>;
+/** Immutable reward allocation for one completed XL1 reward step. */
+export type NetworkStakeRewardsIndexStep = z.infer<typeof NetworkStakeRewardsIndexStepZod>;
+/** Immutable cumulative position totals referenced by a mutable head. */
+export declare const NetworkStakeRewardsIndexSnapshotZod: z.ZodObject<{
+    layout: z.ZodLiteral<"network-stake-rewards-v1">;
+    policyId: z.ZodString;
+    positionRewards: z.ZodRecord<z.ZodString, z.ZodString>;
+    stepCount: z.ZodNumber;
+    totalReward: z.ZodString;
+}, z.core.$strip>;
+/** Immutable cumulative position totals referenced by a mutable head. */
+export type NetworkStakeRewardsIndexSnapshot = z.infer<typeof NetworkStakeRewardsIndexSnapshotZod>;
+/** Mutable pointer written only after every referenced step and snapshot is durable. */
+export declare const NetworkStakeRewardsIndexHeadZod: z.ZodObject<{
+    layout: z.ZodLiteral<"network-stake-rewards-v1">;
+    policyId: z.ZodString;
+    positionCount: z.ZodNumber;
+    processedThroughBlock: z.ZodNumber;
+    snapshot: z.ZodString;
+    source: z.ZodObject<{
+        evm: z.ZodObject<{
+            block: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strip>;
+        xl1: z.ZodObject<{
+            block: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    stepCount: z.ZodNumber;
+}, z.core.$strip>;
+/** Mutable pointer written only after every referenced step and snapshot is durable. */
+export type NetworkStakeRewardsIndexHead = z.infer<typeof NetworkStakeRewardsIndexHeadZod>;
+/** Checks whether a value is a valid rewards index manifest. */
+export declare const isNetworkStakeRewardsIndexManifest: <T>(value: T) => value is T & {
+    evmAddress: string;
+    evmChainId: string;
+    layout: "network-stake-rewards-v1";
+    policyId: string;
+    stepLevels: number[];
+    timeAnchor?: {
+        externalGenesisTime?: number | undefined;
+        maxScanBlocks?: number | undefined;
+    } | undefined;
+};
+/** Converts a value to a rewards index manifest, throwing if invalid. */
+export declare const asNetworkStakeRewardsIndexManifest: {
+    <T>(value: T): (T & {
+        evmAddress: string;
+        evmChainId: string;
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        stepLevels: number[];
+        timeAnchor?: {
+            externalGenesisTime?: number | undefined;
+            maxScanBlocks?: number | undefined;
+        } | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        evmAddress: string;
+        evmChainId: string;
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        stepLevels: number[];
+        timeAnchor?: {
+            externalGenesisTime?: number | undefined;
+            maxScanBlocks?: number | undefined;
+        } | undefined;
+    };
+};
+/** Converts a value to a rewards index step, throwing if invalid. */
+export declare const asNetworkStakeRewardsIndexStep: {
+    <T>(value: T): (T & {
+        denominator: string;
+        externalRange: [number, number];
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        positionRewards: Record<string, string>;
+        step: {
+            block: number;
+            step: number;
+        };
+        totalReward: string;
+        xl1Range: [number, number];
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        denominator: string;
+        externalRange: [number, number];
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        positionRewards: Record<string, string>;
+        step: {
+            block: number;
+            step: number;
+        };
+        totalReward: string;
+        xl1Range: [number, number];
+    };
+};
+/** Converts a value to a rewards index snapshot, throwing if invalid. */
+export declare const asNetworkStakeRewardsIndexSnapshot: {
+    <T>(value: T): (T & {
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        positionRewards: Record<string, string>;
+        stepCount: number;
+        totalReward: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        positionRewards: Record<string, string>;
+        stepCount: number;
+        totalReward: string;
+    };
+};
+/** Converts a value to a rewards index head, throwing if invalid. */
+export declare const asNetworkStakeRewardsIndexHead: {
+    <T>(value: T): (T & {
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        positionCount: number;
+        processedThroughBlock: number;
+        snapshot: string;
+        source: {
+            evm: {
+                block: number;
+                hash: string;
+            };
+            xl1: {
+                block: number;
+                hash: string;
+            };
+        };
+        stepCount: number;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        layout: "network-stake-rewards-v1";
+        policyId: string;
+        positionCount: number;
+        processedThroughBlock: number;
+        snapshot: string;
+        source: {
+            evm: {
+                block: number;
+                hash: string;
+            };
+            xl1: {
+                block: number;
+                hash: string;
+            };
+        };
+        stepCount: number;
+    };
+};
+//# sourceMappingURL=networkStakeRewardsIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/networkStakeRewardsIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStakeRewardsIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/networkStakeRewardsIndex.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,iEAAiE;AACjE,eAAO,MAAM,kCAAkC,EAAG,0BAAmC,CAAA;AACrF,0EAA0E;AAC1E,eAAO,MAAM,iCAAiC,EAAG,SAAkB,CAAA;AAGnE,8DAA8D;AAC9D,eAAO,MAAM,8BAA8B,aAA6C,CAAA;AAQxF,uEAAuE;AACvE,eAAO,MAAM,mCAAmC;;;;;;;;;;iBAU9C,CAAA;AAEF,uEAAuE;AACvE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAElG,qEAAqE;AACrE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;iBAS1C,CAAA;AAEF,qEAAqE;AACrE,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE1F,yEAAyE;AACzE,eAAO,MAAM,mCAAmC;;;;;;iBAM9C,CAAA;AAEF,yEAAyE;AACzE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAElG,wFAAwF;AACxF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAiB1C,CAAA;AAEF,wFAAwF;AACxF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE1F,gEAAgE;AAChE,eAAO,MAAM,kCAAkC;;;;;;;;;;CAAoD,CAAA;AACnG,yEAAyE;AACzE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;CAG9C,CAAA;AACD,qEAAqE;AACrE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG1C,CAAA;AACD,yEAAyE;AACzE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;CAG9C,CAAA;AACD,qEAAqE;AACrE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG1C,CAAA"}

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts

@@ -2,4 +2,5 @@ export * from './chainState.js';
 export * from './evmEventIndex.js';
 export * from './finalized.js';
 export * from './indexPaths.js';
+export * from './networkStakeRewardsIndex.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA"}

package/dist/neutral/modules/network-model/staticRest/paths/networkStakeRewardsIndex.d.ts

@@ -0,0 +1,10 @@
+import type { StepIdentity } from '../../../protocol-model/index.js';
+/** Path of the mutable rewards-index head. */
+export declare function networkStakeRewardsIndexHeadPath(policyId: string): string;
+/** Path of the static rewards-index manifest. */
+export declare function networkStakeRewardsIndexManifestPath(policyId: string): string;
+/** Path of one immutable cumulative position snapshot. */
+export declare function networkStakeRewardsIndexSnapshotPath(policyId: string, stepCount: number): string;
+/** Path of one immutable completed-step reward allocation. */
+export declare function networkStakeRewardsIndexStepPath(policyId: string, step: StepIdentity): string;
+//# sourceMappingURL=networkStakeRewardsIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/networkStakeRewardsIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStakeRewardsIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/networkStakeRewardsIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAMnD,8CAA8C;AAC9C,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,iDAAiD;AACjD,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,0DAA0D;AAC1D,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhG;AAED,8DAA8D;AAC9D,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,CAE7F"}

package/dist/neutral/modules/protocol-lib/runners/NetworkStakeRewardsIndexPublish.d.ts

@@ -0,0 +1,26 @@
+import type { Provider } from '../../protocol-model/index.js';
+import type { EvmEventIndexHead } from './EvmEventIndexPublish.js';
+import type { IndexWatermark } from './IndexPublish.js';
+/** Durable rewards-index progress returned after a publication pass. */
+export interface NetworkStakeRewardsIndexPublishHead {
+    /** Highest XL1 block for which every completed reward step is indexed. */
+    processedThroughBlock: number;
+    /** Number of immutable completed-step records represented by the snapshot. */
+    stepCount: number;
+}
+/** Operations exposed by the network-stake rewards index publisher. */
+export interface NetworkStakeRewardsIndexPublishRunnerMethods {
+    /**
+     * Publishes rewards only through the intersection of the durable XL1 index
+     * watermark and finalized EVM event-index watermark.
+     */
+    publishRewardsIndex(xl1Head: IndexWatermark, evmHead: EvmEventIndexHead): Promise<NetworkStakeRewardsIndexPublishHead>;
+}
+/** Moniker identifier for the network-stake rewards index publisher. */
+export declare const NetworkStakeRewardsIndexPublishRunnerMoniker: "NetworkStakeRewardsIndexPublishRunner";
+/** Type literal for the network-stake rewards index publisher moniker. */
+export type NetworkStakeRewardsIndexPublishRunnerMoniker = typeof NetworkStakeRewardsIndexPublishRunnerMoniker;
+/** Runner interface for publishing durable network-stake rewards. */
+export interface NetworkStakeRewardsIndexPublishRunner extends NetworkStakeRewardsIndexPublishRunnerMethods, Provider<NetworkStakeRewardsIndexPublishRunnerMoniker> {
+}
+//# sourceMappingURL=NetworkStakeRewardsIndexPublish.d.ts.map

package/dist/neutral/modules/protocol-lib/runners/NetworkStakeRewardsIndexPublish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkStakeRewardsIndexPublish.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/runners/NetworkStakeRewardsIndexPublish.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,wEAAwE;AACxE,MAAM,WAAW,mCAAmC;IAClD,0EAA0E;IAC1E,qBAAqB,EAAE,MAAM,CAAA;IAC7B,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,uEAAuE;AACvE,MAAM,WAAW,4CAA4C;IAC3D;;;OAGG;IACH,mBAAmB,CACjB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,mCAAmC,CAAC,CAAA;CAChD;AAED,wEAAwE;AACxE,eAAO,MAAM,4CAA4C,EAAG,uCAAgD,CAAA;AAC5G,0EAA0E;AAC1E,MAAM,MAAM,4CAA4C,GAAG,OAAO,4CAA4C,CAAA;AAE9G,qEAAqE;AACrE,MAAM,WAAW,qCAAsC,SACrD,4CAA4C,EAC5C,QAAQ,CAAC,4CAA4C,CAAC;CAAG"}

package/dist/neutral/modules/protocol-lib/runners/index.d.ts

@@ -7,4 +7,5 @@ export * from './EvmEventIndexPublish.js';
 export * from './Finalization.js';
 export * from './IndexPublish.js';
 export * from './Mempool.js';
+export * from './NetworkStakeRewardsIndexPublish.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-lib/runners/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/runners/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/runners/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA;AAC5B,cAAc,sCAAsC,CAAA"}

package/dist/neutral/network-model.mjs

@@ -360,6 +360,83 @@ function createIndexHead(watermark, updatedAt) {
   }, true);
 }
 
+// src/modules/network-model/staticRest/layout/networkStakeRewardsIndex.ts
+import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory4 } from "@ariestools/sdk";
+import { z as z5 } from "zod";
+var NETWORK_STAKE_REWARDS_INDEX_LAYOUT = "network-stake-rewards-v1";
+var NETWORK_STAKE_REWARDS_BASE_POLICY = "base-v1";
+var DecimalBigIntZod = z5.string().regex(/^(?:0|[1-9]\d*)$/);
+var NetworkStakeRewardsPolicyIdZod = z5.string().regex(/^[a-z0-9][a-z0-9._-]*$/);
+var PositionRewardsZod = z5.record(z5.string().regex(/^(?:0|[1-9]\d*)$/), DecimalBigIntZod);
+var BlockRangeZod = z5.tuple([z5.number().int().nonnegative(), z5.number().int().nonnegative()]);
+var StepIdentityJsonZod = z5.object({
+  block: z5.number().int().nonnegative(),
+  step: z5.number().int().nonnegative()
+});
+var NetworkStakeRewardsIndexManifestZod = z5.object({
+  evmAddress: z5.string(),
+  evmChainId: z5.string(),
+  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+  policyId: NetworkStakeRewardsPolicyIdZod,
+  stepLevels: z5.array(z5.number().int().nonnegative()),
+  timeAnchor: z5.object({
+    externalGenesisTime: z5.number().optional(),
+    maxScanBlocks: z5.number().optional()
+  }).optional()
+});
+var NetworkStakeRewardsIndexStepZod = z5.object({
+  denominator: DecimalBigIntZod,
+  externalRange: BlockRangeZod,
+  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+  policyId: NetworkStakeRewardsPolicyIdZod,
+  positionRewards: PositionRewardsZod,
+  step: StepIdentityJsonZod,
+  totalReward: DecimalBigIntZod,
+  xl1Range: BlockRangeZod
+});
+var NetworkStakeRewardsIndexSnapshotZod = z5.object({
+  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+  policyId: NetworkStakeRewardsPolicyIdZod,
+  positionRewards: PositionRewardsZod,
+  stepCount: z5.number().int().nonnegative(),
+  totalReward: DecimalBigIntZod
+});
+var NetworkStakeRewardsIndexHeadZod = z5.object({
+  layout: z5.literal(NETWORK_STAKE_REWARDS_INDEX_LAYOUT),
+  policyId: NetworkStakeRewardsPolicyIdZod,
+  positionCount: z5.number().int().nonnegative(),
+  processedThroughBlock: z5.number().int().nonnegative(),
+  snapshot: z5.string(),
+  source: z5.object({
+    evm: z5.object({
+      block: z5.number().int().nonnegative(),
+      hash: z5.string()
+    }),
+    xl1: z5.object({
+      block: z5.number().int().nonnegative(),
+      hash: z5.string()
+    })
+  }),
+  stepCount: z5.number().int().nonnegative()
+});
+var isNetworkStakeRewardsIndexManifest = zodIsFactory4(NetworkStakeRewardsIndexManifestZod);
+var asNetworkStakeRewardsIndexManifest = zodAsFactory5(
+  NetworkStakeRewardsIndexManifestZod,
+  "asNetworkStakeRewardsIndexManifest"
+);
+var asNetworkStakeRewardsIndexStep = zodAsFactory5(
+  NetworkStakeRewardsIndexStepZod,
+  "asNetworkStakeRewardsIndexStep"
+);
+var asNetworkStakeRewardsIndexSnapshot = zodAsFactory5(
+  NetworkStakeRewardsIndexSnapshotZod,
+  "asNetworkStakeRewardsIndexSnapshot"
+);
+var asNetworkStakeRewardsIndexHead = zodAsFactory5(
+  NetworkStakeRewardsIndexHeadZod,
+  "asNetworkStakeRewardsIndexHead"
+);
+
 // src/modules/network-model/staticRest/paths/evmEventIndex.ts
 function root(address) {
   return `evm/events/${address.toLowerCase()}`;
@@ -377,6 +454,23 @@ function evmEventIndexTailPath(address) {
   return `${root(address)}/tail.json`;
 }
 
+// src/modules/network-model/staticRest/paths/networkStakeRewardsIndex.ts
+function root2(policyId) {
+  return `rewards/network-stake/v1/${policyId}`;
+}
+function networkStakeRewardsIndexHeadPath(policyId) {
+  return `${root2(policyId)}/head.json`;
+}
+function networkStakeRewardsIndexManifestPath(policyId) {
+  return `${root2(policyId)}/manifest.json`;
+}
+function networkStakeRewardsIndexSnapshotPath(policyId, stepCount) {
+  return `${root2(policyId)}/positions/${stepCount}.json`;
+}
+function networkStakeRewardsIndexStepPath(policyId, step) {
+  return `${root2(policyId)}/steps/${step.step}/${step.block}.json`;
+}
+
 // src/modules/network-model/utils/ExplorerLinks.ts
 var ExplorerLinks = class {
   /** Explorer origin with trailing slashes removed. */
@@ -461,8 +555,15 @@ export {
   local_default as LocalNetworkIconString,
   MainNetwork,
   mainnet_default as MainNetworkIconString,
+  NETWORK_STAKE_REWARDS_BASE_POLICY,
+  NETWORK_STAKE_REWARDS_INDEX_LAYOUT,
   NetworkBootstrapSchema,
   NetworkDataLakeUrls,
+  NetworkStakeRewardsIndexHeadZod,
+  NetworkStakeRewardsIndexManifestZod,
+  NetworkStakeRewardsIndexSnapshotZod,
+  NetworkStakeRewardsIndexStepZod,
+  NetworkStakeRewardsPolicyIdZod,
   SequenceNetwork,
   testnet_default as SequenceNetworkIconString,
   asChainContractManifest,
@@ -472,6 +573,10 @@ export {
   asEvmEventIndexManifest,
   asIndexHead,
   asIndexManifest,
+  asNetworkStakeRewardsIndexHead,
+  asNetworkStakeRewardsIndexManifest,
+  asNetworkStakeRewardsIndexSnapshot,
+  asNetworkStakeRewardsIndexStep,
   asOptionalNetwork,
   blockHashPath,
   blockHashPathTemplate,
@@ -502,7 +607,12 @@ export {
   isIndexHead,
   isIndexManifest,
   isNetworkBootstrap,
+  isNetworkStakeRewardsIndexManifest,
   manifestPath,
+  networkStakeRewardsIndexHeadPath,
+  networkStakeRewardsIndexManifestPath,
+  networkStakeRewardsIndexSnapshotPath,
+  networkStakeRewardsIndexStepPath,
   payloadPath,
   payloadPathTemplate,
   toChainContractManifest,