@xyo-network/xl1-rpc 1.18.0-rc.1 → 1.18.1

package/dist/node/index-node.mjs

@@ -1,121 +1,123 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/engine/requestSchemas.ts
 var requestSchemas = {};
 
 // src/engine/rpcMethodHandlersFromAccountBalanceViewer.ts
-var rpcMethodHandlersFromAccountBalanceViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromAccountBalanceViewer = (viewer) => {
   return {
-    accountBalanceViewer_qualifiedAccountBalances: /* @__PURE__ */ __name((params) => viewer.qualifiedAccountBalances(...params ?? []), "accountBalanceViewer_qualifiedAccountBalances"),
-    accountBalanceViewer_qualifiedAccountBalanceHistories: /* @__PURE__ */ __name((params) => viewer.qualifiedAccountBalanceHistories(...params ?? []), "accountBalanceViewer_qualifiedAccountBalanceHistories")
+    accountBalanceViewer_qualifiedAccountBalances: (params) => viewer.qualifiedAccountBalances(...params ?? []),
+    accountBalanceViewer_qualifiedAccountBalanceHistories: (params) => viewer.qualifiedAccountBalanceHistories(...params ?? [])
   };
-}, "rpcMethodHandlersFromAccountBalanceViewer");
+};
 
 // src/engine/rpcMethodHandlersFromBlockViewer.ts
-var rpcMethodHandlersFromBlockViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromBlockViewer = (viewer) => {
   return {
-    blockViewer_blocksByHash: /* @__PURE__ */ __name((params) => viewer.blocksByHash(...params ?? []), "blockViewer_blocksByHash"),
-    blockViewer_blocksByNumber: /* @__PURE__ */ __name((params) => viewer.blocksByNumber(...params ?? []), "blockViewer_blocksByNumber"),
-    blockViewer_currentBlock: /* @__PURE__ */ __name((params) => viewer.currentBlock(...params ?? []), "blockViewer_currentBlock"),
-    blockViewer_payloadsByHash: /* @__PURE__ */ __name((params) => viewer.payloadsByHash(...params ?? []), "blockViewer_payloadsByHash")
+    blockViewer_blocksByHash: (params) => viewer.blocksByHash(...params ?? []),
+    blockViewer_blocksByNumber: (params) => viewer.blocksByNumber(...params ?? []),
+    blockViewer_currentBlock: (params) => viewer.currentBlock(...params ?? []),
+    blockViewer_payloadsByHash: (params) => viewer.payloadsByHash(...params ?? [])
   };
-}, "rpcMethodHandlersFromBlockViewer");
+};
 
 // src/engine/rpcMethodHandlersFromMempoolRunner.ts
-var rpcMethodHandlersFromMempoolRunner = /* @__PURE__ */ __name((runner) => {
+var rpcMethodHandlersFromMempoolRunner = (runner) => {
   return {
-    mempoolRunner_submitBlocks: /* @__PURE__ */ __name((params) => runner.submitBlocks(...params ?? []), "mempoolRunner_submitBlocks"),
-    mempoolRunner_submitTransactions: /* @__PURE__ */ __name((params) => runner.submitTransactions(...params ?? []), "mempoolRunner_submitTransactions")
+    mempoolRunner_submitBlocks: (params) => runner.submitBlocks(...params ?? []),
+    mempoolRunner_submitTransactions: (params) => runner.submitTransactions(...params ?? [])
   };
-}, "rpcMethodHandlersFromMempoolRunner");
+};
 
 // src/engine/rpcMethodHandlersFromMempoolViewer.ts
-var rpcMethodHandlersFromMempoolViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromMempoolViewer = (viewer) => {
   return {
-    mempoolViewer_pendingBlocks: /* @__PURE__ */ __name((params) => viewer.pendingBlocks(...params ?? []), "mempoolViewer_pendingBlocks"),
-    mempoolViewer_pendingTransactions: /* @__PURE__ */ __name((params) => viewer.pendingTransactions(...params ?? []), "mempoolViewer_pendingTransactions")
+    mempoolViewer_pendingBlocks: (params) => viewer.pendingBlocks(...params ?? []),
+    mempoolViewer_pendingTransactions: (params) => viewer.pendingTransactions(...params ?? [])
   };
-}, "rpcMethodHandlersFromMempoolViewer");
+};
 
 // src/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts
-var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = (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")
+    networkStakingStepRewardsByPositionViewer_bonus: (params) => viewer.bonus(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_claimed: (params) => viewer.claimed(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_earned: (params) => viewer.earned(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_total: (params) => viewer.total(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_unclaimed: (params) => viewer.unclaimed(...params ?? [])
   };
-}, "rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer");
+};
 
 // src/engine/rpcMethodHandlersFromRunner.ts
-var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
-  return {
-    xyoRunner_broadcastTransaction: /* @__PURE__ */ __name((params) => runner.broadcastTransaction(...params ?? []), "xyoRunner_broadcastTransaction")
-  };
-}, "rpcMethodHandlersFromRunner");
+var rpcMethodHandlersFromRunner = (runner) => {
+  return { xyoRunner_broadcastTransaction: (params) => runner.broadcastTransaction(...params ?? []) };
+};
 
 // src/engine/rpcMethodHandlersFromTimeSyncViewer.ts
-var rpcMethodHandlersFromTimeSyncViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromTimeSyncViewer = (viewer) => {
   return {
-    timeSyncViewer_convertTime: /* @__PURE__ */ __name((params) => viewer.convertTime(...params ?? []), "timeSyncViewer_convertTime"),
-    timeSyncViewer_currentTime: /* @__PURE__ */ __name((params) => viewer.currentTime(...params ?? []), "timeSyncViewer_currentTime"),
-    timeSyncViewer_currentTimeAndHash: /* @__PURE__ */ __name((params) => viewer.currentTimeAndHash(...params ?? []), "timeSyncViewer_currentTimeAndHash"),
-    timeSyncViewer_currentTimePayload: /* @__PURE__ */ __name((params) => viewer.currentTimePayload(...params ?? []), "timeSyncViewer_currentTimePayload")
+    timeSyncViewer_convertTime: (params) => viewer.convertTime(...params ?? []),
+    timeSyncViewer_currentTime: (params) => viewer.currentTime(...params ?? []),
+    timeSyncViewer_currentTimeAndHash: (params) => viewer.currentTimeAndHash(...params ?? []),
+    timeSyncViewer_currentTimePayload: (params) => viewer.currentTimePayload(...params ?? [])
   };
-}, "rpcMethodHandlersFromTimeSyncViewer");
+};
 
 // src/engine/rpcMethodHandlersFromViewer.ts
-var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromViewer = (viewer) => {
   return {
-    xyoViewer_networkStakeStepRewardClaimedByAddress: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardClaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardClaimedByAddress"),
-    xyoViewer_networkStakeStepRewardAddressReward: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardAddressReward(...params ?? []), "xyoViewer_networkStakeStepRewardAddressReward"),
-    xyoViewer_networkStakeStepRewardAddressHistory: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardAddressHistory(...params ?? []), "xyoViewer_networkStakeStepRewardAddressHistory"),
-    xyoViewer_networkStakeStepRewardAddressShare: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardAddressShare(...params ?? []), "xyoViewer_networkStakeStepRewardAddressShare"),
-    xyoViewer_networkStakeStepRewardWeightForAddress: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardWeightForAddress?.(...params ?? []), "xyoViewer_networkStakeStepRewardWeightForAddress"),
-    xyoViewer_networkStakeStepRewardUnclaimedByAddress: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardUnclaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardUnclaimedByAddress"),
-    xyoViewer_networkStakeStepRewardPoolShares: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPoolShares(...params ?? []), "xyoViewer_networkStakeStepRewardPoolShares"),
-    xyoViewer_networkStakeStepRewardPoolRewards: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPoolRewards(...params ?? []), "xyoViewer_networkStakeStepRewardPoolRewards"),
-    xyoViewer_networkStakeStepRewardPositionWeight: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPositionWeight?.(...params ?? []), "xyoViewer_networkStakeStepRewardPositionWeight"),
-    xyoViewer_networkStakeStepRewardPotentialPositionLoss: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPotentialPositionLoss?.(...params ?? []), "xyoViewer_networkStakeStepRewardPotentialPositionLoss"),
-    xyoViewer_networkStakeStepRewardForStep: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardForStep?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStep"),
-    xyoViewer_networkStakeStepRewardRandomizer: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardRandomizer?.(...params ?? []), "xyoViewer_networkStakeStepRewardRandomizer"),
-    xyoViewer_networkStakeStepRewardStakerCount: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardStakerCount?.(...params ?? []), "xyoViewer_networkStakeStepRewardStakerCount"),
-    xyoViewer_networkStakeStepRewardForStepForPosition: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardForStepForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStepForPosition"),
-    xyoViewer_networkStakeStepRewardForPosition: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForPosition"),
-    xyoViewer_networkStakeStepRewardsForPosition: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardsForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForPosition"),
-    xyoViewer_networkStakeStepRewardsForRange: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardsForRange?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForRange"),
-    xyoViewer_networkStakeStepRewardsForStepLevel: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardsForStepLevel?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForStepLevel"),
-    xyoViewer_accountBalance: /* @__PURE__ */ __name((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
-    xyoViewer_accountBalanceHistory: /* @__PURE__ */ __name((params) => viewer.accountBalanceHistory(...params ?? []), "xyoViewer_accountBalanceHistory"),
-    xyoViewer_blocksByNumber: /* @__PURE__ */ __name((params) => viewer.blocksByNumber(...params ?? []), "xyoViewer_blocksByNumber"),
-    xyoViewer_blocksByHash: /* @__PURE__ */ __name((params) => viewer.blocksByHash(...params ?? []), "xyoViewer_blocksByHash"),
-    xyoViewer_currentBlock: /* @__PURE__ */ __name((params) => viewer.currentBlock(...params ?? []), "xyoViewer_currentBlock"),
-    xyoViewer_forkHistory: /* @__PURE__ */ __name((params) => viewer.forkHistory(...params ?? []), "xyoViewer_forkHistory"),
-    xyoViewer_stakeById: /* @__PURE__ */ __name((params) => viewer.stakeById(...params ?? []), "xyoViewer_stakeById"),
-    xyoViewer_stakeByStaker: /* @__PURE__ */ __name((params) => viewer.stakeByStaker(...params ?? []), "xyoViewer_stakeByStaker"),
-    xyoViewer_stakesByStaked: /* @__PURE__ */ __name((params) => viewer.stakesByStaked(...params ?? []), "xyoViewer_stakesByStaked"),
-    xyoViewer_stakesByStaker: /* @__PURE__ */ __name((params) => viewer.stakesByStaker(...params ?? []), "xyoViewer_stakesByStaker"),
-    xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
-    xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
-    xyoViewer_transactionByHash: /* @__PURE__ */ __name((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash"),
-    xyoViewer_payloadsByHash: /* @__PURE__ */ __name((params) => viewer.payloadsByHash(...params ?? []), "xyoViewer_payloadsByHash")
+    xyoViewer_networkStakeStepRewardClaimedByAddress: (params) => viewer.networkStakeStepRewardClaimedByAddress(...params ?? []),
+    xyoViewer_networkStakeStepRewardAddressReward: (params) => viewer.networkStakeStepRewardAddressReward(...params ?? []),
+    xyoViewer_networkStakeStepRewardAddressHistory: (params) => viewer.networkStakeStepRewardAddressHistory(...params ?? []),
+    xyoViewer_networkStakeStepRewardAddressShare: (params) => viewer.networkStakeStepRewardAddressShare(...params ?? []),
+    xyoViewer_networkStakeStepRewardWeightForAddress: (params) => viewer.networkStakeStepRewardWeightForAddress?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardUnclaimedByAddress: (params) => viewer.networkStakeStepRewardUnclaimedByAddress(...params ?? []),
+    xyoViewer_networkStakeStepRewardPoolShares: (params) => viewer.networkStakeStepRewardPoolShares(...params ?? []),
+    xyoViewer_networkStakeStepRewardPoolRewards: (params) => viewer.networkStakeStepRewardPoolRewards(...params ?? []),
+    xyoViewer_networkStakeStepRewardPositionWeight: (params) => viewer.networkStakeStepRewardPositionWeight?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardPotentialPositionLoss: (params) => viewer.networkStakeStepRewardPotentialPositionLoss?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardForStep: (params) => viewer.networkStakeStepRewardForStep?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardRandomizer: (params) => viewer.networkStakeStepRewardRandomizer?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardStakerCount: (params) => viewer.networkStakeStepRewardStakerCount?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardForStepForPosition: (params) => viewer.networkStakeStepRewardForStepForPosition?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardForPosition: (params) => viewer.networkStakeStepRewardForPosition?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardsForPosition: (params) => viewer.networkStakeStepRewardsForPosition?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardsForRange: (params) => viewer.networkStakeStepRewardsForRange?.(...params ?? []),
+    xyoViewer_networkStakeStepRewardsForStepLevel: (params) => viewer.networkStakeStepRewardsForStepLevel?.(...params ?? []),
+    xyoViewer_accountBalance: (params) => viewer.accountBalance(...params ?? []),
+    xyoViewer_accountBalanceHistory: (params) => viewer.accountBalanceHistory(...params ?? []),
+    xyoViewer_blocksByNumber: (params) => viewer.blocksByNumber(...params ?? []),
+    xyoViewer_blocksByHash: (params) => viewer.blocksByHash(...params ?? []),
+    xyoViewer_currentBlock: (params) => viewer.currentBlock(...params ?? []),
+    xyoViewer_forkHistory: (params) => viewer.forkHistory(...params ?? []),
+    xyoViewer_stakeById: (params) => viewer.stakeById(...params ?? []),
+    xyoViewer_stakeByStaker: (params) => viewer.stakeByStaker(...params ?? []),
+    xyoViewer_stakesByStaked: (params) => viewer.stakesByStaked(...params ?? []),
+    xyoViewer_stakesByStaker: (params) => viewer.stakesByStaker(...params ?? []),
+    xyoViewer_transactionByBlockHashAndIndex: (params) => viewer.transactionByBlockHashAndIndex(...params ?? []),
+    xyoViewer_transactionByBlockNumberAndIndex: (params) => viewer.transactionByBlockNumberAndIndex(...params ?? []),
+    xyoViewer_transactionByHash: (params) => viewer.transactionByHash(...params ?? []),
+    xyoViewer_payloadsByHash: (params) => viewer.payloadsByHash(...params ?? [])
   };
-}, "rpcMethodHandlersFromViewer");
+};
 
 // src/engine/rpcMethodHandlersFromConnection.ts
