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

package/dist/neutral/index.mjs

@@ -56,6 +56,16 @@ var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
   };
 }, "rpcMethodHandlersFromRunner");
 
+// src/engine/rpcMethodHandlersFromTimeSyncViewer.ts
+var rpcMethodHandlersFromTimeSyncViewer = /* @__PURE__ */ __name((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")
+  };
+}, "rpcMethodHandlersFromTimeSyncViewer");
+
 // src/engine/rpcMethodHandlersFromViewer.ts
 var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
   return {
@@ -81,8 +91,6 @@ var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
     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_chainId: /* @__PURE__ */ __name((params) => viewer.chainId(...params ?? []), "xyoViewer_chainId"),
-    xyoViewer_chainIdAtBlock: /* @__PURE__ */ __name((params) => viewer.chainIdAtBlock(...params ?? []), "xyoViewer_chainIdAtBlock"),
     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"),
@@ -129,6 +137,13 @@ var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection) => {
       ...rpcMethodHandlersFromMempoolViewer(mempoolViewer)
     };
   }
+  const timeSyncViewer = viewer?.time;
+  if (timeSyncViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromTimeSyncViewer(timeSyncViewer)
+    };
+  }
   const mempoolRunner = runner?.mempool;
   if (mempoolRunner) {
     result = {
@@ -181,15 +196,8 @@ var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
   };
 }, "rpcMethodHandlersFromSigner");
 
-// src/transport/HttpRpcTransport.ts
-import { axiosJsonConfig } from "@xylabs/axios";
-import { isDefined, isError, isUndefinedOrNull } from "@xylabs/sdk-js";
-import { Axios, isAxiosError } from "axios";
-import { v4 } from "uuid";
-import * as z19 from "zod";
-
-// src/types/DataLakeViewerRpc.ts
-var DataLakeViewerRpcNamespace = "dataLakeViewer";
+// src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/types/ErrorCodes.ts
 var JsonRpcErrorCodes = {
@@ -372,37 +380,99 @@ var BlockViewerRpcSchemas = {
   }
 };
 
-// src/types/schema/MempoolRunnerRpcSchemas.ts
+// src/types/schema/DataLakeViewerRpcSchema.ts
 import { HashZod as HashZod3 } from "@xylabs/sdk-js";
