@xyo-network/xl1-rpc 1.15.27 → 1.16.0

package/dist/node/index-node.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,7 +106,15 @@ var rpcMethodHandlersFromPermissions = /* @__PURE__ */ __name((permissions) => {
   };
 }, "rpcMethodHandlersFromPermissions");
 
-// src/engine/rpcEngineFromConnection.ts
+// 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/engine-node/rpcEngineFromConnection.ts
 import { createAsyncMiddleware, JsonRpcEngine } from "@metamask/json-rpc-engine";
 
 // src/types/ErrorCodes.ts
@@ -127,8 +144,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 BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/hex";
+import * as z19 from "zod";
 
 // src/types/schema/common/Address.ts
 import { AddressRegEx, toAddress } from "@xylabs/hex";
@@ -136,7 +172,7 @@ import * as z from "zod";
 var AddressZod = z.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
 // src/types/schema/common/BlockBoundWitness.ts
-import { HexZod as HexZod2 } from "@xylabs/hex";
+import { asXL1BlockNumber } from "@xyo-network/xl1-protocol";
 import * as z6 from "zod";
 
 // src/types/schema/common/BoundWitness.ts
@@ -210,7 +246,7 @@ var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.
   message: "all $signatures must be null"
 });
 var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z4.any());
-var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape);
+var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape).safeExtend(StorageMetaZod.shape);
 var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), {
   message: "all $signatures must not be null"
 });
@@ -225,12 +261,15 @@ var ChainZod = z5.string().toLowerCase().regex(AddressRegEx2).transform((v) => t
 
 // src/types/schema/common/BlockBoundWitness.ts
 var BlockNumberZod = z6.number().int().nonnegative();
+var XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber);
+var HexZod2 = z6.string().regex(/^[0-9a-f]+$/);
+var HashZod2 = HexZod2.transform((v) => v);
 var BlockBoundWitnessFieldsZod = z6.object({
-  block: BlockNumberZod,
+  block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: HexZod2.nullable(),
-  protocol: z6.number().optional(),
-  step_hashes: z6.array(HexZod2).optional()
+  previous: HashZod2.nullable(),
+  protocol: z6.number(),
+  step_hashes: z6.array(HashZod2).optional()
 });
 var BlockBoundWitnessMetaZod = z6.object({
   $epoch: z6.number()
@@ -240,51 +279,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,
@@ -304,23 +350,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
 });
@@ -328,17 +374,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,
@@ -350,61 +396,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 = z13.record(z13.string(), z13.record(z13.string(), z13.any()));
+var RequestedPermissionZod = z13.object({
+  parentCapability: z13.string(),
+  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()
+
+// 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,
@@ -427,115 +491,105 @@ 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 { HexZod as HexZod5 } from "@xylabs/hex";
+import { PayloadZodStrictOfSchema, StorageMetaZod as StorageMetaZod2 } 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({
+  $opCodes: z17.array(z17.string()).optional(),
+  context: z17.object().optional(),
+  epoch: z17.number(),
   from: AddressZod,
-  transfers: z15.record(AddressZod, BigIntToJsonZod2)
+  transfers: z17.record(AddressZod, HexZod5)
 });
 var TransferZod = PayloadZodStrictOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
+var TransferZodWithStorageMeta = TransferZod.extend(StorageMetaZod2.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([
+        BigIntToJsonZod2,
+        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
       ])
     },
@@ -547,52 +601,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
       ])
     },