-var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection) => {
+var rpcMethodHandlersFromConnection = (connection) => {
   const { runner, viewer } = connection;
   let result = {};
-  if (runner) result = {
-    ...result,
-    ...rpcMethodHandlersFromRunner(runner)
-  };
-  if (viewer) result = {
-    ...result,
-    ...rpcMethodHandlersFromViewer(viewer)
-  };
+  if (runner) result = { ...result, ...rpcMethodHandlersFromRunner(runner) };
+  if (viewer) result = { ...result, ...rpcMethodHandlersFromViewer(viewer) };
   const accountBalanceViewer = viewer?.account?.balance;
   if (accountBalanceViewer) {
     result = {
@@ -159,68 +161,51 @@ var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection) => {
     };
   }
   return result;
-}, "rpcMethodHandlersFromConnection");
+};
 
 // src/engine/rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer.ts
-var rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer = (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")
+    networkStakingStepRewardsByPositionViewer_bonus: (params) => viewer.bonus(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_claimed: (params) => viewer.claimed(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_earned: (params) => viewer.earned(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_total: (params) => viewer.total(...params ?? []),
+    networkStakingStepRewardsByPositionViewer_unclaimed: (params) => viewer.unclaimed(...params ?? [])
   };
-}, "rpcMethodHandlersFromNetworkStakeStepRewardsByPositionViewer");
+};
 
 // src/engine/rpcMethodHandlersFromNetworkStakingViewer.ts
-var rpcMethodHandlersFromNetworkStakingViewer = /* @__PURE__ */ __name((viewer) => {
-  return {
-    networkStakeViewer_active: /* @__PURE__ */ __name((params) => viewer.active(...params ?? []), "networkStakeViewer_active")
-  };
-}, "rpcMethodHandlersFromNetworkStakingViewer");
+var rpcMethodHandlersFromNetworkStakingViewer = (viewer) => {
+  return { networkStakeViewer_active: (params) => viewer.active(...params ?? []) };
+};
 
 // src/engine/rpcMethodHandlersFromPermissions.ts
-var rpcMethodHandlersFromPermissions = /* @__PURE__ */ __name((permissions) => {
+var rpcMethodHandlersFromPermissions = (permissions) => {
   return {
-    xyoPermissions_getPermissions: /* @__PURE__ */ __name((params) => permissions.getPermissions(...params ?? []), "xyoPermissions_getPermissions"),
-    xyoPermissions_requestPermissions: /* @__PURE__ */ __name((params) => permissions.requestPermissions(...params ?? []), "xyoPermissions_requestPermissions"),
-    xyoPermissions_revokePermissions: /* @__PURE__ */ __name((params) => permissions.revokePermissions(...params ?? []), "xyoPermissions_revokePermissions")
+    xyoPermissions_getPermissions: (params) => permissions.getPermissions(...params ?? []),
+    xyoPermissions_requestPermissions: (params) => permissions.requestPermissions(...params ?? []),
+    xyoPermissions_revokePermissions: (params) => permissions.revokePermissions(...params ?? [])
   };
-}, "rpcMethodHandlersFromPermissions");
+};
 
 // src/engine/rpcMethodHandlersFromSigner.ts
-var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
+var rpcMethodHandlersFromSigner = (signer) => {
   return {
-    xyoSigner_address: /* @__PURE__ */ __name((params) => signer.address(...params ?? []), "xyoSigner_address"),
-    xyoSigner_signTransaction: /* @__PURE__ */ __name((params) => signer.signTransaction(...params ?? []), "xyoSigner_signTransaction")
+    xyoSigner_address: (params) => signer.address(...params ?? []),
+    xyoSigner_signTransaction: (params) => signer.signTransaction(...params ?? [])
   };
-}, "rpcMethodHandlersFromSigner");
+};
 
 // src/engine-node/rpcEngineFromConnection.ts
 import { createAsyncMiddleware, JsonRpcEngine } from "@metamask/json-rpc-engine";
 
 // src/types/ErrorCodes.ts
 var JsonRpcErrorCodes = {
-  InternalError: {
-    code: -32603,
-    message: "Internal JSON-RPC error (unexpected exception)."
-  },
-  InvalidParams: {
-    code: -32602,
-    message: "Invalid method parameter(s)."
-  },
-  InvalidRequest: {
-    code: -32600,
-    message: "The JSON sent is not a valid Request object."
-  },
-  MethodNotFound: {
-    code: -32601,
-    message: "The method does not exist or is not available."
-  },
-  UserRejected: {
-    code: 4001,
-    message: "User rejected the request."
-  }
+  InternalError: { code: -32603, message: "Internal JSON-RPC error (unexpected exception)." },
+  InvalidParams: { code: -32602, message: "Invalid method parameter(s)." },
+  InvalidRequest: { code: -32600, message: "The JSON sent is not a valid Request object." },
+  MethodNotFound: { code: -32601, message: "The method does not exist or is not available." },
+  UserRejected: { code: 4001, message: "User rejected the request." }
 };
 
 // src/types/JsonRpc.ts
@@ -245,93 +230,50 @@ var NetworkStakingStepRewardsTotalViewerRpcNamespace = "networkStakingStepReward
 var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsViewer";
 
 // src/types/schema/AccountBalanceViewerRpcSchemas.ts
-import { AddressZod, BigIntToJsonZod, HashZod, JsonToBigIntZod } from "@xylabs/sdk-js";
-import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
-import { AccountBalanceHistoryItemZod, QualifiedZod } from "@xyo-network/xl1-protocol-sdk";
-import * as z from "zod";
+import {
+  AddressZod,
+  BigIntToJsonZod,
+  JsonToBigIntZod
+} from "@xylabs/sdk-js";
+import {
+  AccountBalanceHistoryItemZod,
+  ChainQualifiedConfigZod,
+  ChainQualifiedZod
+} from "@xyo-network/xl1-protocol-sdk";
+import { z } from "zod";
 var AccountBalanceViewerRpcSchemas = {
   accountBalanceViewer_qualifiedAccountBalances: {
     params: {
-      to: z.union([
-        z.tuple([
-          z.array(AddressZod)
-        ]),
-        z.tuple([
-          z.array(AddressZod),
-          z.union([
-            XL1BlockRangeZod,
-            HashZod
-          ])
-        ])
-      ]),
-      from: z.union([
-        z.tuple([
-          z.array(AddressZod)
-        ]),
-        z.tuple([
-          z.array(AddressZod),
-          z.union([
-            XL1BlockRangeZod,
-            HashZod
-          ])
-        ])
-      ])
-    },
-    result: {
-      to: QualifiedZod(z.record(AddressZod, BigIntToJsonZod)),
-      from: QualifiedZod(z.record(AddressZod, JsonToBigIntZod))
+      to: z.tuple([z.array(AddressZod), ChainQualifiedConfigZod]),
+      from: z.tuple([z.array(AddressZod), ChainQualifiedConfigZod])
+    },
+    result: {
+      to: ChainQualifiedZod(z.record(AddressZod, BigIntToJsonZod)),
+      from: ChainQualifiedZod(z.record(AddressZod, JsonToBigIntZod))
     }
   },
   accountBalanceViewer_qualifiedAccountBalanceHistories: {
     params: {
-      to: z.union([
-        z.tuple([
-          z.array(AddressZod)
-        ]),
-        z.tuple([
-          z.array(AddressZod),
-          z.union([
-            XL1BlockRangeZod,
-            HashZod
-          ])
-        ])
-      ]),
-      from: z.union([
-        z.tuple([
-          z.array(AddressZod)
-        ]),
-        z.tuple([
-          z.array(AddressZod),
-          z.union([
-            XL1BlockRangeZod,
-            HashZod
-          ])
-        ])
-      ])
-    },
-    result: {
-      to: QualifiedZod(z.record(AddressZod, z.array(AccountBalanceHistoryItemZod))),
-      from: QualifiedZod(z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)))
+      to: z.tuple([z.array(AddressZod), ChainQualifiedConfigZod]),
+      from: z.tuple([z.array(AddressZod), ChainQualifiedConfigZod])
+    },
+    result: {
+      to: ChainQualifiedZod(z.record(AddressZod, z.array(AccountBalanceHistoryItemZod))),
+      from: ChainQualifiedZod(z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)))
     }
   }
 };
 
 // src/types/schema/BlockViewerRpcSchemas.ts
-import { HashZod as HashZod2 } from "@xylabs/sdk-js";
+import { HashZod } from "@xylabs/sdk-js";
 import { PayloadZodLoose } from "@xyo-network/payload-model";
 import { SignedHydratedBlockWithHashMetaZod, XL1BlockNumberZod } from "@xyo-network/xl1-protocol";