-import { SignedHydratedBlockZod, SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
+import { PayloadZod } from "@xyo-network/payload-model";
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol";
 import * as z3 from "zod";
-var MempoolRunnerRpcSchemas = {
-  mempoolRunner_submitBlocks: {
+var DataLakeViewerRpcSchemas = {
+  dataLakeViewer_get: {
     params: {
       to: z3.tuple([
-        z3.array(SignedHydratedBlockZod)
+        HashZod3
       ]),
       from: z3.tuple([
-        z3.array(SignedHydratedBlockZod)
+        HashZod3
       ])
     },
     result: {
-      to: z3.array(HashZod3),
-      from: z3.array(HashZod3)
+      to: z3.union([
+        PayloadZod,
+        ArrayBufferToJsonZod
+      ]).optional(),
+      from: z3.union([
+        PayloadZod,
+        JsonToArrayBufferZod
+      ]).optional()
     }
   },
-  mempoolRunner_submitTransactions: {
+  dataLakeViewer_getMany: {
     params: {
       to: z3.tuple([
-        z3.array(SignedHydratedTransactionZod)
+        z3.array(HashZod3)
       ]),
       from: z3.tuple([
-        z3.array(SignedHydratedTransactionZod)
+        z3.array(HashZod3)
+      ])
+    },
+    result: {
+      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
+      ])
+    },
+    result: {
+      to: z3.boolean(),
+      from: z3.boolean()
+    }
+  }
+};
+
+// src/types/schema/MempoolRunnerRpcSchemas.ts
+import { HashZod as HashZod4 } from "@xylabs/sdk-js";
+import { SignedHydratedBlockZod, SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
+import * as z4 from "zod";
+var MempoolRunnerRpcSchemas = {
+  mempoolRunner_submitBlocks: {
+    params: {
+      to: z4.tuple([
+        z4.array(SignedHydratedBlockZod)
+      ]),
+      from: z4.tuple([
+        z4.array(SignedHydratedBlockZod)
       ])
     },
     result: {
-      to: z3.array(HashZod3),
-      from: z3.array(HashZod3)
+      to: z4.array(HashZod4),
+      from: z4.array(HashZod4)
+    }
+  },
+  mempoolRunner_submitTransactions: {
+    params: {
+      to: z4.tuple([
+        z4.array(SignedHydratedTransactionZod)
+      ]),
+      from: z4.tuple([
+        z4.array(SignedHydratedTransactionZod)
+      ])
+    },
+    result: {
+      to: z4.array(HashZod4),
+      from: z4.array(HashZod4)
     }
   }
 };
@@ -410,34 +480,34 @@ 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 z4 from "zod";
+import * as z5 from "zod";
 var MempoolViewerRpcSchemas = {
   mempoolViewer_pendingBlocks: {
     params: {
-      to: z4.tuple([
+      to: z5.tuple([
         PendingBlocksOptionsZod.optional()
       ]),
-      from: z4.tuple([
+      from: z5.tuple([
         PendingBlocksOptionsZod.optional()
       ])
     },
     result: {
-      to: z4.array(SignedHydratedBlockWithHashMetaZod2),
-      from: z4.array(SignedHydratedBlockWithHashMetaZod2)
+      to: z5.array(SignedHydratedBlockWithHashMetaZod2),
+      from: z5.array(SignedHydratedBlockWithHashMetaZod2)
     }
   },
   mempoolViewer_pendingTransactions: {
     params: {
-      to: z4.tuple([
+      to: z5.tuple([
         PendingTransactionsOptionsZod.optional()
       ]),
-      from: z4.tuple([
+      from: z5.tuple([
         PendingTransactionsOptionsZod.optional()
       ])
     },
     result: {
-      to: z4.array(SignedHydratedTransactionWithHashMetaZod),
-      from: z4.array(SignedHydratedTransactionWithHashMetaZod)
+      to: z5.array(SignedHydratedTransactionWithHashMetaZod),
+      from: z5.array(SignedHydratedTransactionWithHashMetaZod)
     }
   }
 };
@@ -445,1290 +515,1327 @@ 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 z5 from "zod";
+import * as z6 from "zod";
 var NetworkStakeViewerRpcSchemas = {
   networkStakeViewer_active: {
     params: {
-      from: z5.tuple([
+      from: z6.tuple([
         BlockNumberZod.optional()
       ]),
-      to: z5.tuple([
+      to: z6.tuple([
         BlockNumberZod.optional()
       ])
     },
     result: {
-      from: z5.tuple([
+      from: z6.tuple([
         JsonToBigIntZod2,
-        z5.number()
+        z6.number()
       ]),
-      to: z5.tuple([
+      to: z6.tuple([
         BigIntToJsonZod2,
-        z5.number()
+        z6.number()
       ])
     }
   }
 };
 
-// src/types/schema/XyoPermissionsRpcSchemas.ts
-import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol";
-import * as z6 from "zod";
-var XyoPermissionsRpcSchemas = {
-  xyoPermissions_getPermissions: {
+// 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";
+var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
+  networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      to: z6.array(z6.any()).length(0),
-      from: z6.array(z6.any()).length(0)
+      from: z7.tuple([
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z7.tuple([
+        RewardsRangeOptionsZod.optional()
+      ])
     },
     result: {
-      to: z6.array(InvokerPermissionZod),
-      from: z6.array(InvokerPermissionZod)
+      from: z7.record(z7.number(), JsonToBigIntZod3.transform((val) => asAttoXL1(val))),
+      to: z7.record(z7.number(), BigIntToJsonZod3)
     }
   },
-  xyoPermissions_requestPermissions: {
+  networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      to: z6.tuple([
-        z6.array(PermissionRequestZod)
+      from: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z6.tuple([
-        z6.array(PermissionRequestZod)
+      to: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: z6.array(RequestedPermissionZod),
-      from: z6.array(RequestedPermissionZod)
+      from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z7.record(z7.number(), JsonToBigIntZod3)
     }
   },
-  xyoPermissions_revokePermissions: {
+  networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      to: z6.tuple([
-        z6.array(PermissionRequestZod)
+      from: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z6.tuple([
-        z6.array(PermissionRequestZod)
+      to: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: z6.array(RequestedPermissionZod),
-      from: z6.array(RequestedPermissionZod)
+      from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z7.record(z7.number(), JsonToBigIntZod3)
     }
-  }
-};
-
-// src/types/schema/XyoRunnerRpcSchemas.ts
-import { HashToJsonZod, JsonToHashZod } from "@xylabs/sdk-js";
-import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-protocol";
-import * as z7 from "zod";
-var XyoRunnerRpcSchemas = {
-  xyoRunner_broadcastTransaction: {
+  },
+  networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      to: z7.tuple([
-        SignedHydratedTransactionZod2
-      ]),
       from: z7.tuple([
-        SignedHydratedTransactionZod2
+        RewardsRangeOptionsZod.optional()
+      ]),
+      to: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: HashToJsonZod,
-      from: JsonToHashZod
-    }
-  }
-};
-
-// src/types/schema/XyoSignerRpcSchemas.ts
-import { AddressZod as AddressZod2 } from "@xylabs/sdk-js";
-import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
-import { z as z8 } from "zod";
-var XyoSignerRpcSchemas = {
-  xyoSigner_address: {
-    params: {
-      to: z8.array(z8.any()).length(0).optional(),
-      from: z8.array(z8.any()).length(0).optional()
-    },
-    result: {
-      to: AddressZod2,
-      from: AddressZod2
+      from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z7.record(z7.number(), JsonToBigIntZod3)
     }
   },
-  xyoSigner_signTransaction: {
+  networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      to: z8.tuple([
-        UnsignedHydratedTransactionZod
+      from: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ]),
-      from: z8.tuple([
-        UnsignedHydratedTransactionZod
+      to: z7.tuple([
+        RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      to: SignedHydratedTransactionWithHashMetaZod2,
-      from: SignedHydratedTransactionWithHashMetaZod2
+      from: z7.record(z7.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z7.record(z7.number(), JsonToBigIntZod3)
     }
   }
 };
 
-// src/types/schema/XyoViewerRpcSchemas.ts
-import { AddressZod as AddressZod3, BigIntToJsonZod as BigIntToJsonZod3, HashZod as HashZod4, JsonToBigIntZod as JsonToBigIntZod3 } from "@xylabs/sdk-js";
-import { PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/payload-model";
-import { BlockNumberZod as BlockNumberZod2, JsonToStakeZod, SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3, SignedHydratedTransactionZod as SignedHydratedTransactionZod3, StakeToJsonZod, StepIdentityZod, XL1BlockNumberZod as XL1BlockNumberZod2, XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
-import { AccountBalanceHistoryItemZod as AccountBalanceHistoryItemZod2 } from "@xyo-network/xl1-protocol-sdk";
-import * as z9 from "zod";
-var XyoViewerRpcSchemas = {
-  xyoViewer_networkStakeStepRewardClaimedByAddress: {
+// src/types/schema/RewardsByStakerViewerRpcSchemas.ts
+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";
+var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
+  networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      to: z9.tuple([
-        AddressZod3
+      from: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      from: z9.tuple([
-        AddressZod3
+      to: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: z8.record(AddressZod2, BigIntToJsonZod4),
+      to: z8.record(AddressZod2, JsonToBigIntZod4)
     }
   },
-  xyoViewer_networkStakeStepRewardAddressReward: {
+  networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod,
-        AddressZod3
+      from: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod,
-        AddressZod3
+      to: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      to: z9.record(AddressZod3, BigIntToJsonZod3),
-      from: z9.record(AddressZod3, JsonToBigIntZod3)
+      from: z8.record(AddressZod2, BigIntToJsonZod4),
+      to: z8.record(AddressZod2, JsonToBigIntZod4)
     }
   },
-  xyoViewer_networkStakeStepRewardAddressHistory: {
+  networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      to: z9.tuple([
-        AddressZod3
+      from: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      from: z9.tuple([
-        AddressZod3
+      to: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      to: z9.record(AddressZod3, BigIntToJsonZod3),
-      from: z9.record(AddressZod3, JsonToBigIntZod3)
+      from: z8.record(AddressZod2, BigIntToJsonZod4),
+      to: z8.record(AddressZod2, JsonToBigIntZod4)
     }
   },
-  xyoViewer_networkStakeStepRewardAddressShare: {
+  networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod,
-        AddressZod3
+      from: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod,
-        AddressZod3
+      to: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      to: z9.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
-      ]),
-      from: z9.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
-      ])
+      from: z8.record(AddressZod2, BigIntToJsonZod4),
+      to: z8.record(AddressZod2, JsonToBigIntZod4)
     }
   },
-  xyoViewer_networkStakeStepRewardWeightForAddress: {
+  networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod,
-        AddressZod3
+      from: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod,
-        AddressZod3
+      to: z8.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: z8.record(AddressZod2, BigIntToJsonZod4),
+      to: z8.record(AddressZod2, JsonToBigIntZod4)
     }
-  },
-  xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
+  }
+};
+
+// src/types/schema/RewardsByStepViewerRpcSchemas.ts
+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";
+var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
+  networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      to: z9.tuple([
-        AddressZod3
-      ]),
       from: z9.tuple([
-        AddressZod3
+        RewardsRangeOptionsZod3.optional()
+      ]),
+      to: z9.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: z9.record(AddressZod3, BigIntToJsonZod5),
+      to: z9.record(AddressZod3, JsonToBigIntZod5)
     }
   },
-  xyoViewer_networkStakeStepRewardPoolRewards: {
+  networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod
-      ]),
       from: z9.tuple([
-        StepIdentityZod
+        RewardsRangeOptionsZod3.optional()
+      ]),
+      to: z9.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      to: z9.record(AddressZod3, BigIntToJsonZod3),
-      from: z9.record(AddressZod3, JsonToBigIntZod3)
+      from: z9.record(AddressZod3, BigIntToJsonZod5),
+      to: z9.record(AddressZod3, JsonToBigIntZod5)
     }
   },
-  xyoViewer_networkStakeStepRewardPositionWeight: {
+  networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod,
-        z9.number()
-      ]),
       from: z9.tuple([
-        StepIdentityZod,
-        z9.number()
+        RewardsRangeOptionsZod3.optional()
+      ]),
+      to: z9.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: z9.record(AddressZod3, BigIntToJsonZod5),
+      to: z9.record(AddressZod3, JsonToBigIntZod5)
     }
   },
-  xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
+  networkStakingStepRewardsByStepViewer_total: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod,
-        z9.number()
-      ]),
       from: z9.tuple([
-        StepIdentityZod,
-        z9.number()
+        RewardsRangeOptionsZod3.optional()
+      ]),
+      to: z9.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: z9.record(AddressZod3, BigIntToJsonZod5),
+      to: z9.record(AddressZod3, JsonToBigIntZod5)
     }
   },
-  xyoViewer_networkStakeStepRewardForStep: {
+  networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod
-      ]),
       from: z9.tuple([
-        StepIdentityZod
+        RewardsRangeOptionsZod3.optional()
+      ]),
+      to: z9.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: z9.record(AddressZod3, BigIntToJsonZod5),
+      to: z9.record(AddressZod3, JsonToBigIntZod5)
     }
-  },
-  xyoViewer_networkStakeStepRewardRandomizer: {
+  }
+};
+
+// 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";
+var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
+  networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod
+      from: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod
+      to: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
-  xyoViewer_networkStakeStepRewardStakerCount: {
+  networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod
+      from: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod
+      to: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      to: z9.number(),
-      from: z9.number()
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
-  xyoViewer_networkStakeStepRewardPoolShares: {
+  networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod
+      from: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod
+      to: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      to: z9.record(AddressZod3, BigIntToJsonZod3),
-      from: z9.record(AddressZod3, JsonToBigIntZod3)
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
-  xyoViewer_networkStakeStepRewardForStepForPosition: {
+  networkStakingStepRewardsTotalViewer_total: {
     params: {
-      to: z9.tuple([
-        StepIdentityZod,
-        z9.number()
+      from: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      from: z9.tuple([
-        StepIdentityZod,
-        z9.number()
+      to: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      to: z9.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
-      ]),
-      from: z9.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
-      ])
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
-  xyoViewer_networkStakeStepRewardForPosition: {
+  networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      to: z9.tuple([
-        z9.number(),
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
+      from: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      from: z9.tuple([
-        z9.number(),
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
+      to: z10.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      to: z9.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
-      ]),
-      from: z9.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
-      ])
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
-  },
-  xyoViewer_networkStakeStepRewardsForRange: {
+  }
+};
+
+// src/types/schema/StakeTotalsViewerRpcSchemas.ts
+import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/sdk-js";
+import * as z11 from "zod";
+var StakeTotalsViewerRpcSchemas = {
+  stakeTotalsViewer_active: {
     params: {
-      to: z9.tuple([
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
-      ]),
-      from: z9.tuple([
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
-      ])
+      to: z11.array(z11.any()).length(0).optional(),
+      from: z11.array(z11.any()).length(0).optional()
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
   },
-  xyoViewer_networkStakeStepRewardsForStepLevel: {
+  stakeTotalsViewer_activeByStaked: {
     params: {
-      to: z9.tuple([
-        z9.number(),
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
+      to: z11.tuple([
+        AddressZod4
       ]),
-      from: z9.tuple([
-        z9.number(),
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
+      from: z11.tuple([
+        AddressZod4
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
   },
-  xyoViewer_networkStakeStepRewardsForPosition: {
+  stakeTotalsViewer_activeByStaker: {
     params: {
-      to: z9.tuple([
-        z9.number(),
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
+      to: z11.tuple([
+        AddressZod4
       ]),
-      from: z9.tuple([
-        z9.number(),
-        z9.tuple([
-          z9.number(),
-          z9.number()
-        ])
+      from: z11.tuple([
+        AddressZod4
       ])
     },
     result: {
-      to: z9.record(z9.string(), z9.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
-      ])),
-      from: z9.record(z9.string(), z9.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
-      ]))
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
   },
-  xyoViewer_accountBalance: {
+  stakeTotalsViewer_pending: {
     params: {
-      to: z9.union([
-        z9.tuple([
-          AddressZod3
-        ]),
-        z9.tuple([
-          AddressZod3,
-          z9.union([
-            XL1BlockRangeZod2,
-            HashZod4
-          ])
-        ])
-      ]),
-      from: z9.union([
-        z9.tuple([
-          AddressZod3
-        ]),
-        z9.tuple([
-          AddressZod3,
-          z9.union([
-            XL1BlockRangeZod2,
-            HashZod4
-          ])
-        ])
-      ])
+      to: z11.array(z11.any()).length(0).optional(),
+      from: z11.array(z11.any()).length(0).optional()
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
   },
-  xyoViewer_accountBalanceHistory: {
+  stakeTotalsViewer_pendingByStaker: {
     params: {
-      to: z9.union([
-        z9.tuple([
-          AddressZod3
-        ]),
-        z9.tuple([
-          AddressZod3,
-          z9.union([
-            XL1BlockRangeZod2,
-            HashZod4
-          ])
-        ])
+      to: z11.tuple([
+        AddressZod4
       ]),
-      from: z9.union([
-        z9.tuple([
-          AddressZod3
-        ]),
-        z9.tuple([
-          AddressZod3,
-          z9.union([
-            XL1BlockRangeZod2,
-            HashZod4
-          ])
-        ])
+      from: z11.tuple([
+        AddressZod4
       ])
     },
     result: {
-      to: z9.array(AccountBalanceHistoryItemZod2),
-      from: z9.array(AccountBalanceHistoryItemZod2)
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
   },
-  xyoViewer_blocksByNumber: {
+  stakeTotalsViewer_withdrawn: {
     params: {
-      to: z9.tuple([
-        XL1BlockNumberZod2,
-        z9.number().optional()
-      ]),
-      from: z9.tuple([
-        XL1BlockNumberZod2,
-        z9.number().optional()
-      ])
+      to: z11.array(z11.any()).length(0).optional(),
+      from: z11.array(z11.any()).length(0).optional()
     },
     result: {
-      to: z9.array(SignedHydratedBlockWithHashMetaZod3),
-      from: z9.array(SignedHydratedBlockWithHashMetaZod3)
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
   },
-  xyoViewer_blocksByHash: {
+  stakeTotalsViewer_withdrawnByStaker: {
     params: {
-      to: z9.tuple([
-        HashZod4,
-        z9.number().optional()
+      to: z11.tuple([
+        AddressZod4
       ]),
-      from: z9.tuple([
-        HashZod4,
-        z9.number().optional()
+      from: z11.tuple([
+        AddressZod4
       ])
     },
     result: {
-      to: z9.array(SignedHydratedBlockWithHashMetaZod3),
-      from: z9.array(SignedHydratedBlockWithHashMetaZod3)
-    }
-  },
-  xyoViewer_chainId: {
-    params: {
-      to: z9.array(z9.any()).length(0).optional(),
-      from: z9.array(z9.any()).length(0).optional()
-    },
-    result: {
-      to: AddressZod3,
-      from: AddressZod3
+      to: BigIntToJsonZod7,
+      from: JsonToBigIntZod7
     }
-  },
-  xyoViewer_chainIdAtBlock: {
+  }
+};
+
+// src/types/schema/StepRewardsViewerRpcSchemas.ts
+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";
+var StepViewerRpcSchemas = {
+  randomizer: {
     params: {
-      to: z9.tuple([
-        BlockNumberZod2
+      from: z12.tuple([
+        StepIdentityZod
       ]),
-      from: z9.tuple([
-        BlockNumberZod2
+      to: z12.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: AddressZod3,
-      from: AddressZod3
+      from: BigIntToJsonZod8,
+      to: JsonToBigIntZod8
     }
   },
-  xyoViewer_currentBlock: {
+  stake: {
     params: {
-      to: z9.array(z9.any()).length(0).optional(),
-      from: z9.array(z9.any()).length(0).optional()
+      from: z12.tuple([
+        StepIdentityZod
+      ]),
+      to: z12.tuple([
+        StepIdentityZod
+      ])
     },
     result: {
-      to: SignedHydratedBlockWithHashMetaZod3,
-      from: SignedHydratedBlockWithHashMetaZod3
+      from: BigIntToJsonZod8,
+      to: JsonToBigIntZod8
     }
   },
-  xyoViewer_forkHistory: {
+  stakers: {
     params: {
-      to: z9.array(z9.any()).length(0).optional(),
-      from: z9.array(z9.any()).length(0).optional()
+      from: z12.tuple([
+        StepIdentityZod
+      ]),
+      to: z12.tuple([
+        StepIdentityZod
+      ])
     },
     result: {
-      to: z9.record(z9.number(), AddressZod3),
-      from: z9.record(z9.number(), AddressZod3)
+      from: z12.array(AddressZod5),
+      to: z12.array(AddressZod5)
     }
   },
-  xyoViewer_stakeByStaker: {
+  weight: {
     params: {
-      to: z9.tuple([
-        AddressZod3,
-        z9.number()
+      from: z12.tuple([
+        StepIdentityZod
       ]),
-      from: z9.tuple([
-        AddressZod3,
-        z9.number()
+      to: z12.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: StakeToJsonZod,
-      from: JsonToStakeZod
+      from: BigIntToJsonZod8,
+      to: JsonToBigIntZod8
     }
   },
-  xyoViewer_stakeById: {
+  positionCount: {
     params: {
-      to: z9.tuple([
-        z9.number()
+      from: z12.tuple([
+        StepIdentityZod
       ]),
-      from: z9.tuple([
-        z9.number()
+      to: z12.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: StakeToJsonZod,
-      from: JsonToStakeZod
+      from: z12.number(),
+      to: z12.number()
     }
   },
-  xyoViewer_stakesByStaker: {
+  positions: {
     params: {
-      to: z9.tuple([
-        AddressZod3
+      from: z12.tuple([
+        StepIdentityZod
       ]),
-      from: z9.tuple([
-        AddressZod3
+      to: z12.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z9.array(StakeToJsonZod),
-      from: z9.array(JsonToStakeZod)
+      from: z12.array(StakeToJsonZod),
+      to: z12.array(JsonToStakeZod)
     }
   },
-  xyoViewer_stakesByStaked: {
+  stakerCount: {
     params: {
-      to: z9.tuple([
-        AddressZod3
+      from: z12.tuple([
+        StepIdentityZod
       ]),
-      from: z9.tuple([
-        AddressZod3
+      to: z12.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z9.array(StakeToJsonZod),
-      from: z9.array(JsonToStakeZod)
+      from: z12.number(),
+      to: z12.number()
     }
-  },
-  xyoViewer_transactionByBlockHashAndIndex: {
+  }
+};
+
+// src/types/schema/TimeSyncViewerRpcSchema.ts
+import { TimeDomainZod, TimePayloadZod } from "@xyo-network/xl1-protocol";
+import * as z13 from "zod";
+var TimeSyncViewerRpcSchemas = {
+  timeSyncViewer_convertTime: {
     params: {
-      to: z9.tuple([
-        HashZod4,
-        z9.number()
+      from: z13.tuple([
+        TimeDomainZod,
+        TimeDomainZod,
+        z13.number()
       ]),
-      from: z9.tuple([
-        HashZod4,
-        z9.number()
+      to: z13.tuple([
+        TimeDomainZod,
+        TimeDomainZod,
+        z13.number()
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      from: z13.number(),
+      to: z13.number()
     }
   },
-  xyoViewer_transactionByBlockNumberAndIndex: {
+  timeSyncViewer_currentTime: {
     params: {
-      to: z9.tuple([
-        z9.number(),
-        z9.number()
+      from: z13.tuple([
+        TimeDomainZod
       ]),
-      from: z9.tuple([
-        z9.number(),
-        z9.number()
+      to: z13.tuple([
+        TimeDomainZod
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      from: z13.tuple([
+        TimeDomainZod,
+        z13.number()
+      ]),
+      to: z13.tuple([
+        TimeDomainZod,
+        z13.number()
+      ])
     }
   },
-  xyoViewer_transactionByHash: {
+  timeSyncViewer_currentTimeAndHash: {
     params: {
-      to: z9.tuple([
-        HashZod4
+      from: z13.tuple([
+        TimeDomainZod
       ]),
-      from: z9.tuple([
-        HashZod4
+      to: z13.tuple([
+        TimeDomainZod
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      from: z13.tuple([
+        z13.number(),
+        z13.nullable(z13.string())
+      ]),
+      to: z13.tuple([
+        z13.number(),
+        z13.nullable(z13.string())
+      ])
     }
   },
-  xyoViewer_payloadsByHash: {
+  timeSyncViewer_currentTimePayload: {
     params: {
-      to: z9.tuple([
-        z9.array(HashZod4)
-      ]),
-      from: z9.tuple([
-        z9.array(HashZod4)
-      ])
+      from: z13.tuple([]),
+      to: z13.tuple([])
     },
     result: {
-      to: z9.array(PayloadZodLoose2),
-      from: z9.array(PayloadZodLoose2)
+      from: TimePayloadZod,
+      to: TimePayloadZod
     }
   }
 };
 
-// src/types/schema/AllRpcSchemas.ts
-var AllRpcSchemas = {
-  ...AccountBalanceViewerRpcSchemas,
-  ...XyoRunnerRpcSchemas,
-  ...XyoSignerRpcSchemas,
-  ...XyoViewerRpcSchemas,
-  ...XyoPermissionsRpcSchemas,
-  ...NetworkStakeViewerRpcSchemas,
-  ...BlockViewerRpcSchemas,
-  ...MempoolViewerRpcSchemas,
-  ...MempoolRunnerRpcSchemas
-};
-
-// src/types/schema/createRequestSchema.ts
-import * as z10 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z10.undefined()) => z10.object({
-  id: z10.union([
-    z10.string(),
-    z10.number()
-  ]),
-  jsonrpc: z10.literal(jsonrpc),
-  method: z10.literal(methodName),
-  params: paramsSchema
-}), "createRequestSchema");
-
-// src/types/schema/createResponseSchema.ts
-import * as z11 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z11.undefined()) => z11.object({
-  id: z11.union([
-    z11.string(),
-    z11.number()
-  ]),
-  jsonrpc: z11.literal(jsonrpc),
-  result: resultSchema
-}), "createResponseSchema");
-
-// src/types/schema/DataLakeViewerRpcSchema.ts
-import { HashZod as HashZod5 } from "@xylabs/sdk-js";
-import { PayloadZod } from "@xyo-network/payload-model";
-import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol";
-import * as z12 from "zod";
-var DataLakeViewerRpcSchemas = {
-  dataLakeViewer_get: {
+// src/types/schema/XyoPermissionsRpcSchemas.ts
+import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol";
+import * as z14 from "zod";
+var XyoPermissionsRpcSchemas = {
+  xyoPermissions_getPermissions: {
     params: {
-      to: z12.tuple([
-        HashZod5
+      to: z14.array(z14.any()).length(0),
+      from: z14.array(z14.any()).length(0)
+    },
+    result: {
+      to: z14.array(InvokerPermissionZod),
+      from: z14.array(InvokerPermissionZod)
+    }
+  },
+  xyoPermissions_requestPermissions: {
+    params: {
+      to: z14.tuple([
+        z14.array(PermissionRequestZod)
       ]),
-      from: z12.tuple([
-        HashZod5
+      from: z14.tuple([
+        z14.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z12.union([
-        PayloadZod,
-        ArrayBufferToJsonZod
-      ]).optional(),
-      from: z12.union([
-        PayloadZod,
-        JsonToArrayBufferZod
-      ]).optional()
+      to: z14.array(RequestedPermissionZod),
+      from: z14.array(RequestedPermissionZod)
     }
   },
-  dataLakeViewer_getMany: {
+  xyoPermissions_revokePermissions: {
     params: {
-      to: z12.tuple([
-        z12.array(HashZod5)
+      to: z14.tuple([
+        z14.array(PermissionRequestZod)
       ]),
-      from: z12.tuple([
-        z12.array(HashZod5)
+      from: z14.tuple([
+        z14.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z12.array(z12.union([
-        PayloadZod,
-        ArrayBufferToJsonZod
-      ])),
-      from: z12.array(z12.union([
-        PayloadZod,
-        JsonToArrayBufferZod
-      ]))
+      to: z14.array(RequestedPermissionZod),
+      from: z14.array(RequestedPermissionZod)
+    }
+  }
+};
+
+// 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";
+var XyoRunnerRpcSchemas = {
+  xyoRunner_broadcastTransaction: {
+    params: {
+      to: z15.tuple([
+        SignedHydratedTransactionZod2
+      ]),
+      from: z15.tuple([
+        SignedHydratedTransactionZod2
+      ])
+    },
+    result: {
+      to: HashToJsonZod,
+      from: JsonToHashZod
+    }
+  }
+};
+
+// src/types/schema/XyoSignerRpcSchemas.ts
+import { AddressZod as AddressZod6 } from "@xylabs/sdk-js";
+import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
+import { z as z16 } from "zod";
+var XyoSignerRpcSchemas = {
+  xyoSigner_address: {
+    params: {
+      to: z16.array(z16.any()).length(0).optional(),
+      from: z16.array(z16.any()).length(0).optional()
+    },
+    result: {
+      to: AddressZod6,
+      from: AddressZod6
     }
   },
-  dataLakeViewer_has: {
+  xyoSigner_signTransaction: {
     params: {
-      to: z12.tuple([
-        HashZod5
+      to: z16.tuple([
+        UnsignedHydratedTransactionZod
       ]),
-      from: z12.tuple([
-        HashZod5
+      from: z16.tuple([
+        UnsignedHydratedTransactionZod
       ])
     },
     result: {
-      to: z12.boolean(),
-      from: z12.boolean()
+      to: SignedHydratedTransactionWithHashMetaZod2,
+      from: SignedHydratedTransactionWithHashMetaZod2
     }
   }
 };
 
-// src/types/schema/RewardsByPositionViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
-import { asAttoXL1, RewardsRangeOptionsZod } from "@xyo-network/xl1-protocol";
-import z13 from "zod";
-var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
-  networkStakingStepRewardsByPositionViewer_bonus: {
+// src/types/schema/XyoViewerRpcSchemas.ts
+import { AddressZod as AddressZod7, BigIntToJsonZod as BigIntToJsonZod9, HashZod as HashZod5, 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 { AccountBalanceHistoryItemZod as AccountBalanceHistoryItemZod2 } from "@xyo-network/xl1-protocol-sdk";
+import * as z17 from "zod";
+var XyoViewerRpcSchemas = {
+  xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      from: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z17.tuple([
+        AddressZod7
       ]),
-      to: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z17.tuple([
+        AddressZod7
       ])
     },
     result: {
-      from: z13.record(z13.number(), JsonToBigIntZod4.transform((val) => asAttoXL1(val))),
-      to: z13.record(z13.number(), BigIntToJsonZod4)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
   },
-  networkStakingStepRewardsByPositionViewer_claimed: {
+  xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      from: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z17.tuple([
+        StepIdentityZod2,
+        AddressZod7
       ]),
-      to: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z17.tuple([
+        StepIdentityZod2,
+        AddressZod7
       ])
     },
     result: {
-      from: z13.record(z13.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
-      to: z13.record(z13.number(), JsonToBigIntZod4)
+      to: z17.record(AddressZod7, BigIntToJsonZod9),
+      from: z17.record(AddressZod7, JsonToBigIntZod9)
     }
   },
-  networkStakingStepRewardsByPositionViewer_earned: {
+  xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      from: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z17.tuple([
+        AddressZod7
       ]),
-      to: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z17.tuple([
+        AddressZod7
       ])
     },
     result: {
-      from: z13.record(z13.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
-      to: z13.record(z13.number(), JsonToBigIntZod4)
+      to: z17.record(AddressZod7, BigIntToJsonZod9),
+      from: z17.record(AddressZod7, JsonToBigIntZod9)
     }
   },
-  networkStakingStepRewardsByPositionViewer_total: {
+  xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      from: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z17.tuple([
+        StepIdentityZod2,
+        AddressZod7
       ]),
-      to: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z17.tuple([
+        StepIdentityZod2,
+        AddressZod7
       ])
     },
     result: {
-      from: z13.record(z13.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
-      to: z13.record(z13.number(), JsonToBigIntZod4)
+      to: z17.tuple([
+        BigIntToJsonZod9,
+        BigIntToJsonZod9
+      ]),
+      from: z17.tuple([
+        JsonToBigIntZod9,
+        JsonToBigIntZod9
+      ])
     }
   },
-  networkStakingStepRewardsByPositionViewer_unclaimed: {
+  xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      from: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z17.tuple([
+        StepIdentityZod2,
+        AddressZod7
       ]),
-      to: z13.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z17.tuple([
+        StepIdentityZod2,
+        AddressZod7
       ])
     },
     result: {
-      from: z13.record(z13.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
-      to: z13.record(z13.number(), JsonToBigIntZod4)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
-  }
-};
-
-// src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
-import { RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol";
-import z14 from "zod";
-var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
-  networkStakingStepRewardsByStakerViewer_bonus: {
+  },
+  xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      from: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      to: z17.tuple([
+        AddressZod7
       ]),
-      to: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      from: z17.tuple([
+        AddressZod7
       ])
     },
     result: {
-      from: z14.record(AddressZod4, BigIntToJsonZod5),
-      to: z14.record(AddressZod4, JsonToBigIntZod5)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
   },
-  networkStakingStepRewardsByStakerViewer_claimed: {
+  xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      from: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      to: z17.tuple([
+        StepIdentityZod2
       ]),
-      to: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      from: z17.tuple([
+        StepIdentityZod2
       ])
     },
     result: {
-      from: z14.record(AddressZod4, BigIntToJsonZod5),
-      to: z14.record(AddressZod4, JsonToBigIntZod5)
+      to: z17.record(AddressZod7, BigIntToJsonZod9),
+      from: z17.record(AddressZod7, JsonToBigIntZod9)
     }
   },
-  networkStakingStepRewardsByStakerViewer_earned: {
+  xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      from: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      to: z17.tuple([
+        StepIdentityZod2,
+        z17.number()
       ]),
-      to: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      from: z17.tuple([
+        StepIdentityZod2,
+        z17.number()
       ])
     },
     result: {
-      from: z14.record(AddressZod4, BigIntToJsonZod5),
-      to: z14.record(AddressZod4, JsonToBigIntZod5)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
   },
-  networkStakingStepRewardsByStakerViewer_total: {
+  xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      from: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      to: z17.tuple([
+        StepIdentityZod2,
+        z17.number()
       ]),
-      to: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      from: z17.tuple([
+        StepIdentityZod2,
+        z17.number()
       ])
     },
     result: {
-      from: z14.record(AddressZod4, BigIntToJsonZod5),
-      to: z14.record(AddressZod4, JsonToBigIntZod5)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
   },
-  networkStakingStepRewardsByStakerViewer_unclaimed: {
+  xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      from: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      to: z17.tuple([
+        StepIdentityZod2
       ]),
-      to: z14.tuple([
-        RewardsRangeOptionsZod2.optional()
+      from: z17.tuple([
+        StepIdentityZod2
       ])
     },
     result: {
-      from: z14.record(AddressZod4, BigIntToJsonZod5),
-      to: z14.record(AddressZod4, JsonToBigIntZod5)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
-  }
-};
-
-// src/types/schema/RewardsByStepViewerRpcSchemas.ts
-import { AddressZod as AddressZod5, BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
-import { RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol";
-import z15 from "zod";
-var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
-  networkStakingStepRewardsByStepViewer_bonus: {
+  },
+  xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      from: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      to: z17.tuple([
+        StepIdentityZod2
       ]),
-      to: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      from: z17.tuple([
+        StepIdentityZod2
       ])
     },
     result: {
-      from: z15.record(AddressZod5, BigIntToJsonZod6),
-      to: z15.record(AddressZod5, JsonToBigIntZod6)
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
   },
-  networkStakingStepRewardsByStepViewer_claimed: {
+  xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      from: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      to: z17.tuple([
+        StepIdentityZod2
       ]),
-      to: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      from: z17.tuple([
+        StepIdentityZod2
       ])
     },
     result: {
-      from: z15.record(AddressZod5, BigIntToJsonZod6),
-      to: z15.record(AddressZod5, JsonToBigIntZod6)
+      to: z17.number(),
+      from: z17.number()
     }
   },
-  networkStakingStepRewardsByStepViewer_earned: {
+  xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      from: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      to: z17.tuple([
+        StepIdentityZod2
       ]),
-      to: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      from: z17.tuple([
+        StepIdentityZod2
       ])
     },
     result: {
-      from: z15.record(AddressZod5, BigIntToJsonZod6),
-      to: z15.record(AddressZod5, JsonToBigIntZod6)
+      to: z17.record(AddressZod7, BigIntToJsonZod9),
+      from: z17.record(AddressZod7, JsonToBigIntZod9)
     }
   },
-  networkStakingStepRewardsByStepViewer_total: {
+  xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      from: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      to: z17.tuple([
+        StepIdentityZod2,
+        z17.number()
       ]),
-      to: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      from: z17.tuple([
+        StepIdentityZod2,
+        z17.number()
       ])
     },
     result: {
-      from: z15.record(AddressZod5, BigIntToJsonZod6),
-      to: z15.record(AddressZod5, JsonToBigIntZod6)
+      to: z17.tuple([
+        BigIntToJsonZod9,
+        BigIntToJsonZod9
+      ]),
+      from: z17.tuple([
+        JsonToBigIntZod9,
+        JsonToBigIntZod9
+      ])
     }
   },
-  networkStakingStepRewardsByStepViewer_unclaimed: {
+  xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      from: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      to: z17.tuple([
+        z17.number(),
+        z17.tuple([
+          z17.number(),
+          z17.number()
+        ])
       ]),
-      to: z15.tuple([
-        RewardsRangeOptionsZod3.optional()
+      from: z17.tuple([
+        z17.number(),
+        z17.tuple([
+          z17.number(),
+          z17.number()
+        ])
       ])
     },
     result: {
-      from: z15.record(AddressZod5, BigIntToJsonZod6),
-      to: z15.record(AddressZod5, JsonToBigIntZod6)
+      to: z17.tuple([
+        BigIntToJsonZod9,
+        BigIntToJsonZod9
+      ]),
+      from: z17.tuple([
+        JsonToBigIntZod9,
+        JsonToBigIntZod9
+      ])
     }
-  }
-};
-
-// src/types/schema/RewardsTotalViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/sdk-js";
-import { asAttoXL1 as asAttoXL12, RewardsRangeOptionsZod as RewardsRangeOptionsZod4 } from "@xyo-network/xl1-protocol";
-import * as z16 from "zod";
-var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
-  networkStakingStepRewardsTotalViewer_bonus: {
+  },
+  xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      from: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      to: z17.tuple([
+        z17.tuple([
+          z17.number(),
+          z17.number()
+        ])
       ]),
-      to: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      from: z17.tuple([
+        z17.tuple([
+          z17.number(),
+          z17.number()
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
+    }
+  },
+  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()
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
+    }
+  },
+  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
+      ]))
+    }
+  },
+  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
+          ])
+        ])
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod7
+      to: BigIntToJsonZod9,
+      from: JsonToBigIntZod9
     }
   },
-  networkStakingStepRewardsTotalViewer_claimed: {
+  xyoViewer_accountBalanceHistory: {
     params: {
-      from: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      to: z17.union([
+        z17.tuple([
+          AddressZod7
+        ]),
+        z17.tuple([
+          AddressZod7,
+          z17.union([
+            XL1BlockRangeZod2,
+            HashZod5
+          ])
+        ])
       ]),
-      to: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      from: z17.union([
+        z17.tuple([
+          AddressZod7
+        ]),
+        z17.tuple([
+          AddressZod7,
+          z17.union([
+            XL1BlockRangeZod2,
+            HashZod5
+          ])
+        ])
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod7
+      to: z17.array(AccountBalanceHistoryItemZod2),
+      from: z17.array(AccountBalanceHistoryItemZod2)
     }
   },
-  networkStakingStepRewardsTotalViewer_earned: {
+  xyoViewer_blocksByNumber: {
     params: {
-      from: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      to: z17.tuple([
+        XL1BlockNumberZod2,
+        z17.number().optional()
       ]),
-      to: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      from: z17.tuple([
+        XL1BlockNumberZod2,
+        z17.number().optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod7
+      to: z17.array(SignedHydratedBlockWithHashMetaZod3),
+      from: z17.array(SignedHydratedBlockWithHashMetaZod3)
     }
   },
-  networkStakingStepRewardsTotalViewer_total: {
+  xyoViewer_blocksByHash: {
     params: {
-      from: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      to: z17.tuple([
+        HashZod5,
+        z17.number().optional()
       ]),
-      to: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
+      from: z17.tuple([
+        HashZod5,
+        z17.number().optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod7
+      to: z17.array(SignedHydratedBlockWithHashMetaZod3),
+      from: z17.array(SignedHydratedBlockWithHashMetaZod3)
     }
   },
-  networkStakingStepRewardsTotalViewer_unclaimed: {
+  xyoViewer_currentBlock: {
     params: {
-      from: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ]),
-      to: z16.tuple([
-        RewardsRangeOptionsZod4.optional()
-      ])
+      to: z17.array(z17.any()).length(0).optional(),
+      from: z17.array(z17.any()).length(0).optional()
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod7
+      to: SignedHydratedBlockWithHashMetaZod3,
+      from: SignedHydratedBlockWithHashMetaZod3
     }
-  }
-};
-
-// src/types/schema/StakeTotalsViewerRpcSchemas.ts
-import { AddressZod as AddressZod6, BigIntToJsonZod as BigIntToJsonZod8, JsonToBigIntZod as JsonToBigIntZod8 } from "@xylabs/sdk-js";
-import * as z17 from "zod";
-var StakeTotalsViewerRpcSchemas = {
-  stakeTotalsViewer_active: {
+  },
+  xyoViewer_forkHistory: {
     params: {
       to: z17.array(z17.any()).length(0).optional(),
       from: z17.array(z17.any()).length(0).optional()
     },
     result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
+      to: z17.record(z17.number(), HexZod),
+      from: z17.record(z17.number(), HexZod)
     }
   },
-  stakeTotalsViewer_activeByStaked: {
+  xyoViewer_stakeByStaker: {
     params: {
       to: z17.tuple([
-        AddressZod6
+        AddressZod7,
+        z17.number()
       ]),
       from: z17.tuple([
-        AddressZod6
+        AddressZod7,
+        z17.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
+      to: StakeToJsonZod2,
+      from: JsonToStakeZod2
     }
   },
-  stakeTotalsViewer_activeByStaker: {
+  xyoViewer_stakeById: {
     params: {
       to: z17.tuple([
-        AddressZod6
+        z17.number()
       ]),
       from: z17.tuple([
-        AddressZod6
+        z17.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
-    }
-  },
-  stakeTotalsViewer_pending: {
-    params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
-    },
-    result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
+      to: StakeToJsonZod2,
+      from: JsonToStakeZod2
     }
   },
-  stakeTotalsViewer_pendingByStaker: {
+  xyoViewer_stakesByStaker: {
     params: {
       to: z17.tuple([
-        AddressZod6
+        AddressZod7
       ]),
       from: z17.tuple([
-        AddressZod6
+        AddressZod7
       ])
     },
     result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
-    }
-  },
-  stakeTotalsViewer_withdrawn: {
-    params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
-    },
-    result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
+      to: z17.array(StakeToJsonZod2),
+      from: z17.array(JsonToStakeZod2)
     }
   },
-  stakeTotalsViewer_withdrawnByStaker: {
+  xyoViewer_stakesByStaked: {
     params: {
       to: z17.tuple([
-        AddressZod6
+        AddressZod7
       ]),
       from: z17.tuple([
-        AddressZod6
+        AddressZod7
       ])
     },
     result: {
-      to: BigIntToJsonZod8,
-      from: JsonToBigIntZod8
+      to: z17.array(StakeToJsonZod2),
+      from: z17.array(JsonToStakeZod2)
     }
-  }
-};
-
-// src/types/schema/StepRewardsViewerRpcSchemas.ts
-var NetworkStakingStepRewardsViewerRpcSchemas = {};
-
-// src/types/schema/TimeSyncViewerRpcSchema.ts
-import { TimeDomainZod, TimePayloadZod } from "@xyo-network/xl1-protocol";
-import * as z18 from "zod";
-var TimeSyncViewerRpcSchemas = {
-  timeSyncViewer_convertTime: {
+  },
+  xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      from: z18.tuple([
-        TimeDomainZod,
-        TimeDomainZod,
-        z18.number()
+      to: z17.tuple([
+        HashZod5,
+        z17.number()
       ]),
-      to: z18.tuple([
-        TimeDomainZod,
-        TimeDomainZod,
-        z18.number()
+      from: z17.tuple([
+        HashZod5,
+        z17.number()
       ])
     },
     result: {
-      from: z18.number(),
-      to: z18.number()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
-  timeSyncViewer_currentTime: {
+  xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      from: z18.tuple([
-        TimeDomainZod
+      to: z17.tuple([
+        z17.number(),
+        z17.number()
       ]),
-      to: z18.tuple([
-        TimeDomainZod
+      from: z17.tuple([
+        z17.number(),
+        z17.number()
       ])
     },
     result: {
-      from: z18.tuple([
-        TimeDomainZod,
-        z18.number()
-      ]),
-      to: z18.tuple([
-        TimeDomainZod,
-        z18.number()
-      ])
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
-  timeSyncViewer_currentTimeAndHash: {
+  xyoViewer_transactionByHash: {
     params: {
-      from: z18.tuple([
-        TimeDomainZod
+      to: z17.tuple([
+        HashZod5
       ]),
-      to: z18.tuple([
-        TimeDomainZod
+      from: z17.tuple([
+        HashZod5
       ])
     },
     result: {
-      from: z18.tuple([
-        z18.number(),
-        z18.nullable(z18.string())
-      ]),
-      to: z18.tuple([
-        z18.number(),
-        z18.nullable(z18.string())
-      ])
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
-  timeSyncViewer_currentTimePayload: {
+  xyoViewer_payloadsByHash: {
     params: {
-      from: z18.tuple([]),
-      to: z18.tuple([])
+      to: z17.tuple([
+        z17.array(HashZod5)
+      ]),
+      from: z17.tuple([
+        z17.array(HashZod5)
+      ])
     },
     result: {
-      from: TimePayloadZod,
-      to: TimePayloadZod
+      to: z17.array(PayloadZodLoose2),
+      from: z17.array(PayloadZodLoose2)
     }
   }
 };
 
-// src/types/TimeSyncViewerRpc.ts
-var TimeSyncViewerRpcNamespace = "timeSyncViewer";
+// src/types/schema/AllRpcSchemas.ts
+var AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
+  ...XyoRunnerRpcSchemas,
+  ...XyoSignerRpcSchemas,
+  ...XyoViewerRpcSchemas,
+  ...XyoPermissionsRpcSchemas,
+  ...NetworkStakeViewerRpcSchemas,
+  ...BlockViewerRpcSchemas,
+  ...MempoolViewerRpcSchemas,
+  ...MempoolRunnerRpcSchemas,
+  ...TimeSyncViewerRpcSchemas,
+  ...StepViewerRpcSchemas,
+  ...DataLakeViewerRpcSchemas,
+  ...StakeTotalsViewerRpcSchemas,
+  ...NetworkStakingStepRewardsViewerRpcSchemas,
+  ...NetworkStakingStepRewardsTotalViewerRpcSchemas,
+  ...NetworkStakingStepRewardsByStepViewerRpcSchemas,
+  ...NetworkStakingStepRewardsByStakerViewerRpcSchemas,
+  ...NetworkStakingStepRewardsByPositionViewerRpcSchemas
+};
+
+// 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()
+  ]),
+  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()
+  ]),
+  jsonrpc: z19.literal(jsonrpc),
+  result: resultSchema
+}), "createResponseSchema");
+
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/viewer/JsonRpcViewer.ts
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+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 { Axios, isAxiosError } from "axios";
+import { v4 } from "uuid";
+import * as z20 from "zod";
 var HttpRpcTransport = class {
   static {
     __name(this, "HttpRpcTransport");
@@ -1754,7 +1861,7 @@ var HttpRpcTransport = class {
       };
       const schema = schemas[method];
       if (params) {
-        body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z19.json().parse(params) : void 0;
+        body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z20.json().parse(params) : void 0;
         if (!isDefined(body.params)) {
           throw new Error(`[callRpc] RPC method ${String(method)} missing schema`);
         }
@@ -1799,145 +1906,50 @@ var MemoryRpcTransport = class {
       requestSchema = createRequestSchema(stringMethod, schema.params.to);
       this.requestSchemas[method] = requestSchema;
     }
-    const req = {
-      jsonrpc,
-      id: v42(),
-      method,
-      params
-    };
-    const request = requestSchema.parse(req);
-    const response = await this._rpcEngine.handle(request);
-    let responseSchema = this.responseSchemas[method];
-    if (!isObject(responseSchema)) {
-      responseSchema = createResponseSchema(schema.result.from);
-      this.responseSchemas[method] = responseSchema;
-    }
-    return responseSchema.parse(response)?.result;
-  }
-};
-
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
-var JsonRpcMempoolRunnerMethods = class {
-  static {
-    __name(this, "JsonRpcMempoolRunnerMethods");
-  }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
-  async 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
-    ]);
-    return result;
-  }
-};
-
-// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
-var JsonRpcMempoolRunner = class extends JsonRpcMempoolRunnerMethods {
-  static {
-    __name(this, "JsonRpcMempoolRunner");
-  }
-  constructor(transport) {
-    super(transport);
-  }
-};
-
-// src/provider/runner/JsonRpcXyoRunner.ts
-var JsonRpcXyoRunner = class {
-  static {
-    __name(this, "JsonRpcXyoRunner");
-  }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
-  async broadcastTransaction(transaction) {
-    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [
-      transaction
-    ]);
-  }
-};
-
-// src/provider/runner/NodeXyoRunner.ts
-import { AbstractCreatable, assertEx as assertEx2, creatable } from "@xylabs/sdk-js";
-import { asArchivistInstance } from "@xyo-network/archivist-model";
-import { SimpleMempoolRunner } 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");
-var NodeXyoRunner = class extends AbstractCreatable {
-  static {
-    __name(this, "NodeXyoRunner");
-  }
-  // TODO: Make configurable with defaults
-  _mempoolRunner;
-  _pendingBlocksArchivist;
-  _pendingTransactionsArchivist;
-  get mempool() {
-    return this._mempoolRunner;
-  }
-  get node() {
-    return this.params.node;
-  }
-  get pendingBlocksArchivist() {
-    return this._pendingBlocksArchivist;
-  }
-  get pendingBlocksArchivistPath() {
-    return this.params.pendingBlocksArchivistPath ?? "XYOChain:Pending:Blocks";
+    const req = {
+      jsonrpc,
+      id: v42(),
+      method,
+      params
+    };
+    const request = requestSchema.parse(req);
+    const response = await this._rpcEngine.handle(request);
+    let responseSchema = this.responseSchemas[method];
+    if (!isObject(responseSchema)) {
+      responseSchema = createResponseSchema(schema.result.from);
+      this.responseSchemas[method] = responseSchema;
+    }
+    return responseSchema.parse(response)?.result;
   }
-  get pendingTransactionsArchivist() {
-    return this._pendingTransactionsArchivist;
+};
+
+// src/provider/viewer/JsonRpcViewer.ts
+var AbstractJsonRpcViewer = class extends AbstractCreatableProvider {
+  static {
+    __name(this, "AbstractJsonRpcViewer");
   }
-  get pendingTransactionsArchivistPath() {
-    return this.params.pendingTransactionsArchivistPath ?? "XYOChain:Pending:Transactions";
+  _transport;
+  get transport() {
+    return this.params.transport;
   }
-  async broadcastTransaction(transaction) {
-    const [txHash] = await this.mempool.submitTransactions([
-      transaction
-    ]);
-    return txHash;
+  async createHandler() {
+    this.params.transport ??= this.createTransport();
+    await super.createHandler();
   }
-  getArchivist = /* @__PURE__ */ __name(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._mempoolRunner = assertEx2(await SimpleMempoolRunner.create({
-      pendingTransactionsArchivist: this.pendingTransactionsArchivist,
-      pendingBlocksArchivist: this.pendingBlocksArchivist
-    }), () => "Failed to create SimpleMempoolRunner");
+  createTransport() {
+    const endpoint = this.config.services.apiEndpoint;
+    if (isDefined2(endpoint)) {
+      return new HttpRpcTransport(endpoint, this.schemas());
+    }
+    throw new Error("Unable to create transport");
   }
 };
-NodeXyoRunner = _ts_decorate([
-  creatable()
-], NodeXyoRunner);
-
-// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
-import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
-var JsonRpcAccountBalanceViewerMethods = class {
+var JsonRpcAccountBalanceViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcAccountBalanceViewerMethods");
   }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
   async qualifiedAccountBalanceHistories(addresses, headOrRange) {
     return await this.transport.sendRequest("accountBalanceViewer_qualifiedAccountBalanceHistories", headOrRange ? [
       addresses,
@@ -1954,6 +1966,9 @@ var JsonRpcAccountBalanceViewerMethods = class {
       addresses
     ]);
   }
+  schemas() {
+    return AccountBalanceViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
@@ -1966,9 +1981,6 @@ var JsonRpcAccountBalanceViewer = class _JsonRpcAccountBalanceViewer extends Jso
     AccountBalanceViewerMoniker
   ];
   moniker = _JsonRpcAccountBalanceViewer.defaultMoniker;
-  constructor(transport) {
-    super(transport);
-  }
   async accountBalance(address, headOrRange) {
     const result = await this.accountBalances([
       address
@@ -1995,18 +2007,14 @@ var JsonRpcAccountBalanceViewer = class _JsonRpcAccountBalanceViewer extends Jso
 import { BlockViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { asAnyPayload, asHashMeta } from "@xyo-network/payload-model";
-var JsonRpcBlockViewerMethods = class {
+var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcBlockViewerMethods");
   }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
   async blocksByHash(hash, limit) {
-    const result = await this.transport.sendRequest("blockViewer_blocksByHash", isDefined2(limit) ? [
+    const result = await this.transport.sendRequest("blockViewer_blocksByHash", isDefined3(limit) ? [
       hash,
       limit
     ] : [
@@ -2015,7 +2023,7 @@ var JsonRpcBlockViewerMethods = class {
     return result;
   }
   async blocksByNumber(block, limit) {
-    const result = await this.transport.sendRequest("blockViewer_blocksByNumber", isDefined2(limit) ? [
+    const result = await this.transport.sendRequest("blockViewer_blocksByNumber", isDefined3(limit) ? [
       block,
       limit
     ] : [
@@ -2035,6 +2043,9 @@ var JsonRpcBlockViewerMethods = class {
       required: true
     }));
   }
+  schemas() {
+    return BlockViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewer.ts
@@ -2047,15 +2058,18 @@ var JsonRpcBlockViewer = class _JsonRpcBlockViewer extends JsonRpcBlockViewerMet
     BlockViewerMoniker
   ];
   moniker = _JsonRpcBlockViewer.defaultMoniker;
-  constructor(transport) {
-    super(transport);
-  }
   async blockByHash(hash) {
     return (await this.blocksByHash(hash, 1))[0];
   }
   async blockByNumber(block) {
     return (await this.blocksByNumber(block, 1))[0];
   }
+  async chainId(blockNumber = "latest") {
+    if (blockNumber === "latest") {
+      return (await this.currentBlock())[0].chain;
+    }
+    return (await this.blocksByNumber(blockNumber, 1))[0][0].chain;
+  }
   async currentBlockHash() {
     return (await this.currentBlock())[0]._hash;
   }
@@ -2073,14 +2087,10 @@ var JsonRpcBlockViewer = class _JsonRpcBlockViewer extends JsonRpcBlockViewerMet
 import { MempoolViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewerMethods.ts
-var JsonRpcMempoolViewerMethods = class {
+var JsonRpcMempoolViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcMempoolViewerMethods");
   }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
   async pendingBlocks(options) {
     const result = await this.transport.sendRequest("mempoolViewer_pendingBlocks", options ? [
       options
@@ -2093,6 +2103,9 @@ var JsonRpcMempoolViewerMethods = class {
     ] : []);
     return result;
   }
+  schemas() {
+    return MempoolViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcMempoolViewer/JsonRpcMempoolViewer.ts
@@ -2105,9 +2118,6 @@ var JsonRpcMempoolViewer = class _JsonRpcMempoolViewer extends JsonRpcMempoolVie
     MempoolViewerMoniker
   ];
   moniker = _JsonRpcMempoolViewer.defaultMoniker;
-  constructor(transport) {
-    super(transport);
-  }
 };
 
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
@@ -2116,22 +2126,14 @@ import { NetworkStakeViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 // src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts
 import { NetworkStakeStepRewardsViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
-// src/provider/viewer/JsonRpcViewer.ts
-var JsonRpcViewer = class {
-  static {
-    __name(this, "JsonRpcViewer");
-  }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
-};
-
 // src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts
-var JsonRpcNetworkStakingStepRewardsViewerMethods = class extends JsonRpcViewer {
+var JsonRpcNetworkStakingStepRewardsViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcNetworkStakingStepRewardsViewerMethods");
   }
+  schemas() {
+    return NetworkStakingStepRewardsViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewer.ts
@@ -2144,27 +2146,22 @@ var JsonRpcNetworkStakingStepRewardsViewer = class _JsonRpcNetworkStakingStepRew
     NetworkStakeStepRewardsViewerMoniker
   ];
   moniker = _JsonRpcNetworkStakingStepRewardsViewer.defaultMoniker;
-  providers;
-  constructor(transport, providers) {
-    super(transport);
-    this.providers = providers ?? {};
-  }
   get position() {
-    return this.providers.position;
+    return this.params.position;
   }
   get staker() {
-    return this.providers.staker;
+    return this.params.staker;
   }
   get step() {
-    return this.providers.step;
+    return this.params.step;
   }
   get total() {
-    return this.providers.total;
+    return this.params.total;
   }
 };
 
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewerMethods.ts
-var JsonRpcNetworkStakeViewerMethods = class extends JsonRpcViewer {
+var JsonRpcNetworkStakeViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcNetworkStakeViewerMethods");
   }
@@ -2173,6 +2170,9 @@ var JsonRpcNetworkStakeViewerMethods = class extends JsonRpcViewer {
       blockNumber
     ]);
   }
+  schemas() {
+    return NetworkStakeViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcNetworkStakeViewer/JsonRpcNetworkStakeViewer.ts
@@ -2186,27 +2186,25 @@ var JsonRpcNetworkStakeViewer = class _JsonRpcNetworkStakeViewer extends JsonRpc
   ];
   moniker = _JsonRpcNetworkStakeViewer.defaultMoniker;
   _stepRewards;
-  constructor(transport) {
-    super(transport);
-    this._stepRewards = new JsonRpcNetworkStakingStepRewardsViewer(transport);
-  }
   get stepRewards() {
     return this._stepRewards;
   }
+  async createHandler() {
+    await super.createHandler();
+    this._stepRewards = await JsonRpcNetworkStakingStepRewardsViewer.create({
+      transport: this.transport
+    });
+  }
 };
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
 import { StakeTotalsViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewerMethods.ts
-var JsonRpcStakeTotalsViewerMethods = class {
+var JsonRpcStakeTotalsViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcStakeTotalsViewerMethods");
   }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
   async active() {
     return await this.transport.sendRequest("stakeTotalsViewer_active", []);
   }
@@ -2236,6 +2234,9 @@ var JsonRpcStakeTotalsViewerMethods = class {
       staker
     ]);
   }
+  schemas() {
+    return StakeTotalsViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcStakeTotalsViewer/JsonRpcStakeTotalsViewer.ts
@@ -2248,23 +2249,16 @@ var JsonRpcStakeTotalsViewer = class _JsonRpcStakeTotalsViewer extends JsonRpcSt
     StakeTotalsViewerMoniker
   ];
   moniker = _JsonRpcStakeTotalsViewer.defaultMoniker;
-  constructor(transport) {
-    super(transport);
-  }
 };
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
 import { TimeSyncViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
-var JsonRpcTimeSyncViewerMethods = class {
+var JsonRpcTimeSyncViewerMethods = class extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcTimeSyncViewerMethods");
   }
-  transport;
-  constructor(transport) {
-    this.transport = transport;
-  }
   async convertTime(fromDomain, toDomain, from) {
     return await this.transport.sendRequest("timeSyncViewer_convertTime", [
       fromDomain,
@@ -2285,6 +2279,9 @@ var JsonRpcTimeSyncViewerMethods = class {
   async currentTimePayload() {
     return await this.transport.sendRequest("timeSyncViewer_currentTimePayload", []);
   }
+  schemas() {
+    return TimeSyncViewerRpcSchemas;
+  }
 };
 
 // src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
@@ -2297,15 +2294,19 @@ var JsonRpcTimeSyncViewer = class _JsonRpcTimeSyncViewer extends JsonRpcTimeSync
     TimeSyncViewerMoniker
   ];
   moniker = _JsonRpcTimeSyncViewer.defaultMoniker;
-  constructor(transport) {
-    super(transport);
-  }
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { isDefined as isDefined3, isHash } from "@xylabs/sdk-js";
+import { isDefined as isDefined4, isHash } from "@xylabs/sdk-js";
 import { isSignedHydratedBlock, isSignedHydratedBlockWithHashMeta, toWithHashMeta } from "@xyo-network/xl1-protocol";
-import { XyoViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
+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");
 async function fixSignedHydratedBlockWithHashMeta(block) {
   if (isSignedHydratedBlockWithHashMeta(block)) {
     return block;
@@ -2319,7 +2320,7 @@ async function fixSignedHydratedBlockWithHashMeta(block) {
   throw new Error("Invalid block format");
 }
 __name(fixSignedHydratedBlockWithHashMeta, "fixSignedHydratedBlockWithHashMeta");
-var JsonRpcXyoViewer = class _JsonRpcXyoViewer {
+var JsonRpcXyoViewer = class _JsonRpcXyoViewer extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcXyoViewer");
   }
@@ -2328,48 +2329,50 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer {
     XyoViewerMoniker
   ];
   moniker = _JsonRpcXyoViewer.defaultMoniker;
-  providers;
-  transport;
-  constructor(transport, providers) {
-    this.transport = transport;
-    this.providers = providers;
+  _chainId;
+  _accountBalanceViewer;
+  _blockViewer;
+  _mempoolViewer;
+  _networkStakeViewer;
+  _stepViewer;
+  _timeSyncViewer;
+  get account() {
+    return {
+      balance: this._accountBalanceViewer
+    };
+  }
+  get block() {
+    return this._blockViewer;
+  }
+  get mempool() {
+    return this._mempoolViewer;
+  }
+  get networkStake() {
+    return this._networkStakeViewer;
   }
-  get networkStakeViewer() {
-    return this.providers?.networkStakeViewer;
+  get step() {
+    return this._stepViewer;
+  }
+  get time() {
+    return this._timeSyncViewer;
   }
   async accountBalance(address, headOrRange) {
-    if (isDefined3(headOrRange)) {
+    if (isDefined4(headOrRange)) {
       if (isHash(headOrRange)) {
-        return await this.transport.sendRequest("xyoViewer_accountBalance", [
-          address,
-          headOrRange
-        ]);
+        return await this.account.balance.accountBalance(address, headOrRange);
       }
-      return await this.transport.sendRequest("xyoViewer_accountBalance", [
-        address,
-        headOrRange
-      ]);
+      return await this.account.balance.accountBalance(address);
     }
-    return await this.transport.sendRequest("xyoViewer_accountBalance", [
-      address
-    ]);
+    return await this.account.balance.accountBalance(address, headOrRange);
   }
   async accountBalanceHistory(address, headOrRange) {
-    if (isDefined3(headOrRange)) {
+    if (isDefined4(headOrRange)) {
       if (isHash(headOrRange)) {
-        return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
-          address,
-          headOrRange
-        ]);
+        return await this.account.balance.accountBalanceHistory(address, headOrRange);
       }
-      return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
-        address,
-        headOrRange
-      ]);
+      return await this.account.balance.accountBalanceHistory(address);
     }
-    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
-      address
-    ]);
+    return await this.account.balance.accountBalanceHistory(address, headOrRange);
   }
   async blockByHash(hash) {
     return (await this.blocksByHash(hash, 1))[0];
@@ -2389,13 +2392,21 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer {
       limit
     ])).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
-  async chainId() {
-    return await this.transport.sendRequest("xyoViewer_chainId");
+  async chainId(blockNumber = "latest") {
+    const block = blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber);
+    if (!block) {
+      throw new Error(`Block not found: ${blockNumber}`);
+    }
+    return block[0].chain;
   }
-  async chainIdAtBlock(blockNumber) {
-    return await this.transport.sendRequest("xyoViewer_chainIdAtBlock", [
-      blockNumber
-    ]);
+  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._stepViewer = await this.locator.getInstance(StepViewerMoniker);
+    this._networkStakeViewer = await this.locator.getInstance(NetworkStakeViewerMoniker2);
+    this._timeSyncViewer = await this.locator.getInstance(TimeSyncViewerMoniker2);
   }
   async currentBlock() {
     const result = await this.transport.sendRequest("xyoViewer_currentBlock");
@@ -2557,68 +2568,24 @@ var JsonRpcXyoViewer = class _JsonRpcXyoViewer {
       transactionHash
     ]);
   }
-};
-
-// src/provider/connection/XyoBaseConnection.ts
-var XyoBaseConnection = class {
-  static {
-    __name(this, "XyoBaseConnection");
-  }
-  _network;
-  _runner;
-  _storage;
-  _viewer;
-  constructor(params) {
-    this._network = params?.network;
-    this._runner = params?.runner;
-    this._storage = params?.storage;
-    this._viewer = params?.viewer;
-  }
-  get network() {
-    return this._network;
-  }
-  get runner() {
-    return this._runner;
-  }
-  get storage() {
-    return this._storage;
-  }
-  get viewer() {
-    return this._viewer;
-  }
-};
-
-// src/provider/connection/HttpRpcXyoConnection.ts
-var HttpRpcXyoConnection = class extends XyoBaseConnection {
-  static {
-    __name(this, "HttpRpcXyoConnection");
-  }
-  constructor(params) {
-    const { endpoint, storage: storageParam } = params;
-    const transport = new HttpRpcTransport(endpoint, {
-      ...XyoRunnerRpcSchemas,
-      ...XyoViewerRpcSchemas,
-      ...NetworkStakeViewerRpcSchemas
-    });
-    const runner = new JsonRpcXyoRunner(transport);
-    const networkStakeViewer = new JsonRpcNetworkStakeViewer(transport);
-    const viewer = new JsonRpcXyoViewer(transport, {
-      networkStakeViewer
-    });
-    const storage = storageParam;
-    super({
-      runner,
-      viewer,
-      storage
-    });
+  schemas() {
+    return XyoViewerRpcSchemas;
   }
 };
+JsonRpcXyoViewer = _ts_decorate([
+  creatableProvider()
+], JsonRpcXyoViewer);
 
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
-var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
+var JsonRpcDataLakeViewerMethods = class _JsonRpcDataLakeViewerMethods extends AbstractJsonRpcViewer {
   static {
     __name(this, "JsonRpcDataLakeViewerMethods");
   }
+  static defaultMoniker = DataLakeViewerMoniker;
+  static monikers = [
+    DataLakeViewerMoniker
+  ];
+  moniker = _JsonRpcDataLakeViewerMethods.defaultMoniker;
   get(_id) {
     throw new Error("Method [get] not implemented.");
   }
@@ -2628,6 +2595,9 @@ var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
   has(_id) {
     throw new Error("Method [has] not implemented.");
   }
+  schemas() {
+    return DataLakeViewerRpcSchemas;
+  }
 };
 
 // src/provider/datalake/JsonRpcDataLakeViewer.ts
@@ -2635,9 +2605,6 @@ var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
   static {
     __name(this, "JsonRpcDataLakeViewer");
   }
-  constructor(transport) {
-    super(transport);
-  }
 };
 
 // src/provider/permissions/RpcXyoPermissions.ts
@@ -2663,6 +2630,167 @@ var RpcXyoPermissions = class {
   }
 };
 
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts
+import { creatableProvider as creatableProvider2, MempoolRunnerMoniker } from "@xyo-network/xl1-protocol-sdk";
+
+// src/provider/runner/JsonRpcRunner.ts
+import { isDefined as isDefined5 } 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;
+  }
+  async createHandler() {
+    this.params.transport ??= this.createTransport();
+    await super.createHandler();
+  }
+  createTransport() {
+    const endpoint = this.config.services.apiEndpoint;
+    if (isDefined5(endpoint)) {
+      return new HttpRpcTransport(endpoint, this.schemas());
+    }
+    throw new Error("Unable to create transport");
+  }
+};
+
+// src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
+var JsonRpcMempoolRunnerMethods = class extends AbstractJsonRpcRunner {
+  static {
+    __name(this, "JsonRpcMempoolRunnerMethods");
+  }
+  async 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
+    ]);
+    return result;
+  }
+  schemas() {
+    return MempoolRunnerRpcSchemas;
+  }
+};
+
+// 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;
+};
+JsonRpcMempoolRunner = _ts_decorate2([
+  creatableProvider2()
+], 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;
+  _mempoolRunner;
+  get mempool() {
+    return this._mempoolRunner;
+  }
+  async broadcastTransaction(transaction) {
+    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [
+      transaction
+    ]);
+  }
+  schemas() {
+    return XyoRunnerRpcSchemas;
+  }
+};
+
+// 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;
+  _mempoolRunner;
+  _pendingBlocksArchivist;
+  _pendingTransactionsArchivist;
+  get mempool() {
+    return this._mempoolRunner;
+  }
+  get node() {
+    return this.params.node;
+  }
+  get pendingBlocksArchivist() {
+    return this._pendingBlocksArchivist;
+  }
+  get pendingBlocksArchivistPath() {
+    return this.params.pendingBlocksArchivistPath ?? "XYOChain:Pending:Blocks";
+  }
+  get pendingTransactionsArchivist() {
+    return this._pendingTransactionsArchivist;
+  }
+  get pendingTransactionsArchivistPath() {
+    return this.params.pendingTransactionsArchivistPath ?? "XYOChain:Pending:Transactions";
+  }
+  async broadcastTransaction(transaction) {
+    const [txHash] = await this.mempool.submitTransactions([
+      transaction
+    ]);
+    return txHash;
+  }
+  getArchivist = /* @__PURE__ */ __name(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._mempoolRunner = assertEx2(await SimpleMempoolRunner.create({
+      context: this.context,
+      pendingTransactionsArchivist: this.pendingTransactionsArchivist,
+      pendingBlocksArchivist: this.pendingBlocksArchivist
+    }), () => "Failed to create SimpleMempoolRunner");
+  }
+};
+NodeXyoRunner = _ts_decorate3([
+  creatableProvider3()
+], NodeXyoRunner);
+
 // src/provider/signer/JsonRpcXyoSigner.ts
 var RpcXyoSigner = class {
   static {
@@ -2682,13 +2810,13 @@ var RpcXyoSigner = class {
   }
 };
 export {
+  AbstractJsonRpcRunner,
+  AbstractJsonRpcViewer,
   AccountBalanceViewerRpcSchemas,
   AllRpcSchemas,
   BlockViewerRpcSchemas,
-  DataLakeViewerRpcNamespace,
   DataLakeViewerRpcSchemas,
   HttpRpcTransport,
-  HttpRpcXyoConnection,
   JsonRpcAccountBalanceViewer,
   JsonRpcAccountBalanceViewerMethods,
   JsonRpcBlockViewer,
@@ -2708,7 +2836,6 @@ export {
   JsonRpcStakeTotalsViewerMethods,
   JsonRpcTimeSyncViewer,
   JsonRpcTimeSyncViewerMethods,
-  JsonRpcViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
   MemoryRpcTransport,
@@ -2730,9 +2857,7 @@ export {
   RpcXyoPermissions,
   RpcXyoSigner,
   StakeTotalsViewerRpcSchemas,
-  TimeSyncViewerRpcNamespace,
   TimeSyncViewerRpcSchemas,
-  XyoBaseConnection,
   XyoPermissionsRpcSchemas,
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
@@ -2752,6 +2877,7 @@ export {
   rpcMethodHandlersFromPermissions,
   rpcMethodHandlersFromRunner,
   rpcMethodHandlersFromSigner,
+  rpcMethodHandlersFromTimeSyncViewer,
   rpcMethodHandlersFromViewer
 };
 //# sourceMappingURL=index.mjs.map