@xyo-network/xl1-rpc 1.15.27 → 1.15.28

package/dist/neutral/index.mjs

@@ -4,6 +4,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/engine/requestSchemas.ts
 var requestSchemas = {};
 
+// src/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts
+var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = /* @__PURE__ */ __name((viewer) => {
+  return {
+    networkStakingStepRewardsByPositionViewer_bonus: /* @__PURE__ */ __name((params) => viewer.bonus(...params ?? []), "networkStakingStepRewardsByPositionViewer_bonus"),
+    networkStakingStepRewardsByPositionViewer_claimed: /* @__PURE__ */ __name((params) => viewer.claimed(...params ?? []), "networkStakingStepRewardsByPositionViewer_claimed"),
+    networkStakingStepRewardsByPositionViewer_earned: /* @__PURE__ */ __name((params) => viewer.earned(...params ?? []), "networkStakingStepRewardsByPositionViewer_earned"),
+    networkStakingStepRewardsByPositionViewer_total: /* @__PURE__ */ __name((params) => viewer.total(...params ?? []), "networkStakingStepRewardsByPositionViewer_total"),
+    networkStakingStepRewardsByPositionViewer_unclaimed: /* @__PURE__ */ __name((params) => viewer.unclaimed(...params ?? []), "networkStakingStepRewardsByPositionViewer_unclaimed")
+  };
+}, "rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer");
+
 // src/engine/rpcMethodHandlersFromRunner.ts
 var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
   return {
@@ -11,15 +22,6 @@ var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
   };
 }, "rpcMethodHandlersFromRunner");
 
-// src/engine/rpcMethodHandlersFromSigner.ts
-var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
-  return {
-    xyoSigner_address: /* @__PURE__ */ __name((params) => signer.address(...params ?? []), "xyoSigner_address"),
-    xyoSigner_createSignedTransaction: /* @__PURE__ */ __name((params) => signer.createSignedTransaction(...params ?? []), "xyoSigner_createSignedTransaction"),
-    xyoSigner_signTransaction: /* @__PURE__ */ __name((params) => signer.signTransaction(...params ?? []), "xyoSigner_signTransaction")
-  };
-}, "rpcMethodHandlersFromSigner");
-
 // src/engine/rpcMethodHandlersFromViewer.ts
 var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
   return {
@@ -68,26 +70,33 @@ var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
 }, "rpcMethodHandlersFromViewer");
 
 // src/engine/rpcMethodHandlersFromConnection.ts
-var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection) => {
-  const { runner, signer, viewer } = connection;
-  let result = {
-    xyoProvider_send: /* @__PURE__ */ __name((params) => connection.send(...params ?? []), "xyoProvider_send")
-  };
+var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection, networkStakeViewer) => {
+  const { runner, viewer } = connection;
+  let result = {};
   if (runner) result = {
     ...result,
     ...rpcMethodHandlersFromRunner(runner)
   };
-  if (signer) result = {
-    ...result,
-    ...rpcMethodHandlersFromSigner(signer)
-  };
   if (viewer) result = {
     ...result,
     ...rpcMethodHandlersFromViewer(viewer)
   };
+  if (networkStakeViewer?.stepRewards?.position) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
+    };
+  }
   return result;
 }, "rpcMethodHandlersFromConnection");
 