-import * as z2 from "zod";
+import { z as z2 } from "zod";
 var BlockViewerRpcSchemas = {
   blockViewer_blocksByNumber: {
     params: {
-      to: z2.tuple([
-        XL1BlockNumberZod,
-        z2.number().optional()
-      ]),
-      from: z2.tuple([
-        XL1BlockNumberZod,
-        z2.number().optional()
-      ])
+      to: z2.tuple([XL1BlockNumberZod, z2.number().optional()]),
+      from: z2.tuple([XL1BlockNumberZod, z2.number().optional()])
     },
     result: {
       to: z2.array(SignedHydratedBlockWithHashMetaZod),
@@ -340,14 +282,8 @@ var BlockViewerRpcSchemas = {
   },
   blockViewer_blocksByHash: {
     params: {
-      to: z2.tuple([
-        HashZod2,
-        z2.number().optional()
-      ]),
-      from: z2.tuple([
-        HashZod2,
-        z2.number().optional()
-      ])
+      to: z2.tuple([HashZod, z2.number().optional()]),
+      from: z2.tuple([HashZod, z2.number().optional()])
     },
     result: {
       to: z2.array(SignedHydratedBlockWithHashMetaZod),
@@ -366,12 +302,8 @@ var BlockViewerRpcSchemas = {
   },
   blockViewer_payloadsByHash: {
     params: {
-      to: z2.tuple([
-        z2.array(HashZod2)
-      ]),
-      from: z2.tuple([
-        z2.array(HashZod2)
-      ])
+      to: z2.tuple([z2.array(HashZod)]),
+      from: z2.tuple([z2.array(HashZod)])
     },
     result: {
       to: z2.array(PayloadZodLoose),
@@ -381,59 +313,35 @@ var BlockViewerRpcSchemas = {
 };
 
 // src/types/schema/DataLakeViewerRpcSchema.ts
-import { HashZod as HashZod3 } from "@xylabs/sdk-js";
+import { HashZod as HashZod2 } from "@xylabs/sdk-js";
 import { PayloadZod } from "@xyo-network/payload-model";
 import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol";
-import * as z3 from "zod";
+import { z as z3 } from "zod";
 var DataLakeViewerRpcSchemas = {
   dataLakeViewer_get: {
     params: {
-      to: z3.tuple([
-        HashZod3
-      ]),
-      from: z3.tuple([
-        HashZod3
-      ])
+      to: z3.tuple([HashZod2]),
+      from: z3.tuple([HashZod2])
     },
     result: {
-      to: z3.union([
-        PayloadZod,
-        ArrayBufferToJsonZod
-      ]).optional(),
-      from: z3.union([
-        PayloadZod,
-        JsonToArrayBufferZod
-      ]).optional()
+      to: z3.union([PayloadZod, ArrayBufferToJsonZod]).optional(),
+      from: z3.union([PayloadZod, JsonToArrayBufferZod]).optional()
     }
   },
   dataLakeViewer_getMany: {
     params: {
-      to: z3.tuple([
-        z3.array(HashZod3)
-      ]),
-      from: z3.tuple([
-        z3.array(HashZod3)
-      ])
+      to: z3.tuple([z3.array(HashZod2)]),
+      from: z3.tuple([z3.array(HashZod2)])
     },
     result: {
-      to: z3.array(z3.union([
-        PayloadZod,
-        ArrayBufferToJsonZod
-      ])),
-      from: z3.array(z3.union([
-        PayloadZod,
-        JsonToArrayBufferZod
-      ]))
+      to: z3.array(z3.union([PayloadZod, ArrayBufferToJsonZod])),
+      from: z3.array(z3.union([PayloadZod, JsonToArrayBufferZod]))
     }
   },
   dataLakeViewer_has: {
     params: {
-      to: z3.tuple([
-        HashZod3
-      ]),
-      from: z3.tuple([
-        HashZod3
-      ])
+      to: z3.tuple([HashZod2]),
+      from: z3.tuple([HashZod2])
     },
     result: {
       to: z3.boolean(),
@@ -443,36 +351,28 @@ var DataLakeViewerRpcSchemas = {
 };
 
 // src/types/schema/MempoolRunnerRpcSchemas.ts
-import { HashZod as HashZod4 } from "@xylabs/sdk-js";
+import { HashZod as HashZod3 } from "@xylabs/sdk-js";
 import { SignedHydratedBlockZod, SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
-import * as z4 from "zod";
+import { z as z4 } from "zod";
 var MempoolRunnerRpcSchemas = {
   mempoolRunner_submitBlocks: {
     params: {
-      to: z4.tuple([
-        z4.array(SignedHydratedBlockZod)
-      ]),
-      from: z4.tuple([
-        z4.array(SignedHydratedBlockZod)
-      ])
+      to: z4.tuple([z4.array(SignedHydratedBlockZod)]),
+      from: z4.tuple([z4.array(SignedHydratedBlockZod)])
     },
     result: {
-      to: z4.array(HashZod4),
-      from: z4.array(HashZod4)
+      to: z4.array(HashZod3),
+      from: z4.array(HashZod3)
     }
   },
   mempoolRunner_submitTransactions: {
     params: {
-      to: z4.tuple([
-        z4.array(SignedHydratedTransactionZod)
-      ]),
-      from: z4.tuple([
-        z4.array(SignedHydratedTransactionZod)
-      ])
+      to: z4.tuple([z4.array(SignedHydratedTransactionZod)]),
+      from: z4.tuple([z4.array(SignedHydratedTransactionZod)])
     },
     result: {
-      to: z4.array(HashZod4),
-      from: z4.array(HashZod4)
+      to: z4.array(HashZod3),
+      from: z4.array(HashZod3)
     }
   }
 };
@@ -480,16 +380,12 @@ var MempoolRunnerRpcSchemas = {
 // src/types/schema/MempoolViewerRpcSchemas.ts
 import { SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod2, SignedHydratedTransactionWithHashMetaZod } from "@xyo-network/xl1-protocol";
 import { PendingBlocksOptionsZod, PendingTransactionsOptionsZod } from "@xyo-network/xl1-protocol-sdk";
-import * as z5 from "zod";
+import { z as z5 } from "zod";
 var MempoolViewerRpcSchemas = {
   mempoolViewer_pendingBlocks: {
     params: {
-      to: z5.tuple([
-        PendingBlocksOptionsZod.optional()
-      ]),
-      from: z5.tuple([
-        PendingBlocksOptionsZod.optional()
-      ])
+      to: z5.tuple([PendingBlocksOptionsZod.optional()]),
+      from: z5.tuple([PendingBlocksOptionsZod.optional()])
     },
     result: {
       to: z5.array(SignedHydratedBlockWithHashMetaZod2),
@@ -498,12 +394,8 @@ var MempoolViewerRpcSchemas = {
   },
   mempoolViewer_pendingTransactions: {
     params: {
-      to: z5.tuple([
-        PendingTransactionsOptionsZod.optional()
-      ]),
-      from: z5.tuple([
-        PendingTransactionsOptionsZod.optional()
-      ])
+      to: z5.tuple([PendingTransactionsOptionsZod.optional()]),
+      from: z5.tuple([PendingTransactionsOptionsZod.optional()])
     },
     result: {
       to: z5.array(SignedHydratedTransactionWithHashMetaZod),
@@ -515,26 +407,16 @@ var MempoolViewerRpcSchemas = {
 // src/types/schema/NetworkStakeViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/sdk-js";
 import { BlockNumberZod } from "@xyo-network/xl1-protocol";
-import * as z6 from "zod";
+import { z as z6 } from "zod";
 var NetworkStakeViewerRpcSchemas = {
   networkStakeViewer_active: {
     params: {
-      from: z6.tuple([
-        BlockNumberZod.optional()
-      ]),
-      to: z6.tuple([
-        BlockNumberZod.optional()
-      ])
+      from: z6.tuple([BlockNumberZod.optional()]),
+      to: z6.tuple([BlockNumberZod.optional()])
     },
     result: {
-      from: z6.tuple([
-        JsonToBigIntZod2,
-        z6.number()
-      ]),
-      to: z6.tuple([
-        BigIntToJsonZod2,
-        z6.number()
-      ])
+      from: z6.tuple([JsonToBigIntZod2, z6.number()]),
+      to: z6.tuple([BigIntToJsonZod2, z6.number()])
     }
   }
 };
@@ -542,16 +424,12 @@ var NetworkStakeViewerRpcSchemas = {
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod3 } from "@xylabs/sdk-js";
 import { asAttoXL1, RewardsRangeOptionsZod } from "@xyo-network/xl1-protocol";
-import z7 from "zod";
+import { z as z7 } from "zod";
 var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ]),
-      to: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ])
+      from: z7.tuple([RewardsRangeOptionsZod.optional()]),
+      to: z7.tuple([RewardsRangeOptionsZod.optional()])
     },
     result: {
       from: z7.record(z7.number(), JsonToBigIntZod3.transform((val) => asAttoXL1(val))),
@@ -560,12 +438,8 @@ var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   },
   networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      from: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ]),
-      to: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ])
+      from: z7.tuple([RewardsRangeOptionsZod.optional()]),
+      to: z7.tuple([RewardsRangeOptionsZod.optional()])
     },
     result: {
       from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
@@ -574,12 +448,8 @@ var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   },
   networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      from: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ]),
-      to: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ])
+      from: z7.tuple([RewardsRangeOptionsZod.optional()]),
+      to: z7.tuple([RewardsRangeOptionsZod.optional()])
     },
     result: {
       from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
@@ -588,12 +458,8 @@ var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   },
   networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      from: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ]),
-      to: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ])
+      from: z7.tuple([RewardsRangeOptionsZod.optional()]),
+      to: z7.tuple([RewardsRangeOptionsZod.optional()])
     },
     result: {
       from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
@@ -602,12 +468,8 @@ var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   },
   networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      from: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ]),
-      to: z7.tuple([
-        RewardsRangeOptionsZod.optional()
-      ])
+      from: z7.tuple([RewardsRangeOptionsZod.optional()]),
+      to: z7.tuple([RewardsRangeOptionsZod.optional()])
     },
     result: {
       from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
@@ -617,18 +479,18 @@ var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
 };
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-import { AddressZod as AddressZod2, BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
+import {
+  AddressZod as AddressZod2,
+  BigIntToJsonZod as BigIntToJsonZod4,
+  JsonToBigIntZod as JsonToBigIntZod4
+} from "@xylabs/sdk-js";
 import { RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol";
-import z8 from "zod";
+import { z as z8 } from "zod";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      from: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ]),
-      to: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ])
+      from: z8.tuple([RewardsRangeOptionsZod2.optional()]),
+      to: z8.tuple([RewardsRangeOptionsZod2.optional()])
     },
     result: {
       from: z8.record(AddressZod2, BigIntToJsonZod4),
@@ -637,12 +499,8 @@ var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      from: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ]),
-      to: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ])
+      from: z8.tuple([RewardsRangeOptionsZod2.optional()]),
+      to: z8.tuple([RewardsRangeOptionsZod2.optional()])
     },
     result: {
       from: z8.record(AddressZod2, BigIntToJsonZod4),
@@ -651,12 +509,8 @@ var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      from: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ]),
-      to: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ])
+      from: z8.tuple([RewardsRangeOptionsZod2.optional()]),
+      to: z8.tuple([RewardsRangeOptionsZod2.optional()])
     },
     result: {
       from: z8.record(AddressZod2, BigIntToJsonZod4),
@@ -665,12 +519,8 @@ var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      from: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ]),
-      to: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ])
+      from: z8.tuple([RewardsRangeOptionsZod2.optional()]),
+      to: z8.tuple([RewardsRangeOptionsZod2.optional()])
     },
     result: {
       from: z8.record(AddressZod2, BigIntToJsonZod4),
@@ -679,12 +529,8 @@ var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      from: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ]),
-      to: z8.tuple([
-        RewardsRangeOptionsZod2.optional()
-      ])
+      from: z8.tuple([RewardsRangeOptionsZod2.optional()]),
+      to: z8.tuple([RewardsRangeOptionsZod2.optional()])
     },
     result: {
       from: z8.record(AddressZod2, BigIntToJsonZod4),
@@ -694,18 +540,18 @@ var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
-import { AddressZod as AddressZod3, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
+import {
+  AddressZod as AddressZod3,
+  BigIntToJsonZod as BigIntToJsonZod5,
+  JsonToBigIntZod as JsonToBigIntZod5
+} from "@xylabs/sdk-js";
 import { RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol";
-import z9 from "zod";
+import { z as z9 } from "zod";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      from: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ]),
-      to: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ])
+      from: z9.tuple([RewardsRangeOptionsZod3.optional()]),
+      to: z9.tuple([RewardsRangeOptionsZod3.optional()])
     },
     result: {
       from: z9.record(AddressZod3, BigIntToJsonZod5),
@@ -714,12 +560,8 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      from: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ]),
-      to: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ])
+      from: z9.tuple([RewardsRangeOptionsZod3.optional()]),
+      to: z9.tuple([RewardsRangeOptionsZod3.optional()])
     },
     result: {
       from: z9.record(AddressZod3, BigIntToJsonZod5),
@@ -728,12 +570,8 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      from: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ]),
-      to: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ])
+      from: z9.tuple([RewardsRangeOptionsZod3.optional()]),
+      to: z9.tuple([RewardsRangeOptionsZod3.optional()])
     },
     result: {
       from: z9.record(AddressZod3, BigIntToJsonZod5),
@@ -742,12 +580,8 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStepViewer_total: {
     params: {
-      from: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ]),
-      to: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ])
+      from: z9.tuple([RewardsRangeOptionsZod3.optional()]),
+      to: z9.tuple([RewardsRangeOptionsZod3.optional()])
     },
     result: {
       from: z9.record(AddressZod3, BigIntToJsonZod5),
@@ -756,12 +590,8 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   },
   networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      from: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ]),
-      to: z9.tuple([
-        RewardsRangeOptionsZod3.optional()
-      ])
+      from: z9.tuple([RewardsRangeOptionsZod3.optional()]),
+      to: z9.tuple([RewardsRangeOptionsZod3.optional()])
     },
     result: {
       from: z9.record(AddressZod3, BigIntToJsonZod5),
@@ -773,16 +603,12 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
 import { asAttoXL1 as asAttoXL12, RewardsRangeOptionsZod as RewardsRangeOptionsZod4 } from "@xyo-network/xl1-protocol";
-import * as z10 from "zod";
+import { z as z10 } from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ]),
-      to: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ])
+      from: z10.tuple([RewardsRangeOptionsZod4.optional()]),
+      to: z10.tuple([RewardsRangeOptionsZod4.optional()])
     },
     result: {
       from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
@@ -791,12 +617,8 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      from: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ]),
-      to: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ])
+      from: z10.tuple([RewardsRangeOptionsZod4.optional()]),
+      to: z10.tuple([RewardsRangeOptionsZod4.optional()])
     },
     result: {
       from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
@@ -805,12 +627,8 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      from: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ]),
-      to: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ])
+      from: z10.tuple([RewardsRangeOptionsZod4.optional()]),
+      to: z10.tuple([RewardsRangeOptionsZod4.optional()])
     },
     result: {
       from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
@@ -819,12 +637,8 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_total: {
     params: {
-      from: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ]),
-      to: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ])
+      from: z10.tuple([RewardsRangeOptionsZod4.optional()]),
+      to: z10.tuple([RewardsRangeOptionsZod4.optional()])
     },
     result: {
       from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
@@ -833,12 +647,8 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ]),
-      to: z10.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ])
+      from: z10.tuple([RewardsRangeOptionsZod4.optional()]),
+      to: z10.tuple([RewardsRangeOptionsZod4.optional()])
     },
     result: {
       from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
@@ -848,8 +658,12 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
 };
 
 // src/types/schema/StakeTotalsViewerRpcSchemas.ts