@@ -606,537 +633,457 @@ 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 BigIntToJsonZod3, HashToJsonZod as HashToJsonZod3, HashZod as HashZod3, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
+import * as z23 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod,
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod,
+        AddressZod
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod3),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod3),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod,
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod,
+        AddressZod
       ])
     },
     result: {
-      to: z21.tuple([
+      to: z23.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z21.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z23.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod,
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod,
+        AddressZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod3),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          z21.number()
-        ])
+      to: z23.tuple([
+        StepIdentityZod,
+        z23.number()
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          z21.number()
-        ])
+      from: z23.tuple([
+        StepIdentityZod,
+        z23.number()
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          z21.number()
-        ])
+      to: z23.tuple([
+        StepIdentityZod,
+        z23.number()
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          z21.number()
-        ])
+      from: z23.tuple([
+        StepIdentityZod,
+        z23.number()
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z21.number(),
-      from: z21.number()
+      to: z23.number(),
+      from: z23.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      to: z23.tuple([
+        StepIdentityZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod
-        ])
+      from: z23.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z21.record(AddressZod, BigIntToJsonZod3),
-      from: z21.record(AddressZod, JsonToBigIntZod2)
+      to: z23.record(AddressZod, BigIntToJsonZod3),
+      from: z23.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          z21.number()
-        ])
+      to: z23.tuple([
+        StepIdentityZod,
+        z23.number()
       ]),