+// src/engine/rpcMethodHandlersFromNetworkStakingViewer.ts
+var rpcMethodHandlersFromNetworkStakingViewer = /* @__PURE__ */ __name((viewer) => {
+  return {
+    networkStakeViewer_active: /* @__PURE__ */ __name((params) => viewer.active(...params ?? []), "networkStakeViewer_active")
+  };
+}, "rpcMethodHandlersFromNetworkStakingViewer");
+
 // src/engine/rpcMethodHandlersFromPermissions.ts
 var rpcMethodHandlersFromPermissions = /* @__PURE__ */ __name((permissions) => {
   return {
@@ -97,6 +106,14 @@ var rpcMethodHandlersFromPermissions = /* @__PURE__ */ __name((permissions) => {
   };
 }, "rpcMethodHandlersFromPermissions");
 
+// src/engine/rpcMethodHandlersFromSigner.ts
+var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
+  return {
+    xyoSigner_address: /* @__PURE__ */ __name((params) => signer.address(...params ?? []), "xyoSigner_address"),
+    xyoSigner_signTransaction: /* @__PURE__ */ __name((params) => signer.signTransaction(...params ?? []), "xyoSigner_signTransaction")
+  };
+}, "rpcMethodHandlersFromSigner");
+
 // src/provider/client/MemoryXyoClient.ts
 var MemoryXyoClient = class {
   static {
@@ -111,8 +128,8 @@ var MemoryXyoClient = class {
 };
 
 // src/provider/connection/HttpRpcXyoConnection.ts
-import { isDefined as isDefined2, isString as isString2 } from "@xylabs/typeof";
-import { isDataLakeProvider as isDataLakeProvider2 } from "@xyo-network/xl1-protocol";
+import { isString as isString2 } from "@xylabs/typeof";
+import { isDataLakeProvider } from "@xyo-network/xl1-protocol";
 
 // src/transport/HttpRpcTransport.ts
 import { AxiosJson } from "@xylabs/axios";
@@ -147,8 +164,27 @@ var JsonRpcErrorCodes = {
 // src/types/JsonRpc.ts
 var jsonrpc = "2.0";
 
-// src/types/schema/XyoPermissionsRpcSchemas.ts
-import * as z17 from "zod";
+// src/types/NetworkStakeViewerRpc.ts
+var NetworkStakeViewerRpcNamespace = "networkStakeViewer";
+
+// src/types/NetworkStakingStepRewardsByPositionViewerRpc.ts
+var NetworkStakingStepRewardsByPositionViewerRpcNamespace = "networkStakingStepRewardsByPositionViewer";
+
+// src/types/NetworkStakingStepRewardsByStakerViewerRpc.ts
+var NetworkStakingStepRewardsByStakerViewerRpcNamespace = "networkStakingStepRewardsByStakerViewer";
+
+// src/types/NetworkStakingStepRewardsByStepViewerRpc.ts
+var NetworkStakingStepRewardsByStepViewerRpcNamespace = "networkStakingStepRewardsByStepViewer";
+
+// src/types/NetworkStakingStepRewardsTotalViewerRpc.ts
+var NetworkStakingStepRewardsTotalViewerRpcNamespace = "networkStakingStepRewardsTotalViewer";
+
+// src/types/NetworkStakingStepRewardsViewerRpc.ts
+var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsViewer";
+
+// src/types/schema/NetworkStakeViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/hex";
+import * as z19 from "zod";
 
 // src/types/schema/common/Address.ts
 import { AddressRegEx, toAddress } from "@xylabs/hex";
@@ -260,51 +296,58 @@ var BlockBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod
 var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 var SignedBlockBoundWitnessWithStorageMetaZod = SignedBoundWitnessWithStorageMetaZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 
+// src/types/schema/common/BlockRange.ts
+import { z as z7 } from "zod";
+var BlockRangeZod = z7.tuple([
+  z7.number().optional(),
+  z7.number().optional()
+]);
+
 // src/types/schema/common/HydratedBlock.ts
-import * as z7 from "zod";
-var HydratedBlockZod = z7.tuple([
+import * as z8 from "zod";
+var HydratedBlockZod = z8.tuple([
   BlockBoundWitnessZod,
-  z7.array(PayloadZod)
+  z8.array(PayloadZod)
 ]);
-var HydratedBlockWithStorageMetaZod = z7.tuple([
+var HydratedBlockWithStorageMetaZod = z8.tuple([
   BlockBoundWitnessWithStorageMetaZod,
-  z7.array(PayloadWithStorageMetaZod)
+  z8.array(PayloadWithStorageMetaZod)
 ]);
-var SignedHydratedBlockZod = z7.tuple([
+var SignedHydratedBlockZod = z8.tuple([
   SignedBlockBoundWitnessZod,
-  z7.array(PayloadZod)
+  z8.array(PayloadZod)
 ]);
-var SignedHydratedBlockToJsonZod = z7.tuple([
+var SignedHydratedBlockToJsonZod = z8.tuple([
   SignedBlockBoundWitnessZod,
-  z7.array(PayloadZod)
+  z8.array(PayloadZod)
 ]);
-var SignedHydratedBlockWithStorageMetaZod = z7.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z8.tuple([
   SignedBlockBoundWitnessWithStorageMetaZod,
-  z7.array(PayloadWithStorageMetaZod)
+  z8.array(PayloadWithStorageMetaZod)
 ]);
 
 // src/types/schema/common/HydratedTransaction.ts
 import { asAnyPayload } from "@xyo-network/payload-model";
 import { asSignedHydratedTransaction } from "@xyo-network/xl1-protocol";
-import * as z10 from "zod";
+import * as z11 from "zod";
 
 // src/types/schema/common/TransactionBoundWitness.ts
-import * as z9 from "zod";
+import * as z10 from "zod";
 
 // src/types/schema/common/TransactionFees.ts
 import { BigIntToJsonZod, HexZod as HexZod3, JsonToBigIntZod } from "@xylabs/hex";
 import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-import * as z8 from "zod";
-var AttoZod = z8.bigint();
+import * as z9 from "zod";
+var AttoZod = z9.bigint();
 var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
 var AttoToJsonZod = BigIntToJsonZod;
-var TransactionFeesHexZod = z8.object({
+var TransactionFeesHexZod = z9.object({
   base: HexZod3,
   gasLimit: HexZod3,
   gasPrice: HexZod3,
   priority: HexZod3
 });
-var TransactionFeesBigIntZod = z8.object({
+var TransactionFeesBigIntZod = z9.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
@@ -324,23 +367,23 @@ var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) =>
 }));
 
 // src/types/schema/common/TransactionBoundWitness.ts
-var BlockStartZod = z9.object({
+var BlockStartZod = z10.object({
   nbf: BlockNumberZod
 });
-var BlockEndZod = z9.object({
+var BlockEndZod = z10.object({
   exp: BlockNumberZod
 });
-var BlockDurationZod = z9.object({
+var BlockDurationZod = z10.object({
   nbf: BlockNumberZod,
   exp: BlockNumberZod
 });
-var BlockScriptsZod = z9.object({
-  script: z9.array(z9.string()).optional()
+var BlockScriptsZod = z10.object({
+  script: z10.array(z10.string()).optional()
 });
-var WithTransactionFeesZod = z9.object({
+var WithTransactionFeesZod = z10.object({
   fees: TransactionFeesHexZod
 });
-var TransactionBoundWitnessFields = z9.object({
+var TransactionBoundWitnessFields = z10.object({
   chain: ChainZod,
   from: ChainZod
 });
@@ -348,17 +391,17 @@ var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod.pa
 var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
 
 // src/types/schema/common/HydratedTransaction.ts
-var HydratedTransactionZod = z10.tuple([
+var HydratedTransactionZod = z11.tuple([
   TransactionBoundWitnessZod,
-  z10.array(PayloadZod)
+  z11.array(PayloadZod)
 ]);
-var UnsignedHydratedTransactionZod = z10.tuple([
+var UnsignedHydratedTransactionZod = z11.tuple([
   TransactionBoundWitnessZod,
-  z10.array(PayloadZod)
+  z11.array(PayloadZod)
 ]);
-var SignedHydratedTransactionZod = z10.tuple([
+var SignedHydratedTransactionZod = z11.tuple([
   SignedTransactionBoundWitnessZod,
-  z10.array(PayloadZod)
+  z11.array(PayloadZod)
 ]);
 var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
   tx,
@@ -370,61 +413,79 @@ var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(
 ]);
 
 // src/types/schema/common/Json.ts
-import * as z11 from "zod";
-var JsonValueZod = z11.lazy(() => z11.union([
-  z11.string(),
-  z11.number(),
-  z11.boolean(),
-  z11.null(),
-  z11.array(JsonValueZod),
-  z11.record(z11.string(), JsonValueZod)
+import * as z12 from "zod";
+var JsonValueZod = z12.lazy(() => z12.union([
+  z12.string(),
+  z12.number(),
+  z12.boolean(),
+  z12.null(),
+  z12.array(JsonValueZod),
+  z12.record(z12.string(), JsonValueZod)
 ]));
-var JsonObjectZod = z11.record(z11.string(), JsonValueZod);
+var JsonObjectZod = z12.record(z12.string(), JsonValueZod);
 
 // src/types/schema/common/Permission.ts
-import { z as z12 } from "zod";
-var CaveatTypesZod = z12.enum([
+import { z as z13 } from "zod";
+var CaveatTypesZod = z13.enum([
   "chain",
   "expiration",
   "filteredResponse",
   "rateLimit",
   "restrictReturnedAccounts"
 ]);
-var CaveatsZod = z12.object({
+var CaveatsZod = z13.object({
   type: CaveatTypesZod,
-  value: z12.json()
+  value: z13.json()
 });
-var PermissionZod = z12.object({
-  parentCapability: z12.string(),
+var PermissionZod = z13.object({
+  parentCapability: z13.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z12.string()
+  invoker: z13.string()
 });
 var InvokerPermissionZod = PermissionZod.extend({
-  date: z12.number().optional()
+  date: z13.number().optional()
 });
-var PermissionRequestZod = z12.record(z12.string(), z12.record(z12.string(), z12.any()));
-var RequestedPermissionZod = z12.object({
-  parentCapability: z12.string(),
-  date: z12.number().optional()
+var PermissionRequestZod = z13.record(z13.string(), z13.record(z13.string(), z13.any()));
+var RequestedPermissionZod = z13.object({
+  parentCapability: z13.string(),
+  date: z13.number().optional()
+});
+
+// src/types/schema/common/RewardsRangeOptions.ts
+import { z as z15 } from "zod";
+
+// src/types/schema/common/StepIdentity.ts
+import * as z14 from "zod";
+var StepIdentityZod = z14.object({
+  block: z14.number(),
+  step: z14.number()
+});
+
+// src/types/schema/common/RewardsRangeOptions.ts
+var RewardsRangeOptionsZod = z15.object({
+  positions: z15.array(z15.number()).optional(),
+  range: BlockRangeZod.optional(),
+  steps: z15.array(StepIdentityZod).optional(),
+  stakers: z15.array(AddressZod).optional()
 });
 
 // src/types/schema/common/Stake.ts
 import { HexZod as HexZod4 } from "@xylabs/hex";
-import * as z13 from "zod";
-var StakeZod = z13.object({
+import * as z16 from "zod";
+var StakeZod = z16.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z13.number(),
+  addBlock: z16.number(),
   // the unique id for the stake item
-  id: z13.number(),
+  id: z16.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z13.number(),
+  removeBlock: z16.number(),
   // the address that is being staked
   staked: AddressZod,
   // the address that owns the stake
   staker: AddressZod,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z13.number()
+  withdrawBlock: z16.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
@@ -447,115 +508,102 @@ var JsonToStakeZod = StakeZod.extend({
   withdrawBlock: val.withdrawBlock
 }));
 
-// src/types/schema/common/StepIdentity.ts
-import * as z14 from "zod";
-var StepIdentityZod = z14.object({
-  block: z14.number(),
-  step: z14.number()
-});
-
 // src/types/schema/common/Transfer.ts
 import { BigIntToJsonZod as BigIntToJsonZod2 } from "@xylabs/hex";
 import { PayloadZodStrictOfSchema } from "@xyo-network/payload-model";
 import { TransferSchema } from "@xyo-network/xl1-protocol";
-import z15 from "zod";
-var TransferFieldsZod = z15.object({
-  epoch: z15.number(),
+import z17 from "zod";
+var TransferFieldsZod = z17.object({
+  epoch: z17.number(),
   from: AddressZod,
-  transfers: z15.record(AddressZod, BigIntToJsonZod2)
+  transfers: z17.record(AddressZod, BigIntToJsonZod2)
 });
 var TransferZod = PayloadZodStrictOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
 
 // src/types/schema/common/TransferPair.ts
-import z16 from "zod";
-var TransferPairZod = z16.tuple([
+import z18 from "zod";
+var TransferPairZod = z18.tuple([
   AddressZod,
   AddressZod
 ]);
 
+// src/types/schema/NetworkStakeViewerRpcSchemas.ts
+var NetworkStakeViewerRpcSchemas = {
+  networkStakeViewer_active: {
+    params: {
+      from: z19.tuple([
+        BlockNumberZod.optional()
+      ]),
+      to: z19.tuple([
+        BlockNumberZod.optional()
+      ])
+    },
+    result: {
+      from: z19.tuple([
+        JsonToBigIntZod2,
+        z19.number()
+      ]),
+      to: z19.tuple([
+        BigIntToJsonZod3,
+        z19.number()
+      ])
+    }
+  }
+};
+
 // src/types/schema/XyoPermissionsRpcSchemas.ts
+import * as z20 from "zod";
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
-      to: z17.array(z17.any()).length(0),
-      from: z17.array(z17.any()).length(0)
+      to: z20.array(z20.any()).length(0),
+      from: z20.array(z20.any()).length(0)
     },
     result: {
-      to: z17.array(InvokerPermissionZod),
-      from: z17.array(InvokerPermissionZod)
+      to: z20.array(InvokerPermissionZod),
+      from: z20.array(InvokerPermissionZod)
     }
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z17.tuple([
-        z17.array(PermissionRequestZod)
+      to: z20.tuple([
+        z20.array(PermissionRequestZod)
       ]),
-      from: z17.tuple([
-        z17.array(PermissionRequestZod)
+      from: z20.tuple([
+        z20.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z17.array(RequestedPermissionZod),
-      from: z17.array(RequestedPermissionZod)
+      to: z20.array(RequestedPermissionZod),
+      from: z20.array(RequestedPermissionZod)
     }
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z17.tuple([
-        z17.array(PermissionRequestZod)
+      to: z20.tuple([
+        z20.array(PermissionRequestZod)
       ]),
-      from: z17.tuple([
-        z17.array(PermissionRequestZod)
-      ])
-    },
-    result: {
-      to: z17.array(RequestedPermissionZod),
-      from: z17.array(RequestedPermissionZod)
-    }
-  }
-};
-
-// src/types/schema/XyoProviderRpcSchemas.ts
-import * as z18 from "zod";
-var XyoProviderRpcSchemas = {
-  xyoProvider_send: {
-    params: {
-      to: z18.tuple([
-        AddressZod,
-        z18.array(PayloadZod),
-        z18.array(PayloadZod),
-        z18.number().nonnegative(),
-        z18.number().nonnegative(),
-        TransactionFeesBigIntToJsonZod,
-        AddressZod.optional()
-      ]),
-      from: z18.tuple([
-        AddressZod,
-        z18.array(PayloadZod),
-        z18.array(PayloadZod),
-        z18.number().nonnegative(),
-        z18.number().nonnegative(),
-        TransactionFeesJsonToBigIntZod,
-        AddressZod.optional()
+      from: z20.tuple([
+        z20.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: SignedTransactionBoundWitnessZod,
-      from: SignedTransactionBoundWitnessZod
+      to: z20.array(RequestedPermissionZod),
+      from: z20.array(RequestedPermissionZod)
     }
   }
 };
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod as HashToJsonZod2, JsonToHashZod } from "@xylabs/hex";
-import * as z19 from "zod";
+import * as z21 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z19.tuple([
+      to: z21.tuple([
         SignedHydratedTransactionZod
       ]),
-      from: z19.tuple([
+      from: z21.tuple([
         SignedHydratedTransactionZod
       ])
     },
@@ -567,52 +615,25 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { AllowedBlockPayloadZod, asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { z as z20 } from "zod";
+import { asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { z as z22 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z22.array(z22.any()).length(0).optional(),
+      from: z22.array(z22.any()).length(0).optional()
     },
     result: {
       to: AddressZod,
       from: AddressZod
     }
   },
-  // NOTE: method is deprecated which is why it uses deprecated types
-  xyoSigner_createSignedTransaction: {
-    params: {
-      to: z20.tuple([
-        ChainZod,
-        z20.array(AllowedBlockPayloadZod),
-        z20.array(PayloadZod),
-        z20.number().nonnegative(),
-        z20.number().nonnegative(),
-        TransactionFeesBigIntToJsonZod,
-        AddressZod.optional()
-      ]),
-      from: z20.tuple([
-        ChainZod,
-        z20.array(PayloadZod),
-        z20.array(PayloadZod),
-        z20.number().nonnegative(),
-        z20.number().nonnegative(),
-        TransactionFeesJsonToBigIntZod,
-        AddressZod.optional()
-      ])
-    },
-    result: {
-      to: SignedTransactionBoundWitnessZod,
-      from: SignedTransactionBoundWitnessZod.transform((data) => data)
-    }
-  },
   xyoSigner_signTransaction: {
     params: {
-      to: z20.tuple([
+      to: z22.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z20.tuple([
+      from: z22.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
@@ -626,437 +647,437 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod3, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod2, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
-import * as z21 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod4, HashToJsonZod as HashToJsonZod3, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
+import * as z23 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod,
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod,
           AddressZod
         ])
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod4),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod4),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod,
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod,
           AddressZod
         ])
       ])
     },
     result: {
-      to: z21.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z23.tuple([
+        BigIntToJsonZod4,
+        BigIntToJsonZod4
       ]),
-      from: z21.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z23.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod,
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod,
           AddressZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod4),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod,
-          z21.number()
+          z23.number()
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod,
-          z21.number()
+          z23.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod,
-          z21.number()
+          z23.number()
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod,
-          z21.number()
+          z23.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ])
     },
     result: {
-      to: z21.number(),
-      from: z21.number()
+      to: z23.number(),
+      from: z23.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod
         ])
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod4),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           StepIdentityZod,
-          z21.number()
+          z23.number()
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           StepIdentityZod,
-          z21.number()
+          z23.number()
         ])
       ])
     },
     result: {
-      to: z21.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z23.tuple([
+        BigIntToJsonZod4,
+        BigIntToJsonZod4
       ]),
-      from: z21.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z23.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      to: z23.union([
+        z23.tuple([
+          z23.number(),
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      from: z23.union([
+        z23.tuple([
+          z23.number(),
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ])
     },
     result: {
-      to: z21.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z23.tuple([
+        BigIntToJsonZod4,
+        BigIntToJsonZod4
       ]),
-      from: z21.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z23.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      to: z23.union([
+        z23.tuple([
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      from: z23.union([
+        z23.tuple([
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      to: z23.union([
+        z23.tuple([
+          z23.number(),
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      from: z23.union([
+        z23.tuple([
+          z23.number(),
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      to: z23.union([
+        z23.tuple([
+          z23.number(),
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
+      from: z23.union([
+        z23.tuple([
+          z23.number(),
+          z23.tuple([
+            z23.number(),
+            z23.number()
           ])
         ])
       ])
     },
     result: {
-      to: z21.record(z21.string(), z21.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z23.record(z23.string(), z23.tuple([
+        BigIntToJsonZod4,
+        BigIntToJsonZod4
       ])),
-      from: z21.record(z21.string(), z21.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z23.record(z23.string(), z23.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ]))
     }
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: z21.array(z21.tuple([
+      to: z23.array(z23.tuple([
         HashZod2,
         HashZod2,
         TransferZod
       ])),
-      from: z21.array(z21.tuple([
+      from: z23.array(z23.tuple([
         HashZod2,
         HashZod2,
         TransferZod
@@ -1065,42 +1086,42 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           TransferPairZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           TransferPairZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           TransferPairZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           TransferPairZod
         ])
       ])
     },
     result: {
-      to: z21.array(z21.tuple([
+      to: z23.array(z23.tuple([
         HashZod2,
         HashZod2,
         PayloadZod
       ])),
-      from: z21.array(z21.tuple([
+      from: z23.array(z23.tuple([
         HashZod2,
         HashZod2,
         PayloadZod
@@ -1109,42 +1130,42 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod4,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
+      to: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
+      from: z23.union([
+        z23.tuple([
           AddressZod
         ])
       ])
     },
     result: {
-      to: z21.array(z21.tuple([
+      to: z23.array(z23.tuple([
         HashZod2,
         HashZod2,
         PayloadZod
       ])),
-      from: z21.array(z21.tuple([
+      from: z23.array(z23.tuple([
         HashZod2,
         HashZod2,
         PayloadZod
@@ -1153,10 +1174,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         HashToJsonZod3
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         JsonToHashZod2
       ])
     },
@@ -1167,11 +1188,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z21.tuple([
-        z21.number()
+      to: z23.tuple([
+        z23.number()
       ]),
-      from: z21.tuple([
-        z21.number()
+      from: z23.tuple([
+        z23.number()
       ])
     },
     result: {
@@ -1181,24 +1202,24 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         HashZod2,
-        z21.number().optional()
+        z23.number().optional()
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         HashZod2,
-        z21.number().optional()
+        z23.number().optional()
       ])
     },
     result: {
-      to: z21.array(SignedHydratedBlockZod),
-      from: z21.array(SignedHydratedBlockZod)
+      to: z23.array(SignedHydratedBlockZod),
+      from: z23.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z21.array(z21.any()).length(0).optional(),
-      from: z21.array(z21.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
       to: AddressZod,
@@ -1207,10 +1228,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         BlockNumberZod
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         BlockNumberZod
       ])
     },
@@ -1221,8 +1242,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z21.array(z21.any()).length(0).optional(),
-      from: z21.array(z21.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -1231,8 +1252,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z21.array(z21.any()).length(0).optional(),
-      from: z21.array(z21.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
       to: HashZod2,
@@ -1241,8 +1262,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z21.array(z21.any()).length(0).optional(),
-      from: z21.array(z21.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
       to: BlockNumberZod,
@@ -1251,23 +1272,23 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z21.array(z21.any()).length(0).optional(),
-      from: z21.array(z21.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
-      to: z21.record(z21.number(), AddressZod),
-      from: z21.record(z21.number(), AddressZod)
+      to: z23.record(z23.number(), AddressZod),
+      from: z23.record(z23.number(), AddressZod)
     }
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         AddressZod,
-        z21.number()
+        z23.number()
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         AddressZod,
-        z21.number()
+        z23.number()
       ])
     },
     result: {
@@ -1277,11 +1298,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z21.tuple([
-        z21.number()
+      to: z23.tuple([
+        z23.number()
       ]),
-      from: z21.tuple([
-        z21.number()
+      from: z23.tuple([
+        z23.number()
       ])
     },
     result: {
@@ -1291,55 +1312,55 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakedByStaker: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         AddressZod
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z21.array(AddressZod),
-      from: z21.array(AddressZod)
+      to: z23.array(AddressZod),
+      from: z23.array(AddressZod)
     }
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         AddressZod
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z21.array(StakeToJsonZod),
-      from: z21.array(JsonToStakeZod)
+      to: z23.array(StakeToJsonZod),
+      from: z23.array(JsonToStakeZod)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         AddressZod
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z21.array(StakeToJsonZod),
-      from: z21.array(JsonToStakeZod)
+      to: z23.array(StakeToJsonZod),
+      from: z23.array(JsonToStakeZod)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         HashZod2,
-        z21.number()
+        z23.number()
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         HashZod2,
-        z21.number()
+        z23.number()
       ])
     },
     result: {
@@ -1349,13 +1370,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z21.tuple([
-        z21.number(),
-        z21.number()
+      to: z23.tuple([
+        z23.number(),
+        z23.number()
       ]),
-      from: z21.tuple([
-        z21.number(),
-        z21.number()
+      from: z23.tuple([
+        z23.number(),
+        z23.number()
       ])
     },
     result: {
@@ -1365,10 +1386,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         HashZod2
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         HashZod2
       ])
     },
@@ -1381,56 +1402,345 @@ var XyoViewerRpcSchemas = {
 
 // src/types/schema/AllRpcSchemas.ts
 var AllRpcSchemas = {
-  ...XyoProviderRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,
-  ...XyoPermissionsRpcSchemas
+  ...XyoPermissionsRpcSchemas,
+  ...NetworkStakeViewerRpcSchemas
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z22 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z22.undefined()) => z22.object({
-  id: z22.union([
-    z22.string(),
-    z22.number()
+import * as z24 from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z24.undefined()) => z24.object({
+  id: z24.union([
+    z24.string(),
+    z24.number()
   ]),
-  jsonrpc: z22.literal(jsonrpc),
-  method: z22.literal(methodName),
+  jsonrpc: z24.literal(jsonrpc),
+  method: z24.literal(methodName),
   params: paramsSchema
 }), "createRequestSchema");
 
 // src/types/schema/createResponseSchema.ts
-import * as z23 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z23.undefined()) => z23.object({
-  id: z23.union([
-    z23.string(),
-    z23.number()
+import * as z25 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z25.undefined()) => z25.object({
+  id: z25.union([
+    z25.string(),
+    z25.number()
   ]),
-  jsonrpc: z23.literal(jsonrpc),
+  jsonrpc: z25.literal(jsonrpc),
   result: resultSchema
 }), "createResponseSchema");
 
-// src/types/schema/NetworkStakeViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod3 } from "@xylabs/hex";
-import * as z24 from "zod";
-var NetworkStakeViewerRpcSchemas = {
-  stake: {
+// src/types/schema/RewardsByPositionViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/hex";
+import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
+import z26 from "zod";
+var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
+  networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z24.tuple([
-        BlockNumberZod.optional()
+      from: z26.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
-        BlockNumberZod.optional()
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z26.record(z26.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), BigIntToJsonZod5)
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_claimed: {
+    params: {
+      from: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: BigIntToJsonZod4,
-      to: JsonToBigIntZod3
+      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), JsonToBigIntZod4)
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_earned: {
+    params: {
+      from: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), JsonToBigIntZod4)
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_total: {
+    params: {
+      from: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), JsonToBigIntZod4)
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_unclaimed: {
+    params: {
+      from: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), JsonToBigIntZod4)
+    }
+  }
+};
+
+// src/types/schema/RewardsByStakerViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/hex";
+import z27 from "zod";
+var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
+  networkStakingStepRewardsByStakerViewer_bonus: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod6),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_claimed: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod6),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_earned: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod6),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_total: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod6),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_unclaimed: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod6),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
     }
   }
 };
 
+// src/types/schema/RewardsByStepViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/hex";
+import z28 from "zod";
+var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
+  networkStakingStepRewardsByStepViewer_bonus: {
+    params: {
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z28.record(AddressZod, BigIntToJsonZod7),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  },
+  networkStakingStepRewardsByStepViewer_claimed: {
+    params: {
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z28.record(AddressZod, BigIntToJsonZod7),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  },
+  networkStakingStepRewardsByStepViewer_earned: {
+    params: {
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z28.record(AddressZod, BigIntToJsonZod7),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  },
+  networkStakingStepRewardsByStepViewer_total: {
+    params: {
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z28.record(AddressZod, BigIntToJsonZod7),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  },
+  networkStakingStepRewardsByStepViewer_unclaimed: {
+    params: {
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z28.record(AddressZod, BigIntToJsonZod7),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  }
+};
+
+// src/types/schema/RewardsTotalViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod8, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/hex";
+import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
+import * as z29 from "zod";
+var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
+  networkStakingStepRewardsTotalViewer_bonus: {
+    params: {
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod8
+    }
+  },
+  networkStakingStepRewardsTotalViewer_claimed: {
+    params: {
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod8
+    }
+  },
+  networkStakingStepRewardsTotalViewer_earned: {
+    params: {
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod8
+    }
+  },
+  networkStakingStepRewardsTotalViewer_total: {
+    params: {
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod8
+    }
+  },
+  networkStakingStepRewardsTotalViewer_unclaimed: {
+    params: {
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod8
+    }
+  }
+};
+
+// src/types/schema/StepRewardsViewerRpcSchemas.ts
+var NetworkStakingStepRewardsViewerRpcSchemas = {};
+
 // src/transport/HttpRpcTransport.ts
 var HttpRpcTransport = class {
   static {
@@ -1513,16 +1823,6 @@ var MemoryRpcTransport = class {
   }
 };
 
-// src/transport/post-message/SessionEnvelope.ts
-var buildSessionMessageRequest = /* @__PURE__ */ __name((data, destination) => {
-  const request = {
-    data,
-    destination,
-    sessionId: globalThis.xyo.walletExtensionId() ?? ""
-  };
-  return request;
-}, "buildSessionMessageRequest");
-
 // src/provider/datalake/AbstractXyoDataLake.ts
 import { ObjectHasher } from "@xyo-network/hash";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
@@ -1793,83 +2093,247 @@ var NodeXyoRunner = class {
   }, "getPendingArchivist");
 };
 
-// src/provider/signer/JsonRpcXyoSigner.ts
-var RpcXyoSigner = class {
+// src/provider/viewer/JsonRpcViewer.ts
+var JsonRpcViewer = class {
   static {
-    __name(this, "RpcXyoSigner");
+    __name(this, "JsonRpcViewer");
   }
   transport;
   constructor(transport) {
     this.transport = transport;
   }
-  async address() {
-    return await this.transport.sendRequest("xyoSigner_address");
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts
+var JsonRpcNetworkStakingStepRewardsByPositionViewerMethods = class extends JsonRpcViewer {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsByPositionViewerMethods");
   }
-  /** @deprecated - use signTransaction instead */
-  async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
-    const ret = await this.transport.sendRequest("xyoSigner_createSignedTransaction", [
-      chain,
-      elevatedPayloads,
-      additionalPayloads,
-      nbf,
-      exp,
-      fees,
-      from
+  async bonus(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_bonus", [
+      options
     ]);
-    return ret;
   }
-  async signTransaction(tx) {
-    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [
-      tx
+  async claimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_claimed", [
+      options
+    ]);
+  }
+  async earned(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_earned", [
+      options
+    ]);
+  }
+  async total(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_total", [
+      options
+    ]);
+  }
+  async unclaimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_unclaimed", [
+      options
     ]);
-    return ret;
   }
 };
-var JsonRpcXyoSigner = class extends RpcXyoSigner {
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewer.ts
+var JsonRpcNetworkStakingStepRewardsByPositionViewer = class extends JsonRpcNetworkStakingStepRewardsByPositionViewerMethods {
   static {
-    __name(this, "JsonRpcXyoSigner");
+    __name(this, "JsonRpcNetworkStakingStepRewardsByPositionViewer");
   }
 };
 
-// src/provider/signer/MemoryXyoSigner.ts
-import { buildTransaction, signTransaction } from "@xyo-network/xl1-protocol-sdk";
-var MemoryXyoSigner = class {
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStakerViewer/JsonRpcNetworkStakingStepRewardsByStakerViewerMethods.ts
+var JsonRpcNetworkStakingStepRewardsByStakerViewerMethods = class extends JsonRpcViewer {
   static {
-    __name(this, "MemoryXyoSigner");
+    __name(this, "JsonRpcNetworkStakingStepRewardsByStakerViewerMethods");
   }
-  _account;
-  constructor(account) {
-    this._account = account;
+  async bonus(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_bonus", [
+      options
+    ]);
   }
-  address() {
-    return this._account.address;
+  async claimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_claimed", [
+      options
+    ]);
   }
-  async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
-    const fromAddress = from ?? this._account.address;
-    const transaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, this._account, nbf, exp, fromAddress, fees);
-    return transaction[0];
+  async earned(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_earned", [
+      options
+    ]);
   }
-  async signTransaction(tx) {
-    const txBW = await signTransaction(tx[0], this._account);
-    return [
-      txBW,
-      tx[1]
-    ];
+  async total(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_total", [
+      options
+    ]);
+  }
+  async unclaimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_unclaimed", [
+      options
+    ]);
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewerMethods.ts
+var JsonRpcNetworkStakingStepRewardsByStepViewerMethods = class extends JsonRpcViewer {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsByStepViewerMethods");
+  }
+  async bonus(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_bonus", [
+      options
+    ]);
+  }
+  async claimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_claimed", [
+      options
+    ]);
+  }
+  async earned(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_earned", [
+      options
+    ]);
+  }
+  async total(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_total", [
+      options
+    ]);
+  }
+  async unclaimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_unclaimed", [
+      options
+    ]);
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewer.ts
+var JsonRpcNetworkStakingStepRewardsByStepViewer = class extends JsonRpcNetworkStakingStepRewardsByStepViewerMethods {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsByStepViewer");
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewerMethods.ts
+var JsonRpcNetworkStakingStepRewardsTotalViewerMethods = class extends JsonRpcViewer {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsTotalViewerMethods");
+  }
+  async bonus(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_bonus", [
+      options
+    ]);
+  }
+  async claimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_claimed", [
+      options
+    ]);
+  }
+  async earned(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_earned", [
+      options
+    ]);
+  }
+  async total(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_total", [
+      options
+    ]);
+  }
+  async unclaimed(options) {
+    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_unclaimed", [
+      options
+    ]);
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewer.ts
+var JsonRpcNetworkStakingStepRewardsTotalViewer = class extends JsonRpcNetworkStakingStepRewardsTotalViewerMethods {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsTotalViewer");
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts
+var JsonRpcNetworkStakingStepRewardsViewerMethods = class extends JsonRpcViewer {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsViewerMethods");
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts
+var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStakingStepRewardsViewerMethods {
+  static {
+    __name(this, "JsonRpcNetworkStakingStepRewardsViewer");
+  }
+  _position;
+  _staker;
+  _step;
+  _total;
+  constructor(transport) {
+    super(transport);
+    this._position = new JsonRpcNetworkStakingStepRewardsByPositionViewer(transport);
+    this._staker = new JsonRpcNetworkStakingStepRewardsByStakerViewerMethods(transport);
+    this._step = new JsonRpcNetworkStakingStepRewardsByStepViewer(transport);
+    this._total = new JsonRpcNetworkStakingStepRewardsTotalViewer(transport);
+  }
+  get position() {
+    return this._position;
+  }
+  get staker() {
+    return this._staker;
+  }
+  get step() {
+    return this._step;
+  }
+  get total() {
+    return this._total;
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
+var JsonRpcNetworkStakeViewerMethods = class extends JsonRpcViewer {
+  static {
+    __name(this, "JsonRpcNetworkStakeViewerMethods");
+  }
+  async active(blockNumber) {
+    return await this.transport.sendRequest("networkStakeViewer_active", [
+      blockNumber
+    ]);
+  }
+};
+
+// src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
+var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
+  static {
+    __name(this, "JsonRpcNetworkStakeViewer");
+  }
+  _stepRewards;
+  constructor(transport) {
+    super(transport);
+    this._stepRewards = new JsonRpcNetworkStakingStepRewardsViewer(transport);
+  }
+  get stepRewards() {
+    return this._stepRewards;
   }
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { asAttoXL1 as asAttoXL12, asHydratedBlock } from "@xyo-network/xl1-protocol";
+import { asAttoXL1 as asAttoXL14, asHydratedBlock } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
   }
+  _networkStakeViewer;
   transport;
-  constructor(transport) {
+  constructor(transport, networkStakeViewer) {
     this.transport = transport;
+    this._networkStakeViewer = networkStakeViewer;
+  }
+  get networkStakeViewer() {
+    return this._networkStakeViewer;
   }
   async accountBalance(address) {
-    return asAttoXL12(await this.transport.sendRequest("xyoViewer_accountBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_accountBalance", [
       address
     ]));
   }
@@ -2061,7 +2525,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async transferBalance(address) {
-    return asAttoXL12(await this.transport.sendRequest("xyoViewer_transferBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferBalance", [
       address
     ]));
   }
@@ -2071,7 +2535,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async transferPairBalance(pair) {
-    return asAttoXL12(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
       pair
     ]));
   }
@@ -2083,24 +2547,17 @@ var JsonRpcXyoViewer = class {
 };
 
 // src/provider/connection/XyoBaseConnection.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { isAnyPayload as isAnyPayload4 } from "@xyo-network/payload-model";
-import { defaultTransactionFees, isDataLakeProvider } from "@xyo-network/xl1-protocol";
-import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
 var XyoBaseConnection = class {
   static {
     __name(this, "XyoBaseConnection");
   }
   _network;
   _runner;
-  _signer;
   _storage;
   _viewer;
   constructor(params) {
     this._network = params?.network;
     this._runner = params?.runner;
-    this._signer = params?.signer;
     this._storage = params?.storage;
     this._viewer = params?.viewer;
   }
@@ -2110,51 +2567,12 @@ var XyoBaseConnection = class {
   get runner() {
     return this._runner;
   }
-  /** @deprecated use signer from gateway instead */
-  get signer() {
-    return this._signer;
-  }
   get storage() {
     return this._storage;
   }
   get viewer() {
     return this._viewer;
   }
-  /** @deprecated use submitTransaction instead */
-  async send(elevatedPayloads, additionalPayloads, chain, nbf, exp, from, fees) {
-    return (await this.submitTransaction(elevatedPayloads, additionalPayloads, {
-      chain,
-      nbf,
-      exp,
-      from,
-      fees
-    }))[0];
-  }
-  /** @deprecated use addPayloadsToChain from gateway instead */
-  async submitTransaction(elevatedPayloads, additionalPayloads, { chain, exp, fees, from, nbf } = {}) {
-    const viewer = assertEx5(this.viewer, () => "No viewer available");
-    const signer = assertEx5(this.signer, () => "No signer available");
-    const runner = assertEx5(this.runner, () => "No runner available");
-    const storage = this.storage;
-    const chainResolved = chain ?? await viewer.chainId();
-    if (chainResolved === void 0) throw new Error("Failed to determine chain");
-    const nbfResolved = Math.max(await viewer.currentBlockNumber() ?? 0, nbf ?? 0);
-    const expResolved = exp ?? nbfResolved + 1e3;
-    const feesResolved = fees ?? defaultTransactionFees;
-    const fromResolved = from ?? await signer.address();
-    if (fromResolved === void 0) throw new Error("Failed to determine from address");
-    const signedTransaction = assertEx5(await signer.createSignedTransaction(chainResolved, elevatedPayloads, additionalPayloads, nbfResolved, expResolved, feesResolved, fromResolved), () => "Failed to create transaction");
-    const hydratedTransaction = [
-      await PayloadBuilder4.addStorageMeta(signedTransaction),
-      await PayloadBuilder4.addStorageMeta(elevatedPayloads)
-    ];
-    if (isDataLakeProvider(storage)) {
-      const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction);
-      await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload4));
-    }
-    assertEx5(await runner.broadcastTransaction(hydratedTransaction), () => "Failed to broadcast transaction");
-    return hydratedTransaction;
-  }
 };
 
 // src/provider/connection/HttpRpcXyoConnection.ts
@@ -2163,33 +2581,28 @@ var HttpRpcXyoConnection = class extends XyoBaseConnection {
     __name(this, "HttpRpcXyoConnection");
   }
   constructor(params) {
-    const { account, endpoint, storage: storageParam } = params;
-    const signer = isDefined2(account) ? new MemoryXyoSigner(account) : void 0;
+    const { endpoint, storage: storageParam } = params;
     const transport = new HttpRpcTransport(endpoint, {
       ...XyoRunnerRpcSchemas,
-      ...XyoViewerRpcSchemas
+      ...XyoViewerRpcSchemas,
+      ...NetworkStakeViewerRpcSchemas
     });
     const runner = new JsonRpcXyoRunner(transport);
-    const viewer = new JsonRpcXyoViewer(transport);
-    const storage = isDataLakeProvider2(storageParam) ? storageParam : isString2(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
+    const networkStakeViewer = new JsonRpcNetworkStakeViewer(transport);
+    const viewer = new JsonRpcXyoViewer(transport, networkStakeViewer);
+    const storage = isDataLakeProvider(storageParam) ? storageParam : isString2(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
     super({
-      signer,
       runner,
       viewer,
       storage
     });
   }
 };
-var RpcXyoConnection = class extends HttpRpcXyoConnection {
-  static {
-    __name(this, "RpcXyoConnection");
-  }
-};
 
 // src/provider/gateway/Abstract.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
-import { isDefined as isDefined3 } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var AbstractXyoGateway = class {
   static {
@@ -2197,19 +2610,16 @@ var AbstractXyoGateway = class {
   }
   async addPayloadsToChain(onChain, offChain, options) {
     const connection = await this.connection();
-    const viewer = assertEx6(connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx5(connection.viewer, () => "No viewer available on connection");
     const signer = await this.signer();
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined3(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = isDefined3(nbf) ? nbf : await viewer?.currentBlockNumber();
-    const resolvedExp = isDefined3(exp) ? exp : resolvedNbf + 10;
+    const resolvedChainId = isDefined2(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = isDefined2(nbf) ? nbf : await viewer?.currentBlockNumber();
+    const resolvedExp = isDefined2(exp) ? exp : resolvedNbf + 10;
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await signer.address(), fees);
-    const runner = assertEx6(connection.runner, () => "No runner available on connection");
+    const runner = assertEx5(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
-    const hash = await runner.broadcastTransaction([
-      await PayloadBuilder5.addStorageMeta(signedTx[0]),
-      await PayloadBuilder5.addStorageMeta(signedTx[1])
-    ]);
+    const hash = await runner.broadcastTransaction(signedTx);
     return [
       hash,
       signedTx
@@ -2218,20 +2628,13 @@ var AbstractXyoGateway = class {
   async addTransactionToChain(tx) {
     const connection = await this.connection();
     const signer = await this.signer();
-    const runner = assertEx6(connection.runner, () => "No runner available on connection");
+    const runner = assertEx5(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     return await runner.broadcastTransaction([
-      await PayloadBuilder5.addStorageMeta(signedTx[0]),
-      await PayloadBuilder5.addStorageMeta(signedTx[1])
+      await PayloadBuilder4.addStorageMeta(signedTx[0]),
+      await PayloadBuilder4.addStorageMeta(signedTx[1])
     ]);
   }
-  /** @deprecated use addPayloadsToChain instead */
-  async submitTransaction(elevatedPayloads, additionalPayloads) {
-    const connection = await this.connection();
-    assertEx6(connection.submitTransaction, () => "Active connection does not support transaction submission");
-    const tx = await connection.submitTransaction?.(elevatedPayloads, additionalPayloads);
-    return assertEx6(tx, () => "Transaction submission failed");
-  }
 };
 
 // src/provider/gateway/MemoryXyoGateway.ts
@@ -2327,7 +2730,7 @@ var MemoryXyoNetwork = class {
 };
 
 // src/provider/permissions/MemoryXyoPermissions.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx6 } from "@xylabs/assert";
 var MemoryXyoPermissions = class {
   static {
     __name(this, "MemoryXyoPermissions");
@@ -2339,7 +2742,7 @@ var MemoryXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx7(this._store, () => "Store must be defined to get permissions");
+    return assertEx6(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -2420,7 +2823,7 @@ var RpcXyoPermissions = class {
 };
 
 // src/provider/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx7 } from "@xylabs/assert";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -2431,7 +2834,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx8(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx7(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -2442,6 +2845,53 @@ var MemoryPermissionsStore = class {
     this.permissions = permissions;
   }
 };
+
+// src/provider/signer/JsonRpcXyoSigner.ts
+var RpcXyoSigner = class {
+  static {
+    __name(this, "RpcXyoSigner");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async address() {
+    return await this.transport.sendRequest("xyoSigner_address");
+  }
+  async signTransaction(tx) {
+    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [
+      tx
+    ]);
+    return ret;
+  }
+};
+
+// src/provider/signer/MemoryXyoSigner.ts
+import { buildTransaction, signTransaction } from "@xyo-network/xl1-protocol-sdk";
+var MemoryXyoSigner = class {
+  static {
+    __name(this, "MemoryXyoSigner");
+  }
+  _account;
+  constructor(account) {
+    this._account = account;
+  }
+  address() {
+    return this._account.address;
+  }
+  async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
+    const fromAddress = from ?? this._account.address;
+    const transaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, this._account, nbf, exp, fromAddress, fees);
+    return transaction[0];
+  }
+  async signTransaction(tx) {
+    const txBW = await signTransaction(tx[0], this._account);
+    return [
+      txBW,
+      tx[1]
+    ];
+  }
+};
 export {
   AbstractXyoDataLake,
   AbstractXyoGateway,
@@ -2461,6 +2911,7 @@ export {
   BlockDurationZod,
   BlockEndZod,
   BlockNumberZod,
+  BlockRangeZod,
   BlockScriptsZod,
   BlockStartZod,
   BoundWitnessZod,
@@ -2476,8 +2927,11 @@ export {
   InvokerPermissionZod,
   JsonObjectZod,
   JsonRpcErrorCodes,
+  JsonRpcNetworkStakeViewer,
+  JsonRpcNetworkStakeViewerMethods,
+  JsonRpcNetworkStakingStepRewardsViewer,
+  JsonRpcNetworkStakingStepRewardsViewerMethods,
   JsonRpcXyoRunner,
-  JsonRpcXyoSigner,
   JsonRpcXyoViewer,
   JsonToAttoZod,
   JsonToSignedHydratedTransactionZod,
@@ -2492,7 +2946,18 @@ export {
   MemoryXyoPermissions,
   MemoryXyoRunner,
   MemoryXyoSigner,
+  NetworkStakeViewerRpcNamespace,
   NetworkStakeViewerRpcSchemas,
+  NetworkStakingStepRewardsByPositionViewerRpcNamespace,
+  NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+  NetworkStakingStepRewardsByStakerViewerRpcNamespace,
+  NetworkStakingStepRewardsByStakerViewerRpcSchemas,
+  NetworkStakingStepRewardsByStepViewerRpcNamespace,
+  NetworkStakingStepRewardsByStepViewerRpcSchemas,
+  NetworkStakingStepRewardsTotalViewerRpcNamespace,
+  NetworkStakingStepRewardsTotalViewerRpcSchemas,
+  NetworkStakingStepRewardsViewerRpcNamespace,
+  NetworkStakingStepRewardsViewerRpcSchemas,
   NodeXyoRunner,
   PayloadWithStorageMetaZod,
   PayloadZod,
@@ -2501,7 +2966,7 @@ export {
   QualifiedSequenceFromStringZod,
   QualifiedSequenceToStringZod,
   RequestedPermissionZod,
-  RpcXyoConnection,
+  RewardsRangeOptionsZod,
   RpcXyoPermissions,
   RpcXyoSigner,
   SchemaZod,
@@ -2536,16 +3001,19 @@ export {
   WithTransactionFeesZod,
   XyoBaseConnection,
   XyoPermissionsRpcSchemas,
-  XyoProviderRpcSchemas,
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
-  buildSessionMessageRequest,
   createRequestSchema,
   createResponseSchema,
   jsonrpc,
   requestSchemas,
   rpcMethodHandlersFromConnection,
-  rpcMethodHandlersFromPermissions
+  rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer,
+  rpcMethodHandlersFromNetworkStakingViewer,
+  rpcMethodHandlersFromPermissions,
+  rpcMethodHandlersFromRunner,
+  rpcMethodHandlersFromSigner,
+  rpcMethodHandlersFromViewer
 };
 //# sourceMappingURL=index.mjs.map