-import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/sdk-js";
-import * as z11 from "zod";
+import {
+  AddressZod as AddressZod4,
+  BigIntToJsonZod as BigIntToJsonZod7,
+  JsonToBigIntZod as JsonToBigIntZod7
+} from "@xylabs/sdk-js";
+import { z as z11 } from "zod";
 var StakeTotalsViewerRpcSchemas = {
   stakeTotalsViewer_active: {
     params: {
@@ -863,12 +677,8 @@ var StakeTotalsViewerRpcSchemas = {
   },
   stakeTotalsViewer_activeByStaked: {
     params: {
-      to: z11.tuple([
-        AddressZod4
-      ]),
-      from: z11.tuple([
-        AddressZod4
-      ])
+      to: z11.tuple([AddressZod4]),
+      from: z11.tuple([AddressZod4])
     },
     result: {
       to: BigIntToJsonZod7,
@@ -877,12 +687,8 @@ var StakeTotalsViewerRpcSchemas = {
   },
   stakeTotalsViewer_activeByStaker: {
     params: {
-      to: z11.tuple([
-        AddressZod4
-      ]),
-      from: z11.tuple([
-        AddressZod4
-      ])
+      to: z11.tuple([AddressZod4]),
+      from: z11.tuple([AddressZod4])
     },
     result: {
       to: BigIntToJsonZod7,
@@ -901,12 +707,8 @@ var StakeTotalsViewerRpcSchemas = {
   },
   stakeTotalsViewer_pendingByStaker: {
     params: {
-      to: z11.tuple([
-        AddressZod4
-      ]),
-      from: z11.tuple([
-        AddressZod4
-      ])
+      to: z11.tuple([AddressZod4]),
+      from: z11.tuple([AddressZod4])
     },
     result: {
       to: BigIntToJsonZod7,
@@ -925,12 +727,8 @@ var StakeTotalsViewerRpcSchemas = {
   },
   stakeTotalsViewer_withdrawnByStaker: {
     params: {
-      to: z11.tuple([
-        AddressZod4
-      ]),
-      from: z11.tuple([
-        AddressZod4
-      ])
+      to: z11.tuple([AddressZod4]),
+      from: z11.tuple([AddressZod4])
     },
     result: {
       to: BigIntToJsonZod7,
@@ -943,18 +741,22 @@ var StakeTotalsViewerRpcSchemas = {
 var NetworkStakingStepRewardsViewerRpcSchemas = {};
 
 // src/types/schema/StepViewerRpcSchemas.ts
-import { AddressZod as AddressZod5, BigIntToJsonZod as BigIntToJsonZod8, JsonToBigIntZod as JsonToBigIntZod8 } from "@xylabs/sdk-js";
-import { JsonToStakeZod, StakeToJsonZod, StepIdentityZod } from "@xyo-network/xl1-protocol";
-import z12 from "zod";
+import {
+  AddressZod as AddressZod5,
+  BigIntToJsonZod as BigIntToJsonZod8,
+  JsonToBigIntZod as JsonToBigIntZod8
+} from "@xylabs/sdk-js";
+import {
+  JsonToStakeZod,
+  StakeToJsonZod,
+  StepIdentityZod
+} from "@xyo-network/xl1-protocol";
+import { z as z12 } from "zod";
 var StepViewerRpcSchemas = {
   randomizer: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: BigIntToJsonZod8,
@@ -963,12 +765,8 @@ var StepViewerRpcSchemas = {
   },
   stake: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: BigIntToJsonZod8,
@@ -977,12 +775,8 @@ var StepViewerRpcSchemas = {
   },
   stakers: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: z12.array(AddressZod5),
@@ -991,12 +785,8 @@ var StepViewerRpcSchemas = {
   },
   weight: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: BigIntToJsonZod8,
@@ -1005,12 +795,8 @@ var StepViewerRpcSchemas = {
   },
   positionCount: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: z12.number(),
@@ -1019,12 +805,8 @@ var StepViewerRpcSchemas = {
   },
   positions: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: z12.array(StakeToJsonZod),
@@ -1033,12 +815,8 @@ var StepViewerRpcSchemas = {
   },
   stakerCount: {
     params: {
-      from: z12.tuple([
-        StepIdentityZod
-      ]),
-      to: z12.tuple([
-        StepIdentityZod
-      ])
+      from: z12.tuple([StepIdentityZod]),
+      to: z12.tuple([StepIdentityZod])
     },
     result: {
       from: z12.number(),
@@ -1049,20 +827,12 @@ var StepViewerRpcSchemas = {
 
 // src/types/schema/TimeSyncViewerRpcSchema.ts
 import { TimeDomainZod, TimePayloadZod } from "@xyo-network/xl1-protocol";
-import * as z13 from "zod";
+import { z as z13 } from "zod";
 var TimeSyncViewerRpcSchemas = {
   timeSyncViewer_convertTime: {
     params: {
-      from: z13.tuple([
-        TimeDomainZod,
-        TimeDomainZod,
-        z13.number()
-      ]),
-      to: z13.tuple([
-        TimeDomainZod,
-        TimeDomainZod,
-        z13.number()
-      ])
+      from: z13.tuple([TimeDomainZod, TimeDomainZod, z13.number()]),
+      to: z13.tuple([TimeDomainZod, TimeDomainZod, z13.number()])
     },
     result: {
       from: z13.number(),
@@ -1071,42 +841,22 @@ var TimeSyncViewerRpcSchemas = {
   },
   timeSyncViewer_currentTime: {
     params: {
-      from: z13.tuple([
-        TimeDomainZod
-      ]),
-      to: z13.tuple([
-        TimeDomainZod
-      ])
+      from: z13.tuple([TimeDomainZod]),
+      to: z13.tuple([TimeDomainZod])
     },
     result: {
-      from: z13.tuple([
-        TimeDomainZod,
-        z13.number()
-      ]),
-      to: z13.tuple([
-        TimeDomainZod,
-        z13.number()
-      ])
+      from: z13.tuple([TimeDomainZod, z13.number()]),
+      to: z13.tuple([TimeDomainZod, z13.number()])
     }
   },
   timeSyncViewer_currentTimeAndHash: {
     params: {
-      from: z13.tuple([
-        TimeDomainZod
-      ]),
-      to: z13.tuple([
-        TimeDomainZod
-      ])
+      from: z13.tuple([TimeDomainZod]),
+      to: z13.tuple([TimeDomainZod])
     },
     result: {
-      from: z13.tuple([
-        z13.number(),
-        z13.nullable(z13.string())
-      ]),
-      to: z13.tuple([
-        z13.number(),
-        z13.nullable(z13.string())
-      ])
+      from: z13.tuple([z13.number(), z13.nullable(z13.string())]),
+      to: z13.tuple([z13.number(), z13.nullable(z13.string())])
     }
   },
   timeSyncViewer_currentTimePayload: {
@@ -1122,8 +872,12 @@ var TimeSyncViewerRpcSchemas = {
 };
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
-import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol";
-import * as z14 from "zod";
+import {
+  InvokerPermissionZod,
+  PermissionRequestZod,
+  RequestedPermissionZod
+} from "@xyo-network/xl1-protocol";
+import { z as z14 } from "zod";
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
@@ -1137,12 +891,8 @@ var XyoPermissionsRpcSchemas = {
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z14.tuple([
-        z14.array(PermissionRequestZod)
-      ]),
-      from: z14.tuple([
-        z14.array(PermissionRequestZod)
-      ])
+      to: z14.tuple([z14.array(PermissionRequestZod)]),
+      from: z14.tuple([z14.array(PermissionRequestZod)])
     },
     result: {
       to: z14.array(RequestedPermissionZod),
@@ -1151,12 +901,8 @@ var XyoPermissionsRpcSchemas = {
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z14.tuple([
-        z14.array(PermissionRequestZod)
-      ]),
-      from: z14.tuple([
-        z14.array(PermissionRequestZod)
-      ])
+      to: z14.tuple([z14.array(PermissionRequestZod)]),
+      from: z14.tuple([z14.array(PermissionRequestZod)])
     },
     result: {
       to: z14.array(RequestedPermissionZod),
@@ -1168,16 +914,12 @@ var XyoPermissionsRpcSchemas = {
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod, JsonToHashZod } from "@xylabs/sdk-js";
 import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-protocol";
-import * as z15 from "zod";
+import { z as z15 } from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z15.tuple([
-        SignedHydratedTransactionZod2
-      ]),
-      from: z15.tuple([
-        SignedHydratedTransactionZod2
-      ])
+      to: z15.tuple([SignedHydratedTransactionZod2]),
+      from: z15.tuple([SignedHydratedTransactionZod2])
     },
     result: {
       to: HashToJsonZod,
@@ -1203,12 +945,8 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z16.tuple([
-        UnsignedHydratedTransactionZod
-      ]),
-      from: z16.tuple([
-        UnsignedHydratedTransactionZod
-      ])
+      to: z16.tuple([UnsignedHydratedTransactionZod]),
+      from: z16.tuple([UnsignedHydratedTransactionZod])
     },
     result: {
       to: SignedHydratedTransactionWithHashMetaZod2,
@@ -1218,20 +956,30 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { AddressZod as AddressZod7, BigIntToJsonZod as BigIntToJsonZod9, HashZod as HashZod5, HexZod, JsonToBigIntZod as JsonToBigIntZod9 } from "@xylabs/sdk-js";
+import {
+  AddressZod as AddressZod7,
+  BigIntToJsonZod as BigIntToJsonZod9,
+  HashZod as HashZod4,
+  HexZod,
+  JsonToBigIntZod as JsonToBigIntZod9
+} from "@xylabs/sdk-js";
 import { PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/payload-model";
-import { JsonToStakeZod as JsonToStakeZod2, SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3, SignedHydratedTransactionZod as SignedHydratedTransactionZod3, StakeToJsonZod as StakeToJsonZod2, StepIdentityZod as StepIdentityZod2, XL1BlockNumberZod as XL1BlockNumberZod2, XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
+import {
+  JsonToStakeZod as JsonToStakeZod2,
+  SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3,
+  SignedHydratedTransactionZod as SignedHydratedTransactionZod3,
+  StakeToJsonZod as StakeToJsonZod2,
+  StepIdentityZod as StepIdentityZod2,
+  XL1BlockNumberZod as XL1BlockNumberZod2,
+  XL1BlockRangeZod
+} from "@xyo-network/xl1-protocol";
 import { AccountBalanceHistoryItemZod as AccountBalanceHistoryItemZod2 } from "@xyo-network/xl1-protocol-sdk";
-import * as z17 from "zod";
+import { z as z17 } from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z17.tuple([
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        AddressZod7
-      ])
+      to: z17.tuple([AddressZod7]),
+      from: z17.tuple([AddressZod7])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1240,14 +988,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2,
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2,
-        AddressZod7
-      ])
+      to: z17.tuple([StepIdentityZod2, AddressZod7]),
+      from: z17.tuple([StepIdentityZod2, AddressZod7])
     },
     result: {
       to: z17.record(AddressZod7, BigIntToJsonZod9),
@@ -1256,12 +998,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z17.tuple([
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        AddressZod7
-      ])
+      to: z17.tuple([AddressZod7]),
+      from: z17.tuple([AddressZod7])
     },
     result: {
       to: z17.record(AddressZod7, BigIntToJsonZod9),
@@ -1270,36 +1008,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2,
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2,
-        AddressZod7
-      ])
+      to: z17.tuple([StepIdentityZod2, AddressZod7]),
+      from: z17.tuple([StepIdentityZod2, AddressZod7])
     },
     result: {
-      to: z17.tuple([
-        BigIntToJsonZod9,
-        BigIntToJsonZod9
-      ]),
-      from: z17.tuple([
-        JsonToBigIntZod9,
-        JsonToBigIntZod9
-      ])
+      to: z17.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z17.tuple([JsonToBigIntZod9, JsonToBigIntZod9])
     }
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2,
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2,
-        AddressZod7
-      ])
+      to: z17.tuple([StepIdentityZod2, AddressZod7]),
+      from: z17.tuple([StepIdentityZod2, AddressZod7])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1308,12 +1028,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z17.tuple([
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        AddressZod7
-      ])
+      to: z17.tuple([AddressZod7]),
+      from: z17.tuple([AddressZod7])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1322,12 +1038,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2
-      ])
+      to: z17.tuple([StepIdentityZod2]),
+      from: z17.tuple([StepIdentityZod2])
     },
     result: {
       to: z17.record(AddressZod7, BigIntToJsonZod9),
@@ -1336,14 +1048,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2,
-        z17.number()
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2,
-        z17.number()
-      ])
+      to: z17.tuple([StepIdentityZod2, z17.number()]),
+      from: z17.tuple([StepIdentityZod2, z17.number()])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1352,14 +1058,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2,
-        z17.number()
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2,
-        z17.number()
-      ])
+      to: z17.tuple([StepIdentityZod2, z17.number()]),
+      from: z17.tuple([StepIdentityZod2, z17.number()])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1368,12 +1068,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2
-      ])
+      to: z17.tuple([StepIdentityZod2]),
+      from: z17.tuple([StepIdentityZod2])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1382,12 +1078,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2
-      ])
+      to: z17.tuple([StepIdentityZod2]),
+      from: z17.tuple([StepIdentityZod2])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1396,12 +1088,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2
-      ])
+      to: z17.tuple([StepIdentityZod2]),
+      from: z17.tuple([StepIdentityZod2])
     },
     result: {
       to: z17.number(),
@@ -1410,12 +1098,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2
-      ])
+      to: z17.tuple([StepIdentityZod2]),
+      from: z17.tuple([StepIdentityZod2])
     },
     result: {
       to: z17.record(AddressZod7, BigIntToJsonZod9),
@@ -1424,68 +1108,28 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z17.tuple([
-        StepIdentityZod2,
-        z17.number()
-      ]),
-      from: z17.tuple([
-        StepIdentityZod2,
-        z17.number()
-      ])
+      to: z17.tuple([StepIdentityZod2, z17.number()]),
+      from: z17.tuple([StepIdentityZod2, z17.number()])
     },
     result: {
-      to: z17.tuple([
-        BigIntToJsonZod9,
-        BigIntToJsonZod9
-      ]),
-      from: z17.tuple([
-        JsonToBigIntZod9,
-        JsonToBigIntZod9
-      ])
+      to: z17.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z17.tuple([JsonToBigIntZod9, JsonToBigIntZod9])
     }
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z17.tuple([
-        z17.number(),
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ]),
-      from: z17.tuple([
-        z17.number(),
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ])
-    },
-    result: {
-      to: z17.tuple([
-        BigIntToJsonZod9,
-        BigIntToJsonZod9
-      ]),
-      from: z17.tuple([
-        JsonToBigIntZod9,
-        JsonToBigIntZod9
-      ])
+      to: z17.tuple([z17.number(), z17.tuple([z17.number(), z17.number()])]),
+      from: z17.tuple([z17.number(), z17.tuple([z17.number(), z17.number()])])
+    },
+    result: {
+      to: z17.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z17.tuple([JsonToBigIntZod9, JsonToBigIntZod9])
     }
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z17.tuple([
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ]),
-      from: z17.tuple([
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ])
+      to: z17.tuple([z17.tuple([z17.number(), z17.number()])]),
+      from: z17.tuple([z17.tuple([z17.number(), z17.number()])])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1494,20 +1138,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z17.tuple([
-        z17.number(),
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ]),
-      from: z17.tuple([
-        z17.number(),
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ])
+      to: z17.tuple([z17.number(), z17.tuple([z17.number(), z17.number()])]),
+      from: z17.tuple([z17.number(), z17.tuple([z17.number(), z17.number()])])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1516,58 +1148,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z17.tuple([
-        z17.number(),
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ]),
-      from: z17.tuple([
-        z17.number(),
-        z17.tuple([
-          z17.number(),
-          z17.number()
-        ])
-      ])
-    },
-    result: {
-      to: z17.record(z17.string(), z17.tuple([
-        BigIntToJsonZod9,
-        BigIntToJsonZod9
-      ])),
-      from: z17.record(z17.string(), z17.tuple([
-        JsonToBigIntZod9,
-        JsonToBigIntZod9
-      ]))
+      to: z17.tuple([z17.number(), z17.tuple([z17.number(), z17.number()])]),
+      from: z17.tuple([z17.number(), z17.tuple([z17.number(), z17.number()])])
+    },
+    result: {
+      to: z17.record(z17.string(), z17.tuple([BigIntToJsonZod9, BigIntToJsonZod9])),
+      from: z17.record(z17.string(), z17.tuple([JsonToBigIntZod9, JsonToBigIntZod9]))
     }
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z17.union([
-        z17.tuple([
-          AddressZod7
-        ]),
-        z17.tuple([
-          AddressZod7,
-          z17.union([
-            XL1BlockRangeZod2,
-            HashZod5
-          ])
-        ])
-      ]),
-      from: z17.union([
-        z17.tuple([
-          AddressZod7
-        ]),
-        z17.tuple([
-          AddressZod7,
-          z17.union([
-            XL1BlockRangeZod2,
-            HashZod5
-          ])
-        ])
-      ])
+      to: z17.union([z17.tuple([AddressZod7]), z17.tuple([AddressZod7, z17.union([XL1BlockRangeZod, HashZod4])])]),
+      from: z17.union([z17.tuple([AddressZod7]), z17.tuple([AddressZod7, z17.union([XL1BlockRangeZod, HashZod4])])])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1576,30 +1168,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z17.union([
-        z17.tuple([
-          AddressZod7
-        ]),
-        z17.tuple([
-          AddressZod7,
-          z17.union([
-            XL1BlockRangeZod2,
-            HashZod5
-          ])
-        ])
-      ]),
-      from: z17.union([
-        z17.tuple([
-          AddressZod7
-        ]),
-        z17.tuple([
-          AddressZod7,
-          z17.union([
-            XL1BlockRangeZod2,
-            HashZod5
-          ])
-        ])
-      ])
+      to: z17.union([z17.tuple([AddressZod7]), z17.tuple([AddressZod7, z17.union([XL1BlockRangeZod, HashZod4])])]),
+      from: z17.union([z17.tuple([AddressZod7]), z17.tuple([AddressZod7, z17.union([XL1BlockRangeZod, HashZod4])])])
     },
     result: {
       to: z17.array(AccountBalanceHistoryItemZod2),
@@ -1608,14 +1178,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByNumber: {
     params: {
-      to: z17.tuple([
-        XL1BlockNumberZod2,
-        z17.number().optional()
-      ]),
-      from: z17.tuple([
-        XL1BlockNumberZod2,
-        z17.number().optional()
-      ])
+      to: z17.tuple([XL1BlockNumberZod2, z17.number().optional()]),
+      from: z17.tuple([XL1BlockNumberZod2, z17.number().optional()])
     },
     result: {
       to: z17.array(SignedHydratedBlockWithHashMetaZod3),
@@ -1624,14 +1188,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z17.tuple([
-        HashZod5,
-        z17.number().optional()
-      ]),
-      from: z17.tuple([
-        HashZod5,
-        z17.number().optional()
-      ])
+      to: z17.tuple([HashZod4, z17.number().optional()]),
+      from: z17.tuple([HashZod4, z17.number().optional()])
     },
     result: {
       to: z17.array(SignedHydratedBlockWithHashMetaZod3),
@@ -1660,14 +1218,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z17.tuple([
-        AddressZod7,
-        z17.number()
-      ]),
-      from: z17.tuple([
-        AddressZod7,
-        z17.number()
-      ])
+      to: z17.tuple([AddressZod7, z17.number()]),
+      from: z17.tuple([AddressZod7, z17.number()])
     },
     result: {
       to: StakeToJsonZod2,
@@ -1676,12 +1228,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z17.tuple([
-        z17.number()
-      ]),
-      from: z17.tuple([
-        z17.number()
-      ])
+      to: z17.tuple([z17.number()]),
+      from: z17.tuple([z17.number()])
     },
     result: {
       to: StakeToJsonZod2,
@@ -1690,12 +1238,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z17.tuple([
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        AddressZod7
-      ])
+      to: z17.tuple([AddressZod7]),
+      from: z17.tuple([AddressZod7])
     },
     result: {
       to: z17.array(StakeToJsonZod2),
@@ -1704,12 +1248,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z17.tuple([
-        AddressZod7
-      ]),
-      from: z17.tuple([
-        AddressZod7
-      ])
+      to: z17.tuple([AddressZod7]),
+      from: z17.tuple([AddressZod7])
     },
     result: {
       to: z17.array(StakeToJsonZod2),
@@ -1718,14 +1258,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z17.tuple([
-        HashZod5,
-        z17.number()
-      ]),
-      from: z17.tuple([
-        HashZod5,
-        z17.number()
-      ])
+      to: z17.tuple([HashZod4, z17.number()]),
+      from: z17.tuple([HashZod4, z17.number()])
     },
     result: {
       to: SignedHydratedTransactionZod3.nullable(),
@@ -1734,14 +1268,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z17.tuple([
-        z17.number(),
-        z17.number()
-      ]),
-      from: z17.tuple([
-        z17.number(),
-        z17.number()
-      ])
+      to: z17.tuple([z17.number(), z17.number()]),
+      from: z17.tuple([z17.number(), z17.number()])
     },
     result: {
       to: SignedHydratedTransactionZod3.nullable(),
@@ -1750,12 +1278,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z17.tuple([
-        HashZod5
-      ]),
-      from: z17.tuple([
-        HashZod5
-      ])
+      to: z17.tuple([HashZod4]),
+      from: z17.tuple([HashZod4])
     },
     result: {
       to: SignedHydratedTransactionZod3.nullable(),
@@ -1764,12 +1288,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_payloadsByHash: {
     params: {
-      to: z17.tuple([
-        z17.array(HashZod5)
-      ]),
-      from: z17.tuple([
-        z17.array(HashZod5)
-      ])
+      to: z17.tuple([z17.array(HashZod4)]),
+      from: z17.tuple([z17.array(HashZod4)])
     },
     result: {
       to: z17.array(PayloadZodLoose2),
@@ -1801,73 +1321,77 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z18 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z18.undefined()) => z18.object({
-  id: z18.union([
-    z18.string(),
-    z18.number()
-  ]),
+import { z as z18 } from "zod";
+var createRequestSchema = (methodName, paramsSchema = z18.undefined()) => z18.object({
+  id: z18.union([z18.string(), z18.number()]),
   jsonrpc: z18.literal(jsonrpc),
   method: z18.literal(methodName),
   params: paramsSchema
-}), "createRequestSchema");
+});
 
 // src/types/schema/createResponseSchema.ts
-import * as z19 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z19.undefined()) => z19.object({
-  id: z19.union([
-    z19.string(),
-    z19.number()
-  ]),
+import { z as z19 } from "zod";
+var createResponseSchema = (resultSchema = z19.undefined()) => z19.object({
+  id: z19.union([z19.string(), z19.number()]),
   jsonrpc: z19.literal(jsonrpc),
   result: resultSchema
-}), "createResponseSchema");
+});
 
 // src/engine-node/rpcEngineFromConnection.ts
-var rpcEngineFromConnection = /* @__PURE__ */ __name((connection) => {
+var rpcEngineFromConnection = (connection) => {
   const engine = new JsonRpcEngine();
   const handlers = rpcMethodHandlersFromConnection(connection);
-  engine.push(createAsyncMiddleware(async (req, res) => {
-    const method = req.method;
-    const handler = handlers[method];
-    const schema = AllRpcSchemas[method];
-    if (schema === void 0 || handler === void 0) {
-      res.error = JsonRpcErrorCodes.MethodNotFound;
-      return;
-    }
-    let requestSchema = requestSchemas[method];
-    if (requestSchema == void 0) {
-      requestSchema = createRequestSchema(method, schema.params.from);
-      requestSchemas[method] = requestSchema;
-    }
-    const parsed = requestSchema.safeParse(req);
-    if (!parsed.success) {
-      console.error("RPC Request Validation Error:", parsed.error);
-      res.error = {
-        // Return invalid params error
-        ...JsonRpcErrorCodes.InvalidParams,
-        // with the specific validation error message
-        message: parsed.error.message
-      };
-      return;
-    }
-    const { params } = parsed.data;
-    try {
-      const result = await handler(params);
-      res.result = schema.result.to.parse(result);
-    } catch (error) {
-      console.error("RPC Response Handler Error:", error);
-      throw error;
-    }
-  }));
+  engine.push(
+    createAsyncMiddleware(async (req, res) => {
+      const method = req.method;
+      const handler = handlers[method];
+      const schema = AllRpcSchemas[method];
+      if (schema === void 0 || handler === void 0) {
+        res.error = JsonRpcErrorCodes.MethodNotFound;
+        return;
+      }
+      let requestSchema = requestSchemas[method];
+      if (requestSchema == void 0) {
+        requestSchema = createRequestSchema(method, schema.params.from);
+        requestSchemas[method] = requestSchema;
+      }
+      const parsed = requestSchema.safeParse(req);
+      if (!parsed.success) {
+        console.error("RPC Request Validation Error:", parsed.error);
+        res.error = {
+          // Return invalid params error
+          ...JsonRpcErrorCodes.InvalidParams,
+          // with the specific validation error message
+          message: parsed.error.message
+        };
+        return;
+      }
+      const { params } = parsed.data;
+      try {
+        const result = await handler(params);
+        res.result = schema.result.to.parse(result);
+      } catch (error) {
+        console.error("RPC Response Handler Error:", error);
+        throw error;
+      }
+    })
+  );
   return engine;
-}, "rpcEngineFromConnection");
+};
+
+// src/provider/datalake/JsonRpcDataLakeViewer.ts
+import { creatableProvider as creatableProvider9 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
 import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
-import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2, creatableProvider } from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+import {
+  AccountBalanceViewerMoniker
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcViewer.ts
 import { isDefined as isDefined2 } from "@xylabs/sdk-js";
@@ -1875,14 +1399,15 @@ import { AbstractCreatableProvider } from "@xyo-network/xl1-protocol-sdk";
 
 // src/transport/HttpRpcTransport.ts
 import { axiosJsonConfig } from "@xylabs/axios";
-import { isDefined, isError, isUndefinedOrNull } from "@xylabs/sdk-js";
+import {
+  isDefined,
+  isError,
+  isUndefinedOrNull
+} from "@xylabs/sdk-js";
 import { Axios, isAxiosError } from "axios";
 import { v4 } from "uuid";
-import * as z20 from "zod";
+import { z as z20 } from "zod";
 var HttpRpcTransport = class {
-  static {
-    __name(this, "HttpRpcTransport");
-  }
   _passThrough;
   _rpcUrl;
   _schemas;
@@ -1910,11 +1435,11 @@ var HttpRpcTransport = class {
         }
       }
       const res = await new Axios(axiosJsonConfig()).post(url, body);
-      const json2 = res.data;
-      if (isUndefinedOrNull(json2) || json2.error) {
-        throw new Error(json2.error.message);
+      const json = res.data;
+      if (isUndefinedOrNull(json) || json.error) {
+        throw new Error(json.error.message);
       }
-      const result = isDefined(schema) ? schemas[method].result.from.parse(json2.result) : json2.result;
+      const result = isDefined(schema) ? schemas[method].result.from.parse(json.result) : json.result;
       return result;
     } catch (ex) {
       let message = isError(ex) ? ex.message : String(ex);
@@ -1927,12 +1452,13 @@ var HttpRpcTransport = class {
 };
 
 // src/transport/MemoryRpcTransport.ts
-import { assertEx, isObject, isString } from "@xylabs/sdk-js";
+import {
+  assertEx,
+  isObject,
+  isString
+} from "@xylabs/sdk-js";
 import { v4 as v42 } from "uuid";
 var MemoryRpcTransport = class {
-  static {
-    __name(this, "MemoryRpcTransport");
-  }
   _rpcEngine;
   _schemas;
   requestSchemas = {};
@@ -1968,9 +1494,6 @@ var MemoryRpcTransport = class {
 
 // src/provider/viewer/JsonRpcViewer.ts
 var AbstractJsonRpcViewer = class extends AbstractCreatableProvider {
-  static {
-    __name(this, "AbstractJsonRpcViewer");
-  }
   _transport;
   get transport() {
     return this.params.transport;
@@ -1990,24 +1513,18 @@ var AbstractJsonRpcViewer = class extends AbstractCreatableProvider {
 
 // src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
 var JsonRpcAccountBalanceViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcAccountBalanceViewerMethods");
-  }
-  async qualifiedAccountBalanceHistories(addresses, headOrRange) {
-    return await this.transport.sendRequest("accountBalanceViewer_qualifiedAccountBalanceHistories", headOrRange ? [
-      addresses,
-      headOrRange
-    ] : [
-      addresses
-    ]);
-  }
-  async qualifiedAccountBalances(addresses, headOrRange) {
-    return await this.transport.sendRequest("accountBalanceViewer_qualifiedAccountBalances", headOrRange ? [
-      addresses,
-      headOrRange
-    ] : [
-      addresses
-    ]);
+  moniker = AccountBalanceViewerMoniker;
+  async qualifiedAccountBalanceHistories(addresses, config) {
+    return await this.transport.sendRequest(
+      "accountBalanceViewer_qualifiedAccountBalanceHistories",
+      [addresses, config]
+    );
+  }
+  async qualifiedAccountBalances(addresses, config) {
+    return await this.transport.sendRequest(
+      "accountBalanceViewer_qualifiedAccountBalances",
+      [addresses, config]
+    );
   }
   schemas() {
     return AccountBalanceViewerRpcSchemas;
@@ -2015,76 +1532,73 @@ var JsonRpcAccountBalanceViewerMethods = class extends AbstractJsonRpcViewer {
 };
 
 // src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
-var JsonRpcAccountBalanceViewer = class _JsonRpcAccountBalanceViewer extends JsonRpcAccountBalanceViewerMethods {
-  static {
-    __name(this, "JsonRpcAccountBalanceViewer");
-  }
-  static defaultMoniker = AccountBalanceViewerMoniker;
-  static monikers = [
-    AccountBalanceViewerMoniker
-  ];
-  moniker = _JsonRpcAccountBalanceViewer.defaultMoniker;
-  async accountBalance(address, headOrRange) {
-    const result = await this.accountBalances([
-      address
-    ], headOrRange);
+var JsonRpcAccountBalanceViewer = class extends JsonRpcAccountBalanceViewerMethods {
+  async accountBalance(address, config = {}) {
+    const result = await this.accountBalances([address], config);
     return result[address];
   }
-  async accountBalanceHistories(address, headOrRange) {
-    const [result] = await this.qualifiedAccountBalanceHistories(address, headOrRange);
+  async accountBalanceHistories(address, config = {}) {
+    const [result] = await this.qualifiedAccountBalanceHistories(address, config);
     return result;
   }
-  async accountBalanceHistory(address, headOrRange) {
-    const result = await this.accountBalanceHistories([
-      address
-    ], headOrRange);
+  async accountBalanceHistory(address, config = {}) {
+    const result = await this.accountBalanceHistories([address], config);
     return result[address];
   }
-  async accountBalances(address, headOrRange) {
-    const [result] = await this.qualifiedAccountBalances(address, headOrRange);
+  async accountBalances(address, config = {}) {
+    const [result] = await this.qualifiedAccountBalances(address, config);
     return result;
   }
 };
+__publicField(JsonRpcAccountBalanceViewer, "defaultMoniker", AccountBalanceViewerMoniker2);
+__publicField(JsonRpcAccountBalanceViewer, "dependencies", []);
+__publicField(JsonRpcAccountBalanceViewer, "monikers", [AccountBalanceViewerMoniker2]);
+JsonRpcAccountBalanceViewer = __decorateClass([
+  creatableProvider()
+], JsonRpcAccountBalanceViewer);
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
-import { BlockViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import {
+  BlockViewerMoniker as BlockViewerMoniker2,
+  creatableProvider as creatableProvider2
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
 import { isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { asAnyPayload, asHashMeta } from "@xyo-network/payload-model";
+import {
+  asAnyPayload,
+  asHashMeta
+} from "@xyo-network/payload-model";
+import { BlockViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcBlockViewerMethods");
-  }
+  moniker = BlockViewerMoniker;
   async blocksByHash(hash, limit) {
-    const result = await this.transport.sendRequest("blockViewer_blocksByHash", isDefined3(limit) ? [
-      hash,
-      limit
-    ] : [
-      hash
-    ]);
+    const result = await this.transport.sendRequest(
+      "blockViewer_blocksByHash",
+      isDefined3(limit) ? [hash, limit] : [hash]
+    );
     return result;
   }
   async blocksByNumber(block, limit) {
-    const result = await this.transport.sendRequest("blockViewer_blocksByNumber", isDefined3(limit) ? [
-      block,
-      limit
-    ] : [
-      block
-    ]);
+    const result = await this.transport.sendRequest(
+      "blockViewer_blocksByNumber",
+      isDefined3(limit) ? [block, limit] : [block]
+    );
     return result;
   }
   async currentBlock() {
-    const result = await this.transport.sendRequest("blockViewer_currentBlock", []);
+    const result = await this.transport.sendRequest(
+      "blockViewer_currentBlock",
+      []
+    );
     return result;
   }
   async payloadsByHash(hashes) {
-    const result = await this.transport.sendRequest("blockViewer_payloadsByHash", [
-      hashes
-    ]);
-    return result.map((p) => asHashMeta(p, true)).map((p) => asAnyPayload(p, {
-      required: true
-    }));
+    const result = await this.transport.sendRequest(
+      "blockViewer_payloadsByHash",
+      [hashes]
+    );
+    return result.map((p) => asHashMeta(p, true)).map((p) => asAnyPayload(p, { required: true }));
   }
   schemas() {
     return BlockViewerRpcSchemas;
@@ -2092,15 +1606,7 @@ var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
 };
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
-var JsonRpcBlockViewer = class _JsonRpcBlockViewer extends JsonRpcBlockViewerMethods {
-  static {
-    __name(this, "JsonRpcBlockViewer");
-  }
-  static defaultMoniker = BlockViewerMoniker;
-  static monikers = [
-    BlockViewerMoniker
-  ];
-  moniker = _JsonRpcBlockViewer.defaultMoniker;
+var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
   async blockByHash(hash) {
     return (await this.blocksByHash(hash, 1))[0];
   }
@@ -2120,30 +1626,40 @@ var JsonRpcBlockViewer = class _JsonRpcBlockViewer extends JsonRpcBlockViewerMet
     return (await this.currentBlock())[0].block;
   }
   async payloadByHash(hash) {
-    return (await this.payloadsByHash([
-      hash
-    ]))[0] ?? null;
+    return (await this.payloadsByHash([hash]))[0] ?? null;
   }
 };
+__publicField(JsonRpcBlockViewer, "defaultMoniker", BlockViewerMoniker2);
+__publicField(JsonRpcBlockViewer, "dependencies", []);
+__publicField(JsonRpcBlockViewer, "monikers", [BlockViewerMoniker2]);
+JsonRpcBlockViewer = __decorateClass([
+  creatableProvider2()
+], JsonRpcBlockViewer);
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
-import { MempoolViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import {
+  creatableProvider as creatableProvider3,
+  MempoolViewerMoniker as MempoolViewerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewerMethods.ts
+import {
+  MempoolViewerMoniker
+} from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcMempoolViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcMempoolViewerMethods");
-  }
+  moniker = MempoolViewerMoniker;
   async pendingBlocks(options) {
-    const result = await this.transport.sendRequest("mempoolViewer_pendingBlocks", options ? [
-      options
-    ] : []);
+    const result = await this.transport.sendRequest(
+      "mempoolViewer_pendingBlocks",
+      options ? [options] : []
+    );
     return result;
   }
   async pendingTransactions(options) {
-    const result = await this.transport.sendRequest("mempoolViewer_pendingTransactions", options ? [
-      options
-    ] : []);
+    const result = await this.transport.sendRequest(
+      "mempoolViewer_pendingTransactions",
+      options ? [options] : []
+    );
     return result;
   }
   schemas() {
@@ -2152,43 +1668,32 @@ var JsonRpcMempoolViewerMethods = class extends AbstractJsonRpcViewer {
 };
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
-var JsonRpcMempoolViewer = class _JsonRpcMempoolViewer extends JsonRpcMempoolViewerMethods {
-  static {
-    __name(this, "JsonRpcMempoolViewer");
-  }
-  static defaultMoniker = MempoolViewerMoniker;
-  static monikers = [
-    MempoolViewerMoniker
-  ];
-  moniker = _JsonRpcMempoolViewer.defaultMoniker;
+var JsonRpcMempoolViewer = class extends JsonRpcMempoolViewerMethods {
 };
+__publicField(JsonRpcMempoolViewer, "defaultMoniker", MempoolViewerMoniker2);
+__publicField(JsonRpcMempoolViewer, "dependencies", []);
+__publicField(JsonRpcMempoolViewer, "monikers", [MempoolViewerMoniker2]);
+JsonRpcMempoolViewer = __decorateClass([
+  creatableProvider3()
+], JsonRpcMempoolViewer);
 
-// src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
-import { NetworkStakeViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+// src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts
+import {
+  creatableProvider as creatableProvider4,
+  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
 
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts
+// src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewerMethods.ts
 import { NetworkStakeStepRewardsViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts
-var JsonRpcNetworkStakingStepRewardsViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsViewerMethods");
-  }
+var JsonRpcNetworkStakeStepRewardsViewerMethods = class extends AbstractJsonRpcViewer {
+  moniker = NetworkStakeStepRewardsViewerMoniker;
   schemas() {
     return NetworkStakingStepRewardsViewerRpcSchemas;
   }
 };
 
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts
-var JsonRpcNetworkStakingStepRewardsViewer = class _JsonRpcNetworkStakingStepRewardsViewer extends JsonRpcNetworkStakingStepRewardsViewerMethods {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsViewer");
-  }
-  static defaultMoniker = NetworkStakeStepRewardsViewerMoniker;
-  static monikers = [
-    NetworkStakeStepRewardsViewerMoniker
-  ];
-  moniker = _JsonRpcNetworkStakingStepRewardsViewer.defaultMoniker;
+// src/provider/viewer/JsonRpcNetworkStakeStepRewardsViewer/JsonRpcNetworkStakeStepRewardsViewer.ts
+var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStakeStepRewardsViewerMethods {
   get position() {
     return this.params.position;
   }
@@ -2202,16 +1707,26 @@ var JsonRpcNetworkStakingStepRewardsViewer = class _JsonRpcNetworkStakingStepRew
     return this.params.total;
   }
 };
+__publicField(JsonRpcNetworkStakingStepRewardsViewer, "defaultMoniker", NetworkStakeStepRewardsViewerMoniker2);
+__publicField(JsonRpcNetworkStakingStepRewardsViewer, "dependencies", []);
+__publicField(JsonRpcNetworkStakingStepRewardsViewer, "monikers", [NetworkStakeStepRewardsViewerMoniker2]);
+JsonRpcNetworkStakingStepRewardsViewer = __decorateClass([
+  creatableProvider4()
+], JsonRpcNetworkStakingStepRewardsViewer);
+
+// src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
+import {
+  creatableProvider as creatableProvider5,
+  NetworkStakeStepRewardsViewerMoniker as NetworkStakeStepRewardsViewerMoniker3,
+  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
+import { NetworkStakeViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcNetworkStakeViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcNetworkStakeViewerMethods");
-  }
+  moniker = NetworkStakeViewerMoniker;
   async active(blockNumber) {
-    return await this.transport.sendRequest("networkStakeViewer_active", [
-      blockNumber
-    ]);
+    return await this.transport.sendRequest("networkStakeViewer_active", [blockNumber]);
   }
   schemas() {
     return NetworkStakeViewerRpcSchemas;
@@ -2219,63 +1734,53 @@ var JsonRpcNetworkStakeViewerMethods = class extends AbstractJsonRpcViewer {
 };
 
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
-var JsonRpcNetworkStakeViewer = class _JsonRpcNetworkStakeViewer extends JsonRpcNetworkStakeViewerMethods {
-  static {
-    __name(this, "JsonRpcNetworkStakeViewer");
-  }
-  static defaultMoniker = NetworkStakeViewerMoniker;
-  static monikers = [
-    NetworkStakeViewerMoniker
-  ];
-  moniker = _JsonRpcNetworkStakeViewer.defaultMoniker;
+var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
   _stepRewards;
   get stepRewards() {
     return this._stepRewards;
   }
   async createHandler() {
     await super.createHandler();
-    this._stepRewards = await JsonRpcNetworkStakingStepRewardsViewer.create({
-      transport: this.transport
-    });
+    this._stepRewards = await this.locator.getInstance(NetworkStakeStepRewardsViewerMoniker3);
   }
 };
+__publicField(JsonRpcNetworkStakeViewer, "defaultMoniker", NetworkStakeViewerMoniker2);
+__publicField(JsonRpcNetworkStakeViewer, "dependencies", []);
+__publicField(JsonRpcNetworkStakeViewer, "monikers", [NetworkStakeViewerMoniker2]);
+JsonRpcNetworkStakeViewer = __decorateClass([
+  creatableProvider5()
+], JsonRpcNetworkStakeViewer);
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
-import { StakeTotalsViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import {
+  creatableProvider as creatableProvider6,
+  StakeTotalsViewerMoniker as StakeTotalsViewerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts
+import { StakeTotalsViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcStakeTotalsViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcStakeTotalsViewerMethods");
-  }
+  moniker = StakeTotalsViewerMoniker;
   async active() {
     return await this.transport.sendRequest("stakeTotalsViewer_active", []);
   }
   async activeByStaked(staked) {
-    return await this.transport.sendRequest("stakeTotalsViewer_activeByStaked", [
-      staked
-    ]);
+    return await this.transport.sendRequest("stakeTotalsViewer_activeByStaked", [staked]);
   }
   async activeByStaker(address) {
-    return await this.transport.sendRequest("stakeTotalsViewer_activeByStaker", [
-      address
-    ]);
+    return await this.transport.sendRequest("stakeTotalsViewer_activeByStaker", [address]);
   }
   async pending() {
     return await this.transport.sendRequest("stakeTotalsViewer_pending", []);
   }
   async pendingByStaker(staker) {
-    return await this.transport.sendRequest("stakeTotalsViewer_pendingByStaker", [
-      staker
-    ]);
+    return await this.transport.sendRequest("stakeTotalsViewer_pendingByStaker", [staker]);
   }
   async withdrawn() {
     return await this.transport.sendRequest("stakeTotalsViewer_withdrawn", []);
   }
   async withdrawnByStaker(staker) {
-    return await this.transport.sendRequest("stakeTotalsViewer_withdrawnByStaker", [
-      staker
-    ]);
+    return await this.transport.sendRequest("stakeTotalsViewer_withdrawnByStaker", [staker]);
   }
   schemas() {
     return StakeTotalsViewerRpcSchemas;
@@ -2283,41 +1788,33 @@ var JsonRpcStakeTotalsViewerMethods = class extends AbstractJsonRpcViewer {
 };
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
-var JsonRpcStakeTotalsViewer = class _JsonRpcStakeTotalsViewer extends JsonRpcStakeTotalsViewerMethods {
-  static {
-    __name(this, "JsonRpcStakeTotalsViewer");
-  }
-  static defaultMoniker = StakeTotalsViewerMoniker;
-  static monikers = [
-    StakeTotalsViewerMoniker
-  ];
-  moniker = _JsonRpcStakeTotalsViewer.defaultMoniker;
+var JsonRpcStakeTotalsViewer = class extends JsonRpcStakeTotalsViewerMethods {
 };
+__publicField(JsonRpcStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker2);
+__publicField(JsonRpcStakeTotalsViewer, "dependencies", []);
+__publicField(JsonRpcStakeTotalsViewer, "monikers", [StakeTotalsViewerMoniker2]);
+JsonRpcStakeTotalsViewer = __decorateClass([
+  creatableProvider6()
+], JsonRpcStakeTotalsViewer);
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
-import { TimeSyncViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import {
+  creatableProvider as creatableProvider7,
+  TimeSyncViewerMoniker as TimeSyncViewerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
+import { TimeSyncViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcTimeSyncViewerMethods = class extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcTimeSyncViewerMethods");
-  }
+  moniker = TimeSyncViewerMoniker;
   async convertTime(fromDomain, toDomain, from) {
-    return await this.transport.sendRequest("timeSyncViewer_convertTime", [
-      fromDomain,
-      toDomain,
-      from
-    ]);
+    return await this.transport.sendRequest("timeSyncViewer_convertTime", [fromDomain, toDomain, from]);
   }
   async currentTime(domain) {
-    return await this.transport.sendRequest("timeSyncViewer_currentTime", [
-      domain
-    ]);
+    return await this.transport.sendRequest("timeSyncViewer_currentTime", [domain]);
   }
   async currentTimeAndHash(domain) {
-    return await this.transport.sendRequest("timeSyncViewer_currentTimeAndHash", [
-      domain
-    ]);
+    return await this.transport.sendRequest("timeSyncViewer_currentTimeAndHash", [domain]);
   }
   async currentTimePayload() {
     return await this.transport.sendRequest("timeSyncViewer_currentTimePayload", []);
@@ -2328,50 +1825,42 @@ var JsonRpcTimeSyncViewerMethods = class extends AbstractJsonRpcViewer {
 };
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
-var JsonRpcTimeSyncViewer = class _JsonRpcTimeSyncViewer extends JsonRpcTimeSyncViewerMethods {
-  static {
-    __name(this, "JsonRpcTimeSyncViewer");
-  }
-  static defaultMoniker = TimeSyncViewerMoniker;
-  static monikers = [
-    TimeSyncViewerMoniker
-  ];
-  moniker = _JsonRpcTimeSyncViewer.defaultMoniker;
+var JsonRpcTimeSyncViewer = class extends JsonRpcTimeSyncViewerMethods {
 };
+__publicField(JsonRpcTimeSyncViewer, "defaultMoniker", TimeSyncViewerMoniker2);
+__publicField(JsonRpcTimeSyncViewer, "dependencies", []);
+__publicField(JsonRpcTimeSyncViewer, "monikers", [TimeSyncViewerMoniker2]);
+JsonRpcTimeSyncViewer = __decorateClass([
+  creatableProvider7()
+], JsonRpcTimeSyncViewer);
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { isDefined as isDefined4, isHash } from "@xylabs/sdk-js";
-import { isSignedHydratedBlock, isSignedHydratedBlockWithHashMeta, toWithHashMeta } from "@xyo-network/xl1-protocol";
-import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2, BlockViewerMoniker as BlockViewerMoniker2, creatableProvider, MempoolViewerMoniker as MempoolViewerMoniker2, NetworkStakeViewerMoniker as NetworkStakeViewerMoniker2, StepViewerMoniker, TimeSyncViewerMoniker as TimeSyncViewerMoniker2, XyoViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
+import {
+  isSignedHydratedBlock,
+  isSignedHydratedBlockWithHashMeta,
+  toWithHashMeta
+} from "@xyo-network/xl1-protocol";
+import {
+  AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
+  BlockViewerMoniker as BlockViewerMoniker3,
+  creatableProvider as creatableProvider8,
+  MempoolViewerMoniker as MempoolViewerMoniker3,
+  NetworkStakeViewerMoniker as NetworkStakeViewerMoniker3,
+  StepViewerMoniker,
+  TimeSyncViewerMoniker as TimeSyncViewerMoniker3,
+  XyoViewerMoniker
+} from "@xyo-network/xl1-protocol-sdk";
 async function fixSignedHydratedBlockWithHashMeta(block) {
   if (isSignedHydratedBlockWithHashMeta(block)) {
     return block;
   }
   if (isSignedHydratedBlock(block)) {
-    return [
-      await toWithHashMeta(block[0], true),
-      await Promise.all(block[1].map((p) => toWithHashMeta(p, true)))
-    ];
+    return [block[0], await Promise.all(block[1].map((p) => toWithHashMeta(p, true)))];
   }
   throw new Error("Invalid block format");
 }
-__name(fixSignedHydratedBlockWithHashMeta, "fixSignedHydratedBlockWithHashMeta");
-var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcXyoViewer");
-  }
-  static defaultMoniker = XyoViewerMoniker;
-  static monikers = [
-    XyoViewerMoniker
-  ];
-  moniker = _JsonRpcXyoViewer.defaultMoniker;
+var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
+  moniker = JsonRpcXyoViewer.defaultMoniker;
   _chainId;
   _accountBalanceViewer;
   _blockViewer;
@@ -2380,9 +1869,7 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
   _stepViewer;
   _timeSyncViewer;
   get account() {
-    return {
-      balance: this._accountBalanceViewer
-    };
+    return { balance: this._accountBalanceViewer };
   }
   get block() {
     return this._blockViewer;
@@ -2399,23 +1886,11 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
   get time() {
     return this._timeSyncViewer;
   }
-  async accountBalance(address, headOrRange) {
-    if (isDefined4(headOrRange)) {
-      if (isHash(headOrRange)) {
-        return await this.account.balance.accountBalance(address, headOrRange);
-      }
-      return await this.account.balance.accountBalance(address);
-    }
-    return await this.account.balance.accountBalance(address, headOrRange);
+  async accountBalance(address, config = {}) {
+    return await this.account.balance.accountBalance(address, config);
   }
-  async accountBalanceHistory(address, headOrRange) {
-    if (isDefined4(headOrRange)) {
-      if (isHash(headOrRange)) {
-        return await this.account.balance.accountBalanceHistory(address, headOrRange);
-      }
-      return await this.account.balance.accountBalanceHistory(address);
-    }
-    return await this.account.balance.accountBalanceHistory(address, headOrRange);
+  async accountBalanceHistory(address, config = {}) {
+    return await this.account.balance.accountBalanceHistory(address, config);
   }
   async blockByHash(hash) {
     return (await this.blocksByHash(hash, 1))[0];
@@ -2424,16 +1899,16 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
     return (await this.blocksByNumber(blockNumber, 1))[0];
   }
   async blocksByHash(hash, limit) {
-    return await Promise.all((await this.transport.sendRequest("xyoViewer_blocksByHash", [
-      hash,
-      limit
-    ])).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    return await Promise.all((await this.transport.sendRequest(
+      "xyoViewer_blocksByHash",
+      [hash, limit]
+    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async blocksByNumber(blockNumber, limit) {
-    return await Promise.all((await this.transport.sendRequest("xyoViewer_blocksByNumber", [
-      blockNumber,
-      limit
-    ])).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    return await Promise.all((await this.transport.sendRequest(
+      "xyoViewer_blocksByNumber",
+      [blockNumber, limit]
+    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async chainId(blockNumber = "latest") {
     const block = blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber);
@@ -2444,12 +1919,12 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
   }
   async createHandler() {
     await super.createHandler();
-    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker2);
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker2);
-    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker2);
+    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker3);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
+    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker3);
     this._stepViewer = await this.locator.getInstance(StepViewerMoniker);
-    this._networkStakeViewer = await this.locator.getInstance(NetworkStakeViewerMoniker2);
-    this._timeSyncViewer = await this.locator.getInstance(TimeSyncViewerMoniker2);
+    this._networkStakeViewer = await this.locator.getInstance(NetworkStakeViewerMoniker3);
+    this._timeSyncViewer = await this.locator.getInstance(TimeSyncViewerMoniker3);
   }
   async currentBlock() {
     const result = await this.transport.sendRequest("xyoViewer_currentBlock");
@@ -2465,169 +1940,110 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
     return await this.transport.sendRequest("xyoViewer_forkHistory");
   }
   async networkStakeStepRewardAddressHistory(address) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressHistory", [
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressHistory", [address]);
   }
   async networkStakeStepRewardAddressReward(context, address) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressReward", [
-      context,
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressReward", [context, address]);
   }
   async networkStakeStepRewardAddressShare(context, address) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressShare", [
-      context,
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressShare", [context, address]);
   }
   async networkStakeStepRewardClaimedByAddress(address) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardClaimedByAddress", [
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardClaimedByAddress", [address]);
   }
   async networkStakeStepRewardForPosition(position, range) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForPosition", [
-      position,
-      range
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForPosition", [position, range]);
   }
   async networkStakeStepRewardForStep(context) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStep", [
-      context
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStep", [context]);
   }
   async networkStakeStepRewardForStepForPosition(context, position) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStepForPosition", [
-      context,
-      position
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStepForPosition", [context, position]);
   }
   async networkStakeStepRewardPoolRewards(context) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolRewards", [
-      context
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolRewards", [context]);
   }
   async networkStakeStepRewardPoolShares(context) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolShares", [
-      context
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolShares", [context]);
   }
   async networkStakeStepRewardPositionWeight(context, position) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPositionWeight", [
-      context,
-      position
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPositionWeight", [context, position]);
   }
   async networkStakeStepRewardPotentialPositionLoss(context, position) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPotentialPositionLoss", [
-      context,
-      position
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPotentialPositionLoss", [context, position]);
   }
   async networkStakeStepRewardRandomizer(context) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardRandomizer", [
-      context
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardRandomizer", [context]);
   }
   async networkStakeStepRewardStakerCount(context) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardStakerCount", [
-      context
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardStakerCount", [context]);
   }
   async networkStakeStepRewardUnclaimedByAddress(address) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardUnclaimedByAddress", [
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardUnclaimedByAddress", [address]);
   }
   async networkStakeStepRewardWeightForAddress(context, address) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardWeightForAddress", [
-      context,
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardWeightForAddress", [context, address]);
   }
   async networkStakeStepRewardsForPosition(position, range) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForPosition", [
-      position,
-      range
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForPosition", [position, range]);
   }
   async networkStakeStepRewardsForRange(range) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForRange", [
-      range
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForRange", [range]);
   }
   async networkStakeStepRewardsForStepLevel(stepLevel, range) {
-    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForStepLevel", [
-      stepLevel,
-      range
-    ]);
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForStepLevel", [stepLevel, range]);
   }
   async payloadByHash(hash) {
-    return (await this.payloadsByHash([
-      hash
-    ]))[0] ?? null;
+    return (await this.payloadsByHash([hash]))[0] ?? null;
   }
   async payloadsByHash(hashes) {
-    return await Promise.all((await this.transport.sendRequest("xyoViewer_payloadsByHash", [
-      hashes
-    ])).map((p) => toWithHashMeta(p, true)));
+    return await Promise.all((await this.transport.sendRequest(
+      "xyoViewer_payloadsByHash",
+      [hashes]
+    )).map((p) => toWithHashMeta(p, true)));
   }
   async stakeById(id) {
-    return await this.transport.sendRequest("xyoViewer_stakeById", [
-      id
-    ]);
+    return await this.transport.sendRequest("xyoViewer_stakeById", [id]);
   }
   async stakeByStaker(staker, slot) {
-    return await this.transport.sendRequest("xyoViewer_stakeByStaker", [
-      staker,
-      slot
-    ]);
+    return await this.transport.sendRequest("xyoViewer_stakeByStaker", [staker, slot]);
   }
   async stakesByStaked(staked) {
-    return await this.transport.sendRequest("xyoViewer_stakesByStaked", [
-      staked
-    ]);
+    return await this.transport.sendRequest("xyoViewer_stakesByStaked", [staked]);
   }
   async stakesByStaker(staker) {
-    return await this.transport.sendRequest("xyoViewer_stakesByStaker", [
-      staker
-    ]);
+    return await this.transport.sendRequest("xyoViewer_stakesByStaker", [staker]);
   }
   async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
-    return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [
-      blockHash,
-      transactionIndex
-    ]);
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [blockHash, transactionIndex]);
   }
   async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
-    return await this.transport.sendRequest("xyoViewer_transactionByBlockNumberAndIndex", [
-      blockNumber,
-      transactionIndex
-    ]);
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockNumberAndIndex", [blockNumber, transactionIndex]);
   }
   async transactionByHash(transactionHash) {
-    return await this.transport.sendRequest("xyoViewer_transactionByHash", [
-      transactionHash
-    ]);
+    return await this.transport.sendRequest("xyoViewer_transactionByHash", [transactionHash]);
   }
   schemas() {
     return XyoViewerRpcSchemas;
   }
 };
-JsonRpcXyoViewer = _ts_decorate([
-  creatableProvider()
+__publicField(JsonRpcXyoViewer, "defaultMoniker", XyoViewerMoniker);
+__publicField(JsonRpcXyoViewer, "dependencies", [
+  AccountBalanceViewerMoniker3,
+  BlockViewerMoniker3,
+  MempoolViewerMoniker3,
+  StepViewerMoniker,
+  TimeSyncViewerMoniker3
+]);
+__publicField(JsonRpcXyoViewer, "monikers", [XyoViewerMoniker]);
+JsonRpcXyoViewer = __decorateClass([
+  creatableProvider8()
 ], JsonRpcXyoViewer);
 
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
 var JsonRpcDataLakeViewerMethods = class _JsonRpcDataLakeViewerMethods extends AbstractJsonRpcViewer {
-  static {
-    __name(this, "JsonRpcDataLakeViewerMethods");
-  }
   static defaultMoniker = DataLakeViewerMoniker;
-  static monikers = [
-    DataLakeViewerMoniker
-  ];
+  static monikers = [DataLakeViewerMoniker];
   moniker = _JsonRpcDataLakeViewerMethods.defaultMoniker;
   get(_id) {
     throw new Error("Method [get] not implemented.");
@@ -2645,16 +2061,14 @@ var JsonRpcDataLakeViewerMethods = class _JsonRpcDataLakeViewerMethods extends A
 
 // src/provider/datalake/JsonRpcDataLakeViewer.ts
 var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
-  static {
-    __name(this, "JsonRpcDataLakeViewer");
-  }
 };
+__publicField(JsonRpcDataLakeViewer, "dependencies", []);
+JsonRpcDataLakeViewer = __decorateClass([
+  creatableProvider9()
+], JsonRpcDataLakeViewer);
 
 // src/provider/permissions/RpcXyoPermissions.ts
 var RpcXyoPermissions = class {
-  static {
-    __name(this, "RpcXyoPermissions");
-  }
   transport;
   constructor(transport) {
     this.transport = transport;
@@ -2663,9 +2077,7 @@ var RpcXyoPermissions = class {
     return await this.transport.sendRequest("xyoPermissions_getPermissions", []);
   }
   async requestPermissions(permissions) {
-    return await this.transport.sendRequest("xyoPermissions_requestPermissions", [
-      permissions
-    ]);
+    return await this.transport.sendRequest("xyoPermissions_requestPermissions", [permissions]);
   }
   async revokePermissions(_permissions) {
     await Promise.resolve();
@@ -2674,15 +2086,18 @@ var RpcXyoPermissions = class {
 };
 
 // src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-import { creatableProvider as creatableProvider2, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-sdk";
+import {
+  creatableProvider as creatableProvider10,
+  MempoolRunnerMoniker as MempoolRunnerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
+import { MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/runner/JsonRpcRunner.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
 import { AbstractCreatableProvider as AbstractCreatableProvider2 } from "@xyo-network/xl1-protocol-sdk";
 var AbstractJsonRpcRunner = class extends AbstractCreatableProvider2 {
-  static {
-    __name(this, "AbstractJsonRpcRunner");
-  }
   get transport() {
     return this.params.transport;
   }
@@ -2692,7 +2107,7 @@ var AbstractJsonRpcRunner = class extends AbstractCreatableProvider2 {
   }
   createTransport() {
     const endpoint = this.config.services.apiEndpoint;
-    if (isDefined5(endpoint)) {
+    if (isDefined4(endpoint)) {
       return new HttpRpcTransport(endpoint, this.schemas());
     }
     throw new Error("Unable to create transport");
@@ -2701,19 +2116,19 @@ var AbstractJsonRpcRunner = class extends AbstractCreatableProvider2 {
 
 // src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
 var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
-  static {
-    __name(this, "JsonRpcMempoolRunnerMethods");
-  }
+  moniker = MempoolRunnerMoniker;
   async submitBlocks(blocks) {
-    const result = await this.transport.sendRequest("mempoolRunner_submitBlocks", [
-      blocks
-    ]);
+    const result = await this.transport.sendRequest(
+      "mempoolRunner_submitBlocks",
+      [blocks]
+    );
     return result;
   }
   async submitTransactions(transactions) {
-    const result = await this.transport.sendRequest("mempoolRunner_submitTransactions", [
-      transactions
-    ]);
+    const result = await this.transport.sendRequest(
+      "mempoolRunner_submitTransactions",
+      [transactions]
+    );
     return result;
   }
   schemas() {
@@ -2722,72 +2137,48 @@ var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
 };
 
 // src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate2, "_ts_decorate");
-var JsonRpcMempoolRunner = class _JsonRpcMempoolRunner extends JsonRpcMempoolRunnerMethods {
-  static {
-    __name(this, "JsonRpcMempoolRunner");
-  }
-  static defaultMoniker = MempoolRunnerMoniker;
-  static monikers = [
-    MempoolRunnerMoniker
-  ];
-  moniker = _JsonRpcMempoolRunner.defaultMoniker;
+var JsonRpcMempoolRunner = class extends JsonRpcMempoolRunnerMethods {
 };
-JsonRpcMempoolRunner = _ts_decorate2([
-  creatableProvider2()
+__publicField(JsonRpcMempoolRunner, "defaultMoniker", MempoolRunnerMoniker2);
+__publicField(JsonRpcMempoolRunner, "dependencies", []);
+__publicField(JsonRpcMempoolRunner, "monikers", [MempoolRunnerMoniker2]);
+JsonRpcMempoolRunner = __decorateClass([
+  creatableProvider10()
 ], JsonRpcMempoolRunner);
 
 // src/provider/runner/JsonRpcXyoRunner.ts
-import { XyoRunnerMoniker } from "@xyo-network/xl1-protocol-sdk";
-var JsonRpcXyoRunner = class _JsonRpcXyoRunner extends AbstractJsonRpcRunner {
-  static {
-    __name(this, "JsonRpcXyoRunner");
-  }
-  static defaultMoniker = XyoRunnerMoniker;
-  static monikers = [
-    XyoRunnerMoniker
-  ];
-  moniker = _JsonRpcXyoRunner.defaultMoniker;
+import { creatableProvider as creatableProvider11, XyoRunnerMoniker } from "@xyo-network/xl1-protocol-sdk";
+var JsonRpcXyoRunner = class extends AbstractJsonRpcRunner {
+  moniker = JsonRpcXyoRunner.defaultMoniker;
   _mempoolRunner;
   get mempool() {
     return this._mempoolRunner;
   }
   async broadcastTransaction(transaction) {
-    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [
-      transaction
-    ]);
+    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [transaction]);
   }
   schemas() {
     return XyoRunnerRpcSchemas;
   }
 };
+__publicField(JsonRpcXyoRunner, "defaultMoniker", XyoRunnerMoniker);
+__publicField(JsonRpcXyoRunner, "dependencies", []);
+__publicField(JsonRpcXyoRunner, "monikers", [XyoRunnerMoniker]);
+JsonRpcXyoRunner = __decorateClass([
+  creatableProvider11()
+], JsonRpcXyoRunner);
 
 // src/provider/runner/NodeXyoRunner.ts
 import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
-import { AbstractCreatableProvider as AbstractCreatableProvider3, creatableProvider as creatableProvider3, SimpleMempoolRunner, XyoRunnerMoniker as XyoRunnerMoniker2 } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate3(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate3, "_ts_decorate");
-var NodeXyoRunner = class _NodeXyoRunner extends AbstractCreatableProvider3 {
-  static {
-    __name(this, "NodeXyoRunner");
-  }
-  static defaultMoniker = XyoRunnerMoniker2;
-  static monikers = [
-    XyoRunnerMoniker2
-  ];
-  moniker = _NodeXyoRunner.defaultMoniker;
+import {
+  AbstractCreatableProvider as AbstractCreatableProvider3,
+  creatableProvider as creatableProvider12,
+  SimpleMempoolRunner,
+  XyoRunnerMoniker as XyoRunnerMoniker2
+} from "@xyo-network/xl1-protocol-sdk";
+var NodeXyoRunner = class extends AbstractCreatableProvider3 {
+  moniker = NodeXyoRunner.defaultMoniker;
   _mempoolRunner;
   _pendingBlocksArchivist;
   _pendingTransactionsArchivist;
@@ -2810,19 +2201,23 @@ var NodeXyoRunner = class _NodeXyoRunner extends AbstractCreatableProvider3 {
     return this.params.pendingTransactionsArchivistPath ?? "XYOChain:Pending:Transactions";
   }
   async broadcastTransaction(transaction) {
-    const [txHash] = await this.mempool.submitTransactions([
-      transaction
-    ]);
+    const [txHash] = await this.mempool.submitTransactions([transaction]);
     return txHash;
   }
-  getArchivist = /* @__PURE__ */ __name(async (identifier) => {
+  getArchivist = async (identifier) => {
     const archivist = await this.node.resolve(identifier);
     return assertEx2(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
-  }, "getArchivist");
+  };
   async startHandler() {
     await super.startHandler();
-    this._pendingTransactionsArchivist = assertEx2(await this.getArchivist(this.pendingTransactionsArchivistPath), () => `Could not resolve pending archivist at ${this.pendingTransactionsArchivistPath}`);
-    this._pendingBlocksArchivist = assertEx2(await this.getArchivist(this.pendingBlocksArchivistPath), () => `Could not resolve pending archivist at ${this.pendingBlocksArchivistPath}`);
+    this._pendingTransactionsArchivist = assertEx2(
+      await this.getArchivist(this.pendingTransactionsArchivistPath),
+      () => `Could not resolve pending archivist at ${this.pendingTransactionsArchivistPath}`
+    );
+    this._pendingBlocksArchivist = assertEx2(
+      await this.getArchivist(this.pendingBlocksArchivistPath),
+      () => `Could not resolve pending archivist at ${this.pendingBlocksArchivistPath}`
+    );
     this._mempoolRunner = assertEx2(await SimpleMempoolRunner.create({
       context: this.context,
       pendingTransactionsArchivist: this.pendingTransactionsArchivist,
@@ -2830,15 +2225,15 @@ var NodeXyoRunner = class _NodeXyoRunner extends AbstractCreatableProvider3 {
     }), () => "Failed to create SimpleMempoolRunner");
   }
 };
-NodeXyoRunner = _ts_decorate3([
-  creatableProvider3()
+__publicField(NodeXyoRunner, "defaultMoniker", XyoRunnerMoniker2);
+__publicField(NodeXyoRunner, "dependencies", []);
+__publicField(NodeXyoRunner, "monikers", [XyoRunnerMoniker2]);
+NodeXyoRunner = __decorateClass([
+  creatableProvider12()
 ], NodeXyoRunner);
 
 // src/provider/signer/JsonRpcXyoSigner.ts
 var RpcXyoSigner = class {
-  static {
-    __name(this, "RpcXyoSigner");
-  }
   transport;
   constructor(transport) {
     this.transport = transport;
@@ -2847,9 +2242,7 @@ var RpcXyoSigner = class {
     return await this.transport.sendRequest("xyoSigner_address");
   }
   async signTransaction(tx) {
-    return await this.transport.sendRequest("xyoSigner_signTransaction", [
-      tx
-    ]);
+    return await this.transport.sendRequest("xyoSigner_signTransaction", [tx]);
   }
 };
 export {
@@ -2871,10 +2264,10 @@ export {
   JsonRpcMempoolRunnerMethods,
   JsonRpcMempoolViewer,
   JsonRpcMempoolViewerMethods,
+  JsonRpcNetworkStakeStepRewardsViewerMethods,
   JsonRpcNetworkStakeViewer,
   JsonRpcNetworkStakeViewerMethods,
   JsonRpcNetworkStakingStepRewardsViewer,
-  JsonRpcNetworkStakingStepRewardsViewerMethods,
   JsonRpcStakeTotalsViewer,
   JsonRpcStakeTotalsViewerMethods,
   JsonRpcTimeSyncViewer,