-      from: z21.union([
-        z21.tuple([
-          StepIdentityZod,
-          z21.number()
-        ])
+      from: z23.tuple([
+        StepIdentityZod,
+        z23.number()
       ])
     },
     result: {
-      to: z21.tuple([
+      to: z23.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      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.tuple([
+        z23.number(),
+        z23.tuple([
+          z23.number(),
+          z23.number()
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
-          ])
+      from: z23.tuple([
+        z23.number(),
+        z23.tuple([
+          z23.number(),
+          z23.number()
         ])
       ])
     },
     result: {
-      to: z21.tuple([
+      to: z23.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      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.tuple([
+        z23.tuple([
+          z23.number(),
+          z23.number()
         ])
       ]),
-      from: z21.union([
-        z21.tuple([
-          z21.tuple([
-            z21.number(),
-            z21.number()
-          ])
+      from: z23.tuple([
+        z23.tuple([
+          z23.number(),
+          z23.number()
         ])
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
-          ])
+      to: 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.tuple([
+        z23.number(),
+        z23.tuple([
+          z23.number(),
+          z23.number()
         ])
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          z21.number(),
-          z21.tuple([
-            z21.number(),
-            z21.number()
-          ])
+      to: 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.tuple([
+        z23.number(),
+        z23.tuple([
+          z23.number(),
+          z23.number()
         ])
       ])
     },
     result: {
-      to: z21.record(z21.string(), z21.tuple([
+      to: z23.record(z23.string(), z23.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ])),
-      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([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z21.array(z21.tuple([
-        HashZod2,
-        HashZod2,
-        TransferZod
+      to: z23.array(z23.tuple([
+        BlockBoundWitnessZod,
+        TransactionBoundWitnessZod.nullable(),
+        TransferZodWithStorageMeta
       ])),
-      from: z21.array(z21.tuple([
-        HashZod2,
-        HashZod2,
-        TransferZod
+      from: z23.array(z23.tuple([
+        BlockBoundWitnessZod,
+        TransactionBoundWitnessZod.nullable(),
+        TransferZodWithStorageMeta
       ]))
     }
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          TransferPairZod
-        ])
+      to: z23.tuple([
+        TransferPairZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          TransferPairZod
-        ])
+      from: z23.tuple([
+        TransferPairZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          TransferPairZod
-        ])
+      to: z23.tuple([
+        TransferPairZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          TransferPairZod
-        ])
+      from: z23.tuple([
+        TransferPairZod
       ])
     },
     result: {
-      to: z21.array(z21.tuple([
-        HashZod2,
-        HashZod2,
+      to: z23.array(z23.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z23.union([
+          TransactionBoundWitnessZod,
+          z23.null()
+        ]),
         PayloadZod
       ])),
-      from: z21.array(z21.tuple([
-        HashZod2,
-        HashZod2,
+      from: z23.array(z23.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z23.union([
+          TransactionBoundWitnessZod,
+          z23.null()
+        ]),
         PayloadZod
       ]))
     }
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod
       ])
     },
     result: {
       to: BigIntToJsonZod3,
-      from: JsonToBigIntZod2
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      to: z23.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ]),
-      from: z21.union([
-        z21.tuple([
-          AddressZod
-        ])
+      from: z23.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z21.array(z21.tuple([
-        HashZod2,
-        HashZod2,
+      to: z23.array(z23.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z23.union([
+          TransactionBoundWitnessZod,
+          z23.null()
+        ]),
         PayloadZod
       ])),
-      from: z21.array(z21.tuple([
-        HashZod2,
-        HashZod2,
+      from: z23.array(z23.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z23.union([
+          TransactionBoundWitnessZod,
+          z23.null()
+        ]),
         PayloadZod
       ]))
     }
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         HashToJsonZod3
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         JsonToHashZod2
       ])
     },
@@ -1147,11 +1094,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: {
@@ -1161,24 +1108,24 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z21.tuple([
-        HashZod2,
-        z21.number().optional()
+      to: z23.tuple([
+        HashZod3,
+        z23.number().optional()
       ]),
-      from: z21.tuple([
-        HashZod2,
-        z21.number().optional()
+      from: z23.tuple([
+        HashZod3,
+        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,
@@ -1187,10 +1134,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z21.tuple([
+      to: z23.tuple([
         BlockNumberZod
       ]),
-      from: z21.tuple([
+      from: z23.tuple([
         BlockNumberZod
       ])
     },
@@ -1201,8 +1148,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,
@@ -1211,18 +1158,18 @@ 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,
-      from: HashZod2
+      to: HashZod3,
+      from: HashZod3
     }
   },
   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,
@@ -1231,23 +1178,37 @@ 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: {
+      to: StakeToJsonZod,
+      from: JsonToStakeZod
+    }
+  },
+  xyoViewer_stakeById: {
+    params: {
+      to: z23.tuple([
+        z23.number()
+      ]),
+      from: z23.tuple([
+        z23.number()
       ])
     },
     result: {
@@ -1255,166 +1216,441 @@ var XyoViewerRpcSchemas = {
       from: JsonToStakeZod
     }
   },
-  xyoViewer_stakeById: {
+  xyoViewer_stakedByStaker: {
+    params: {
+      to: z23.tuple([
+        AddressZod
+      ]),
+      from: z23.tuple([
+        AddressZod
+      ])
+    },
+    result: {
+      to: z23.array(AddressZod),
+      from: z23.array(AddressZod)
+    }
+  },
+  xyoViewer_stakesByStaker: {
+    params: {
+      to: z23.tuple([
+        AddressZod
+      ]),
+      from: z23.tuple([
+        AddressZod
+      ])
+    },
+    result: {
+      to: z23.array(StakeToJsonZod),
+      from: z23.array(JsonToStakeZod)
+    }
+  },
+  xyoViewer_stakesByStaked: {
+    params: {
+      to: z23.tuple([
+        AddressZod
+      ]),
+      from: z23.tuple([
+        AddressZod
+      ])
+    },
+    result: {
+      to: z23.array(StakeToJsonZod),
+      from: z23.array(JsonToStakeZod)
+    }
+  },
+  xyoViewer_transactionByBlockHashAndIndex: {
+    params: {
+      to: z23.tuple([
+        HashZod3,
+        z23.number()
+      ]),
+      from: z23.tuple([
+        HashZod3,
+        z23.number()
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable()
+    }
+  },
+  xyoViewer_transactionByBlockNumberAndIndex: {
+    params: {
+      to: z23.tuple([
+        z23.number(),
+        z23.number()
+      ]),
+      from: z23.tuple([
+        z23.number(),
+        z23.number()
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable()
+    }
+  },
+  xyoViewer_transactionByHash: {
+    params: {
+      to: z23.tuple([
+        HashZod3
+      ]),
+      from: z23.tuple([
+        HashZod3
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable()
+    }
+  }
+};
+
+// src/types/schema/AllRpcSchemas.ts
+var AllRpcSchemas = {
+  ...XyoRunnerRpcSchemas,
+  ...XyoSignerRpcSchemas,
+  ...XyoViewerRpcSchemas,
+  ...XyoPermissionsRpcSchemas,
+  ...NetworkStakeViewerRpcSchemas
+};
+
+// src/types/schema/createRequestSchema.ts
+import * as z24 from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z24.undefined()) => z24.object({
+  id: z24.union([
+    z24.string(),
+    z24.number()
+  ]),
+  jsonrpc: z24.literal(jsonrpc),
+  method: z24.literal(methodName),
+  params: paramsSchema
+}), "createRequestSchema");
+
+// src/types/schema/createResponseSchema.ts
+import * as z25 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z25.undefined()) => z25.object({
+  id: z25.union([
+    z25.string(),
+    z25.number()
+  ]),
+  jsonrpc: z25.literal(jsonrpc),
+  result: resultSchema
+}), "createResponseSchema");
+
+// src/types/schema/RewardsByPositionViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod4, 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: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z26.record(z26.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), BigIntToJsonZod4)
+    }
+  },
+  networkStakingStepRewardsByPositionViewer_claimed: {
+    params: {
+      from: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z26.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z26.record(z26.number(), BigIntToJsonZod4.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(), BigIntToJsonZod4.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(), BigIntToJsonZod4.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(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z26.record(z26.number(), JsonToBigIntZod4)
+    }
+  }
+};
+
+// src/types/schema/RewardsByStakerViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod5, 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, BigIntToJsonZod5),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_claimed: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod5),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_earned: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod5),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_total: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod5),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  },
+  networkStakingStepRewardsByStakerViewer_unclaimed: {
+    params: {
+      from: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z27.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z27.record(AddressZod, BigIntToJsonZod5),
+      to: z27.record(AddressZod, JsonToBigIntZod5)
+    }
+  }
+};
+
+// src/types/schema/RewardsByStepViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod6, 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, BigIntToJsonZod6),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  },
+  networkStakingStepRewardsByStepViewer_claimed: {
+    params: {
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
+    },
+    result: {
+      from: z28.record(AddressZod, BigIntToJsonZod6),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
+    }
+  },
+  networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      to: z21.tuple([
-        z21.number()
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        z21.number()
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: StakeToJsonZod,
-      from: JsonToStakeZod
+      from: z28.record(AddressZod, BigIntToJsonZod6),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
     }
   },
-  xyoViewer_stakedByStaker: {
+  networkStakingStepRewardsByStepViewer_total: {
     params: {
-      to: z21.tuple([
-        AddressZod
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        AddressZod
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: z21.array(AddressZod),
-      from: z21.array(AddressZod)
+      from: z28.record(AddressZod, BigIntToJsonZod6),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
     }
   },
-  xyoViewer_stakesByStaker: {
+  networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      to: z21.tuple([
-        AddressZod
+      from: z28.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        AddressZod
+      to: z28.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: z21.array(StakeToJsonZod),
-      from: z21.array(JsonToStakeZod)
+      from: z28.record(AddressZod, BigIntToJsonZod6),
+      to: z28.record(AddressZod, JsonToBigIntZod6)
     }
-  },
-  xyoViewer_stakesByStaked: {
+  }
+};
+
+// src/types/schema/RewardsTotalViewerRpcSchemas.ts
+import { BigIntToJsonZod as BigIntToJsonZod7, 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: {
-      to: z21.tuple([
-        AddressZod
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        AddressZod
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: z21.array(StakeToJsonZod),
-      from: z21.array(JsonToStakeZod)
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod7
     }
   },
-  xyoViewer_transactionByBlockHashAndIndex: {
+  networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      to: z21.tuple([
-        HashZod2,
-        z21.number()
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        HashZod2,
-        z21.number()
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod.nullable(),
-      from: SignedHydratedTransactionZod.nullable()
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod7
     }
   },
-  xyoViewer_transactionByBlockNumberAndIndex: {
+  networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      to: z21.tuple([
-        z21.number(),
-        z21.number()
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        z21.number(),
-        z21.number()
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod.nullable(),
-      from: SignedHydratedTransactionZod.nullable()
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod7
     }
   },
-  xyoViewer_transactionByHash: {
+  networkStakingStepRewardsTotalViewer_total: {
     params: {
-      to: z21.tuple([
-        HashZod2
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z21.tuple([
-        HashZod2
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod.nullable(),
-      from: SignedHydratedTransactionZod.nullable()
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod7
     }
-  }
-};
-
-// src/types/schema/AllRpcSchemas.ts
-var AllRpcSchemas = {
-  ...XyoProviderRpcSchemas,
-  ...XyoRunnerRpcSchemas,
-  ...XyoSignerRpcSchemas,
-  ...XyoViewerRpcSchemas,
-  ...XyoPermissionsRpcSchemas
-};
-
-// 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()
-  ]),
-  jsonrpc: z22.literal(jsonrpc),
-  method: z22.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()
-  ]),
-  jsonrpc: z23.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: {
+  },
+  networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z24.tuple([
-        BlockNumberZod.optional()
+      from: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
-        BlockNumberZod.optional()
+      to: z29.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: BigIntToJsonZod4,
-      to: JsonToBigIntZod3
+      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
+      to: BigIntToJsonZod7
     }
   }
 };
 
-// src/engine/rpcEngineFromConnection.ts
-var rpcEngineFromConnection = /* @__PURE__ */ __name((connection) => {
+// src/types/schema/StepRewardsViewerRpcSchemas.ts
+var NetworkStakingStepRewardsViewerRpcSchemas = {};
+
+// src/engine-node/rpcEngineFromConnection.ts
+var rpcEngineFromConnection = /* @__PURE__ */ __name((connection, networkStakeViewer) => {
   const engine = new JsonRpcEngine();
-  const handlers = rpcMethodHandlersFromConnection(connection);
+  const handlers = rpcMethodHandlersFromConnection(connection, networkStakeViewer);
   engine.push(createAsyncMiddleware(async (req, res) => {
     const method = req.method;
     const handler = handlers[method];
@@ -1459,8 +1695,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-sdk";
 
 // src/transport/HttpRpcTransport.ts
 import { AxiosJson } from "@xylabs/axios";
@@ -1548,16 +1784,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";
@@ -1828,88 +2054,256 @@ 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 { isDefined as isDefined2 } from "@xylabs/typeof";
+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
     ]));
   }
-  async accountBalanceHistory(address) {
-    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
+  async accountBalanceHistory(address, range) {
+    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", isDefined2(range) ? [
+      address,
+      range
+    ] : [
       address
     ]);
   }
@@ -2096,46 +2490,35 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async transferBalance(address) {
-    return asAttoXL12(await this.transport.sendRequest("xyoViewer_transferBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferBalance", [
       address
     ]));
   }
-  async transferBalanceHistory(address) {
-    return await this.transport.sendRequest("xyoViewer_transferBalanceHistory", [
-      address
-    ]);
+  transferBalanceHistory(address, range) {
+    throw new Error("Method not implemented.");
   }
   async transferPairBalance(pair) {
-    return asAttoXL12(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
       pair
     ]));
   }
-  async transferPairBalanceHistory(pair) {
-    return await this.transport.sendRequest("xyoViewer_transferPairBalanceHistory", [
-      pair
-    ]);
+  transferPairBalanceHistory(pair) {
+    throw new Error("Method not implemented.");
   }
 };
 
 // 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;
   }
@@ -2145,51 +2528,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
@@ -2198,33 +2542,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 { assertEx as assertEx5 } from "@xylabs/assert";
 import { isDefined as isDefined3 } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var AbstractXyoGateway = class {
   static {
@@ -2232,19 +2571,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 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
@@ -2253,20 +2589,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
@@ -2362,7 +2691,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");
@@ -2374,7 +2703,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();
@@ -2455,7 +2784,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");
@@ -2466,7 +2795,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();
@@ -2477,6 +2806,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,
@@ -2496,12 +2872,15 @@ export {
   BlockDurationZod,
   BlockEndZod,
   BlockNumberZod,
+  BlockRangeZod,
   BlockScriptsZod,
   BlockStartZod,
   BoundWitnessZod,
   CaveatTypesZod,
   CaveatsZod,
   ChainZod,
+  HashZod2 as HashZod,
+  HexZod2 as HexZod,
   HttpRpcTransport,
   HttpRpcXyoConnection,
   HttpXyoDataLake,
@@ -2511,8 +2890,11 @@ export {
   InvokerPermissionZod,
   JsonObjectZod,
   JsonRpcErrorCodes,
+  JsonRpcNetworkStakeViewer,
+  JsonRpcNetworkStakeViewerMethods,
+  JsonRpcNetworkStakingStepRewardsViewer,
+  JsonRpcNetworkStakingStepRewardsViewerMethods,
   JsonRpcXyoRunner,
-  JsonRpcXyoSigner,
   JsonRpcXyoViewer,
   JsonToAttoZod,
   JsonToSignedHydratedTransactionZod,
@@ -2527,7 +2909,18 @@ export {
   MemoryXyoPermissions,
   MemoryXyoRunner,
   MemoryXyoSigner,
+  NetworkStakeViewerRpcNamespace,
   NetworkStakeViewerRpcSchemas,
+  NetworkStakingStepRewardsByPositionViewerRpcNamespace,
+  NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+  NetworkStakingStepRewardsByStakerViewerRpcNamespace,
+  NetworkStakingStepRewardsByStakerViewerRpcSchemas,
+  NetworkStakingStepRewardsByStepViewerRpcNamespace,
+  NetworkStakingStepRewardsByStepViewerRpcSchemas,
+  NetworkStakingStepRewardsTotalViewerRpcNamespace,
+  NetworkStakingStepRewardsTotalViewerRpcSchemas,
+  NetworkStakingStepRewardsViewerRpcNamespace,
+  NetworkStakingStepRewardsViewerRpcSchemas,
   NodeXyoRunner,
   PayloadWithStorageMetaZod,
   PayloadZod,
@@ -2536,7 +2929,7 @@ export {
   QualifiedSequenceFromStringZod,
   QualifiedSequenceToStringZod,
   RequestedPermissionZod,
-  RpcXyoConnection,
+  RewardsRangeOptionsZod,
   RpcXyoPermissions,
   RpcXyoSigner,
   SchemaZod,
@@ -2564,24 +2957,29 @@ export {
   TransferFieldsZod,
   TransferPairZod,
   TransferZod,
+  TransferZodWithStorageMeta,
   UnsignedBoundWitnessWithStorageMetaZod,
   UnsignedBoundWitnessZod,
   UnsignedHydratedTransactionZod,
   WithStorageMetaZod,
   WithTransactionFeesZod,
+  XL1BlockNumberZod,
   XyoBaseConnection,
   XyoPermissionsRpcSchemas,
-  XyoProviderRpcSchemas,
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
-  buildSessionMessageRequest,
   createRequestSchema,
   createResponseSchema,
   jsonrpc,
   requestSchemas,
   rpcEngineFromConnection,
   rpcMethodHandlersFromConnection,
-  rpcMethodHandlersFromPermissions
+  rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer,
+  rpcMethodHandlersFromNetworkStakingViewer,
+  rpcMethodHandlersFromPermissions,
+  rpcMethodHandlersFromRunner,
+  rpcMethodHandlersFromSigner,
+  rpcMethodHandlersFromViewer
 };
 //# sourceMappingURL=index-node.mjs.map