@xyo-network/xl1-rpc 1.16.9 → 1.16.10

package/dist/neutral/index.mjs

@@ -58,7 +58,6 @@ var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
     xyoViewer_stakeByStaker: /* @__PURE__ */ __name((params) => viewer.stakeByStaker(...params ?? []), "xyoViewer_stakeByStaker"),
     xyoViewer_stakesByStaked: /* @__PURE__ */ __name((params) => viewer.stakesByStaked(...params ?? []), "xyoViewer_stakesByStaked"),
     xyoViewer_stakesByStaker: /* @__PURE__ */ __name((params) => viewer.stakesByStaker(...params ?? []), "xyoViewer_stakesByStaker"),
-    xyoViewer_stakedByStaker: /* @__PURE__ */ __name((params) => viewer.stakedByStaker(...params ?? []), "xyoViewer_stakedByStaker"),
     xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
     xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
     xyoViewer_transactionByHash: /* @__PURE__ */ __name((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash"),
@@ -120,6 +119,9 @@ import { isError, isUndefinedOrNull } from "@xylabs/typeof";
 import { isAxiosError } from "axios";
 import { v4 } from "uuid";
 
+// src/types/DataLakeViewerRpc.ts
+var DataLakeViewerRpcNamespace = "dataLakeViewer";
+
 // src/types/ErrorCodes.ts
 var JsonRpcErrorCodes = {
   InternalError: {
@@ -193,15 +195,10 @@ var NetworkStakeViewerRpcSchemas = {
 };
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
-import * as z19 from "zod";
-
-// src/types/schema/common/Address.ts
-import { AddressRegEx, toAddress } from "@xylabs/hex";
-import * as z2 from "zod";
-var AddressZod = z2.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+import * as z17 from "zod";
 
 // src/types/schema/common/ArrayBuffer.ts
-import * as z3 from "zod";
+import * as z2 from "zod";
 function base64Encode(u8) {
   if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
     return Buffer.from(u8).toString("base64");
@@ -224,11 +221,11 @@ function base64Decode(b64) {
   return u8;
 }
 __name(base64Decode, "base64Decode");
-var ArrayBufferToJsonZod = z3.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z2.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z3.string().transform((x) => {
+var JsonToArrayBufferZod = z2.string().transform((x) => {
   const u8 = base64Decode(x);
   return u8.buffer;
 });
@@ -237,112 +234,112 @@ var JsonToArrayBufferZod = z3.string().transform((x) => {
 import { HashZod as HashZod2 } from "@xylabs/hex";
 import { StorageMetaZod as StorageMetaZod2 } from "@xyo-network/payload-model";
 import { XL1BlockNumberZod } from "@xyo-network/xl1-protocol";
-import * as z6 from "zod";
+import * as z5 from "zod";
 
 // src/types/schema/common/BoundWitness.ts
-import { HashZod, HexZod } from "@xylabs/hex";
+import { AddressZod, HashZod, HexZod } from "@xylabs/hex";
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { PayloadZod, SchemaZod, StorageMetaZod } from "@xyo-network/payload-model";
-import * as z4 from "zod";
-var BoundWitnessRequiredFieldsZod = z4.object({
-  addresses: z4.array(AddressZod),
-  payload_hashes: z4.array(HashZod),
-  payload_schemas: z4.array(SchemaZod),
-  previous_hashes: z4.array(HashZod.nullable())
+import * as z3 from "zod";
+var BoundWitnessRequiredFieldsZod = z3.object({
+  addresses: z3.array(AddressZod),
+  payload_hashes: z3.array(HashZod),
+  payload_schemas: z3.array(SchemaZod),
+  previous_hashes: z3.array(HashZod.nullable())
 });
-var BoundWitnessMetaZod = z4.object({
+var BoundWitnessMetaZod = z3.object({
   $destination: AddressZod.optional(),
   $sourceQuery: HashZod.optional(),
-  $signatures: z4.array(z4.union([
+  $signatures: z3.array(z3.union([
     HexZod,
-    z4.null()
+    z3.null()
   ]))
 });
 var BoundWitnessZod = PayloadZod.extend({
-  schema: z4.literal(BoundWitnessSchema)
+  schema: z3.literal(BoundWitnessSchema)
 }).extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape).refine((data) => data.$signatures.length === data.addresses.length, {
   message: "$signatures length must equal addresses length"
 });
-var AnyBoundWitnessZod = BoundWitnessZod.catchall(z4.any());
+var AnyBoundWitnessZod = BoundWitnessZod.catchall(z3.any());
 var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), {
   message: "all $signatures must be null"
 });
-var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z4.any());
+var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z3.any());
 var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape).safeExtend(StorageMetaZod.shape);
 var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), {
   message: "all $signatures must not be null"
 });
 var SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod;
-var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z4.any());
-var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z4.any());
+var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z3.any());
+var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z3.any());
 
 // src/types/schema/common/Chain.ts
-import { AddressRegEx as AddressRegEx2, toAddress as toAddress2 } from "@xylabs/hex";
-import * as z5 from "zod";
-var ChainZod = z5.string().toLowerCase().regex(AddressRegEx2).transform((v) => toAddress2(v));
+import { AddressRegEx, toAddress } from "@xylabs/hex";
+import * as z4 from "zod";
+var ChainZod = z4.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
 // src/types/schema/common/BlockBoundWitness.ts
-var BlockBoundWitnessFieldsZod = z6.object({
+var BlockBoundWitnessFieldsZod = z5.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
   previous: HashZod2.nullable(),
-  protocol: z6.number(),
-  step_hashes: z6.array(HashZod2).optional()
+  protocol: z5.number(),
+  step_hashes: z5.array(HashZod2).optional()
 });
-var BlockBoundWitnessMetaZod = z6.object({
-  $epoch: z6.number()
+var BlockBoundWitnessMetaZod = z5.object({
+  $epoch: z5.number()
 });
 var BlockBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod2.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod2.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 
 // src/types/schema/common/HydratedBlock.ts
 import { PayloadZodLoose, WithStorageMetaZod } from "@xyo-network/payload-model";
-import * as z7 from "zod";
-var HydratedBlockZod = z7.tuple([
+import * as z6 from "zod";
+var HydratedBlockZod = z6.tuple([
   BlockBoundWitnessZod,
-  z7.array(PayloadZodLoose)
+  z6.array(PayloadZodLoose)
 ]);
-var HydratedBlockWithStorageMetaZod = z7.tuple([
+var HydratedBlockWithStorageMetaZod = z6.tuple([
   WithStorageMetaZod(BlockBoundWitnessZod),
-  z7.array(WithStorageMetaZod(PayloadZodLoose))
+  z6.array(WithStorageMetaZod(PayloadZodLoose))
 ]);
-var SignedHydratedBlockZod = z7.tuple([
+var SignedHydratedBlockZod = z6.tuple([
   SignedBlockBoundWitnessZod,
-  z7.array(PayloadZodLoose)
+  z6.array(PayloadZodLoose)
 ]);
-var SignedHydratedBlockToJsonZod = z7.tuple([
+var SignedHydratedBlockToJsonZod = z6.tuple([
   SignedBlockBoundWitnessZod,
-  z7.array(PayloadZodLoose)
+  z6.array(PayloadZodLoose)
 ]);
-var SignedHydratedBlockWithStorageMetaZod = z7.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z6.tuple([
   WithStorageMetaZod(SignedBlockBoundWitnessZod),
-  z7.array(WithStorageMetaZod(PayloadZodLoose))
+  z6.array(WithStorageMetaZod(PayloadZodLoose))
 ]);
 
 // src/types/schema/common/HydratedTransaction.ts
 import { asAnyPayload, PayloadZodLoose as PayloadZodLoose2 } from "@xyo-network/payload-model";
 import { asSignedHydratedTransaction } from "@xyo-network/xl1-protocol";
-import * as z10 from "zod";
+import * as z9 from "zod";
 
 // src/types/schema/common/TransactionBoundWitness.ts
 import { StorageMetaZod as StorageMetaZod3 } from "@xyo-network/payload-model";
 import { BlockNumberZod as BlockNumberZod2 } from "@xyo-network/xl1-protocol";
-import * as z9 from "zod";
+import * as z8 from "zod";
 
 // src/types/schema/common/TransactionFees.ts
 import { BigIntToJsonZod as BigIntToJsonZod2, HexZod as HexZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/hex";
 import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-import * as z8 from "zod";
-var AttoZod = z8.bigint();
+import * as z7 from "zod";
+var AttoZod = z7.bigint();
 var JsonToAttoZod = JsonToBigIntZod2.transform((v) => asAttoXL1(v));
 var AttoToJsonZod = BigIntToJsonZod2;
-var TransactionFeesHexZod = z8.object({
+var TransactionFeesHexZod = z7.object({
   base: HexZod2,
   gasLimit: HexZod2,
   gasPrice: HexZod2,
   priority: HexZod2
 });
-var TransactionFeesBigIntZod = z8.object({
+var TransactionFeesBigIntZod = z7.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
@@ -362,23 +359,23 @@ var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) =>
 }));
 
 // src/types/schema/common/TransactionBoundWitness.ts
-var BlockStartZod = z9.object({
+var BlockStartZod = z8.object({
   nbf: BlockNumberZod2
 });
-var BlockEndZod = z9.object({
+var BlockEndZod = z8.object({
   exp: BlockNumberZod2
 });
-var BlockDurationZod = z9.object({
+var BlockDurationZod = z8.object({
   nbf: BlockNumberZod2,
   exp: BlockNumberZod2
 });
-var BlockScriptsZod = z9.object({
-  script: z9.array(z9.string()).optional()
+var BlockScriptsZod = z8.object({
+  script: z8.array(z8.string()).optional()
 });
-var WithTransactionFeesZod = z9.object({
+var WithTransactionFeesZod = z8.object({
   fees: TransactionFeesHexZod
 });
-var TransactionBoundWitnessFields = z9.object({
+var TransactionBoundWitnessFields = z8.object({
   chain: ChainZod,
   from: ChainZod
 });
@@ -386,17 +383,17 @@ var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod3.p
 var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod3.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
 
 // src/types/schema/common/HydratedTransaction.ts
-var HydratedTransactionZod = z10.tuple([
+var HydratedTransactionZod = z9.tuple([
   TransactionBoundWitnessZod,
-  z10.array(PayloadZodLoose2)
+  z9.array(PayloadZodLoose2)
 ]);
-var UnsignedHydratedTransactionZod = z10.tuple([
+var UnsignedHydratedTransactionZod = z9.tuple([
   TransactionBoundWitnessZod,
-  z10.array(PayloadZodLoose2)
+  z9.array(PayloadZodLoose2)
 ]);
-var SignedHydratedTransactionZod = z10.tuple([
+var SignedHydratedTransactionZod = z9.tuple([
   SignedTransactionBoundWitnessZod,
-  z10.array(PayloadZodLoose2)
+  z9.array(PayloadZodLoose2)
 ]);
 var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
   tx,
@@ -408,107 +405,99 @@ var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(
 ]);
 
 // src/types/schema/common/Json.ts
-import * as z11 from "zod";
-var JsonValueZod = z11.lazy(() => z11.union([
-  z11.string(),
-  z11.number(),
-  z11.boolean(),
-  z11.null(),
-  z11.array(JsonValueZod),
-  z11.record(z11.string(), JsonValueZod)
+import * as z10 from "zod";
+var JsonValueZod = z10.lazy(() => z10.union([
+  z10.string(),
+  z10.number(),
+  z10.boolean(),
+  z10.null(),
+  z10.array(JsonValueZod),
+  z10.record(z10.string(), JsonValueZod)
 ]));
-var JsonObjectZod = z11.record(z11.string(), JsonValueZod);
+var JsonObjectZod = z10.record(z10.string(), JsonValueZod);
 
 // src/types/schema/common/Permission.ts
-import { z as z12 } from "zod";
-var CaveatTypesZod = z12.enum([
+import { z as z11 } from "zod";
+var CaveatTypesZod = z11.enum([
   "chain",
   "expiration",
   "filteredResponse",
   "rateLimit",
   "restrictReturnedAccounts"
 ]);
-var CaveatsZod = z12.object({
+var CaveatsZod = z11.object({
   type: CaveatTypesZod,
-  value: z12.json()
+  value: z11.json()
 });
-var PermissionZod = z12.object({
-  parentCapability: z12.string(),
+var PermissionZod = z11.object({
+  parentCapability: z11.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z12.string()
+  invoker: z11.string()
 });
 var InvokerPermissionZod = PermissionZod.extend({
-  date: z12.number().optional()
+  date: z11.number().optional()
 });
-var PermissionRequestZod = z12.record(z12.string(), z12.record(z12.string(), z12.any()));
-var RequestedPermissionZod = z12.object({
-  parentCapability: z12.string(),
-  date: z12.number().optional()
+var PermissionRequestZod = z11.record(z11.string(), z11.record(z11.string(), z11.any()));
+var RequestedPermissionZod = z11.object({
+  parentCapability: z11.string(),
+  date: z11.number().optional()
 });
 
 // src/types/schema/common/RewardsRangeOptions.ts
-import { BlockRangeZod } from "@xyo-network/xl1-protocol";
-import { z as z14 } from "zod";
-
-// src/types/schema/common/StepIdentity.ts
-import * as z13 from "zod";
-var StepIdentityZod = z13.object({
-  block: z13.number(),
-  step: z13.number()
-});
-
-// src/types/schema/common/RewardsRangeOptions.ts
-var RewardsRangeOptionsZod = z14.object({
-  positions: z14.array(z14.number()).optional(),
+import { AddressZod as AddressZod2 } from "@xylabs/hex";
+import { BlockRangeZod, StepIdentityZod } from "@xyo-network/xl1-protocol";
+import { z as z12 } from "zod";
+var RewardsRangeOptionsZod = z12.object({
+  positions: z12.array(z12.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z14.array(StepIdentityZod).optional(),
-  stakers: z14.array(AddressZod).optional()
+  steps: z12.array(StepIdentityZod).optional(),
+  stakers: z12.array(AddressZod2).optional()
 });
 
 // src/types/schema/common/Sequence.ts
 import { HexRegExMinMax, toHex } from "@xylabs/hex";
 import { SequenceConstants } from "@xyo-network/payload-model";
-import * as z15 from "zod";
+import * as z13 from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z15.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z15.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z13.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z13.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z15.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z15.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z15.union([
+var QualifiedSequenceToStringZod = z13.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z13.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z13.union([
   LocalSequenceToStringZod,
   QualifiedSequenceToStringZod
 ]);
-var SequenceFromStringZod = z15.union([
+var SequenceFromStringZod = z13.union([
   LocalSequenceFromStringZod,
   QualifiedSequenceFromStringZod
 ]);
 
 // src/types/schema/common/Stake.ts
-import { HexZod as HexZod3 } from "@xylabs/hex";
-import * as z16 from "zod";
-var StakeZod = z16.object({
+import { AddressZod as AddressZod3, HexZod as HexZod3 } from "@xylabs/hex";
+import * as z14 from "zod";
+var StakeZod = z14.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z16.number(),
+  addBlock: z14.number(),
   // the unique id for the stake item
-  id: z16.number(),
+  id: z14.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z16.number(),
+  removeBlock: z14.number(),
   // the address that is being staked
-  staked: AddressZod,
+  staked: AddressZod3,
   // the address that owns the stake
-  staker: AddressZod,
+  staker: AddressZod3,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z16.number()
+  withdrawBlock: z14.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: AttoToJsonZod.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: AddressZod.parse(val.staked),
-  staker: AddressZod.parse(val.staker),
+  staked: AddressZod3.parse(val.staked),
+  staker: AddressZod3.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({
@@ -523,82 +512,74 @@ var JsonToStakeZod = StakeZod.extend({
   withdrawBlock: val.withdrawBlock
 }));
 
-// src/types/schema/common/Transfer.ts
-import { HexZod as HexZod4 } from "@xylabs/hex";
-import { PayloadZod as PayloadZod2 } from "@xyo-network/payload-model";
-import { TransferSchema } from "@xyo-network/xl1-protocol";
-import z17 from "zod";
-var TransferFieldsZod = z17.object({
-  $opCodes: z17.array(z17.string()).optional(),
-  context: z17.record(z17.string(), z17.json()).optional(),
-  epoch: z17.number(),
-  from: AddressZod,
-  transfers: z17.record(AddressZod, HexZod4)
-});
-var PayloadZodOfSchema = /* @__PURE__ */ __name((schema) => PayloadZod2.extend({
-  schema: z17.literal(schema)
-}), "PayloadZodOfSchema");
-var TransferZod = PayloadZodOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
+// src/types/schema/common/TimeDomain.ts
+import * as z15 from "zod";
+var TimeDomainZod = z15.union([
+  z15.literal("xl1"),
+  z15.literal("epoch"),
+  z15.literal("ethereum")
+]);
 
 // src/types/schema/common/TransferPair.ts
-import z18 from "zod";
-var TransferPairZod = z18.tuple([
-  AddressZod,
-  AddressZod
+import { AddressZod as AddressZod4 } from "@xylabs/hex";
+import z16 from "zod";
+var TransferPairZod = z16.tuple([
+  AddressZod4,
+  AddressZod4
 ]);
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
-      to: z19.array(z19.any()).length(0),
-      from: z19.array(z19.any()).length(0)
+      to: z17.array(z17.any()).length(0),
+      from: z17.array(z17.any()).length(0)
     },
     result: {
-      to: z19.array(InvokerPermissionZod),
-      from: z19.array(InvokerPermissionZod)
+      to: z17.array(InvokerPermissionZod),
+      from: z17.array(InvokerPermissionZod)
     }
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z19.tuple([
-        z19.array(PermissionRequestZod)
+      to: z17.tuple([
+        z17.array(PermissionRequestZod)
       ]),
-      from: z19.tuple([
-        z19.array(PermissionRequestZod)
+      from: z17.tuple([
+        z17.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z19.array(RequestedPermissionZod),
-      from: z19.array(RequestedPermissionZod)
+      to: z17.array(RequestedPermissionZod),
+      from: z17.array(RequestedPermissionZod)
     }
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z19.tuple([
-        z19.array(PermissionRequestZod)
+      to: z17.tuple([
+        z17.array(PermissionRequestZod)
       ]),
-      from: z19.tuple([
-        z19.array(PermissionRequestZod)
+      from: z17.tuple([
+        z17.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z19.array(RequestedPermissionZod),
-      from: z19.array(RequestedPermissionZod)
+      to: z17.array(RequestedPermissionZod),
+      from: z17.array(RequestedPermissionZod)
     }
   }
 };
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod, JsonToHashZod } from "@xylabs/hex";
-import * as z20 from "zod";
+import * as z18 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z20.tuple([
+      to: z18.tuple([
         SignedHydratedTransactionZod
       ]),
-      from: z20.tuple([
+      from: z18.tuple([
         SignedHydratedTransactionZod
       ])
     },
@@ -610,25 +591,26 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
+import { AddressZod as AddressZod5 } from "@xylabs/hex";
 import { asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { z as z21 } from "zod";
+import { z as z19 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z21.array(z21.any()).length(0).optional(),
-      from: z21.array(z21.any()).length(0).optional()
+      to: z19.array(z19.any()).length(0).optional(),
+      from: z19.array(z19.any()).length(0).optional()
     },
     result: {
-      to: AddressZod,
-      from: AddressZod
+      to: AddressZod5,
+      from: AddressZod5
     }
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z21.tuple([
+      to: z19.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z21.tuple([
+      from: z19.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
@@ -642,18 +624,18 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod2, HashZod as HashZod3, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
+import { AddressZod as AddressZod6, BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod2, HashZod as HashZod3, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
 import { WithHashMetaZod } from "@xyo-network/payload-model";
-import { BlockNumberZod as BlockNumberZod3, BlockRangeZod as BlockRangeZod2, StepIdentityZod as StepIdentityZod2, XL1BlockNumberZod as XL1BlockNumberZod2, XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
-import * as z22 from "zod";
+import { BlockNumberZod as BlockNumberZod3, BlockRangeZod as BlockRangeZod2, StepIdentityZod as StepIdentityZod2, TransferZod, XL1BlockNumberZod as XL1BlockNumberZod2, XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
+import * as z20 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
@@ -663,51 +645,51 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2,
-        AddressZod
+        AddressZod6
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2,
-        AddressZod
+        AddressZod6
       ])
     },
     result: {
-      to: z22.record(AddressZod, BigIntToJsonZod3),
-      from: z22.record(AddressZod, JsonToBigIntZod3)
+      to: z20.record(AddressZod6, BigIntToJsonZod3),
+      from: z20.record(AddressZod6, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
-      to: z22.record(AddressZod, BigIntToJsonZod3),
-      from: z22.record(AddressZod, JsonToBigIntZod3)
+      to: z20.record(AddressZod6, BigIntToJsonZod3),
+      from: z20.record(AddressZod6, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2,
-        AddressZod
+        AddressZod6
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2,
-        AddressZod
+        AddressZod6
       ])
     },
     result: {
-      to: z22.tuple([
+      to: z20.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -715,13 +697,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2,
-        AddressZod
+        AddressZod6
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2,
-        AddressZod
+        AddressZod6
       ])
     },
     result: {
@@ -731,11 +713,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
@@ -745,27 +727,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2
       ])
     },
     result: {
-      to: z22.record(AddressZod, BigIntToJsonZod3),
-      from: z22.record(AddressZod, JsonToBigIntZod3)
+      to: z20.record(AddressZod6, BigIntToJsonZod3),
+      from: z20.record(AddressZod6, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2,
-        z22.number()
+        z20.number()
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2,
-        z22.number()
+        z20.number()
       ])
     },
     result: {
@@ -775,13 +757,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2,
-        z22.number()
+        z20.number()
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2,
-        z22.number()
+        z20.number()
       ])
     },
     result: {
@@ -791,10 +773,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2
       ])
     },
@@ -805,10 +787,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2
       ])
     },
@@ -819,49 +801,49 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2
       ])
     },
     result: {
-      to: z22.number(),
-      from: z22.number()
+      to: z20.number(),
+      from: z20.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2
       ])
     },
     result: {
-      to: z22.record(AddressZod, BigIntToJsonZod3),
-      from: z22.record(AddressZod, JsonToBigIntZod3)
+      to: z20.record(AddressZod6, BigIntToJsonZod3),
+      from: z20.record(AddressZod6, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         StepIdentityZod2,
-        z22.number()
+        z20.number()
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         StepIdentityZod2,
-        z22.number()
+        z20.number()
       ])
     },
     result: {
-      to: z22.tuple([
+      to: z20.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -869,27 +851,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z22.tuple([
-        z22.number(),
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      to: z20.tuple([
+        z20.number(),
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ]),
-      from: z22.tuple([
-        z22.number(),
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      from: z20.tuple([
+        z20.number(),
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ])
     },
     result: {
-      to: z22.tuple([
+      to: z20.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -897,16 +879,16 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z22.tuple([
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      to: z20.tuple([
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ]),
-      from: z22.tuple([
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      from: z20.tuple([
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ])
     },
@@ -917,18 +899,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z22.tuple([
-        z22.number(),
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      to: z20.tuple([
+        z20.number(),
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ]),
-      from: z22.tuple([
-        z22.number(),
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      from: z20.tuple([
+        z20.number(),
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ])
     },
@@ -939,27 +921,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z22.tuple([
-        z22.number(),
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      to: z20.tuple([
+        z20.number(),
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ]),
-      from: z22.tuple([
-        z22.number(),
-        z22.tuple([
-          z22.number(),
-          z22.number()
+      from: z20.tuple([
+        z20.number(),
+        z20.tuple([
+          z20.number(),
+          z20.number()
         ])
       ])
     },
     result: {
-      to: z22.record(z22.string(), z22.tuple([
+      to: z20.record(z20.string(), z20.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ])),
-      from: z22.record(z22.string(), z22.tuple([
+      from: z20.record(z20.string(), z20.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ]))
@@ -967,11 +949,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
@@ -981,25 +963,25 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z22.union([
-        z22.tuple([
-          AddressZod
+      to: z20.union([
+        z20.tuple([
+          AddressZod6
         ]),
-        z22.tuple([
-          AddressZod,
-          z22.union([
+        z20.tuple([
+          AddressZod6,
+          z20.union([
             XL1BlockRangeZod,
             HashZod3
           ])
         ])
       ]),
-      from: z22.union([
-        z22.tuple([
-          AddressZod
+      from: z20.union([
+        z20.tuple([
+          AddressZod6
         ]),
-        z22.tuple([
-          AddressZod,
-          z22.union([
+        z20.tuple([
+          AddressZod6,
+          z20.union([
             XL1BlockRangeZod,
             HashZod3
           ])
@@ -1007,12 +989,12 @@ var XyoViewerRpcSchemas = {
       ])
     },
     result: {
-      to: z22.array(z22.tuple([
+      to: z20.array(z20.tuple([
         WithHashMetaZod(BlockBoundWitnessZod),
         WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
         WithHashMetaZod(TransferZod)
       ])),
-      from: z22.array(z22.tuple([
+      from: z20.array(z20.tuple([
         WithHashMetaZod(BlockBoundWitnessZod),
         WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
         WithHashMetaZod(TransferZod)
@@ -1021,10 +1003,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         TransferPairZod
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         TransferPairZod
       ])
     },
@@ -1035,20 +1017,20 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         TransferPairZod
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         TransferPairZod
       ])
     },
     result: {
-      to: z22.array(z22.tuple([
+      to: z20.array(z20.tuple([
         WithHashMetaZod(BlockBoundWitnessZod),
         WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
         WithHashMetaZod(TransferZod)
       ])),
-      from: z22.array(z22.tuple([
+      from: z20.array(z20.tuple([
         WithHashMetaZod(BlockBoundWitnessZod),
         WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
         WithHashMetaZod(TransferZod)
@@ -1057,11 +1039,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
@@ -1071,22 +1053,22 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z22.tuple([
-        AddressZod,
+      to: z20.tuple([
+        AddressZod6,
         BlockRangeZod2.optional()
       ]),
-      from: z22.tuple([
-        AddressZod,
+      from: z20.tuple([
+        AddressZod6,
         BlockRangeZod2.optional()
       ])
     },
     result: {
-      to: z22.array(z22.tuple([
+      to: z20.array(z20.tuple([
         WithHashMetaZod(BlockBoundWitnessZod),
         WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
         WithHashMetaZod(TransferZod)
       ])),
-      from: z22.array(z22.tuple([
+      from: z20.array(z20.tuple([
         WithHashMetaZod(BlockBoundWitnessZod),
         WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
         WithHashMetaZod(TransferZod)
@@ -1095,10 +1077,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         HashToJsonZod2
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         JsonToHashZod2
       ])
     },
@@ -1109,11 +1091,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z22.tuple([
-        z22.number()
+      to: z20.tuple([
+        z20.number()
       ]),
-      from: z22.tuple([
-        z22.number()
+      from: z20.tuple([
+        z20.number()
       ])
     },
     result: {
@@ -1123,48 +1105,48 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         HashZod3,
-        z22.number().optional()
+        z20.number().optional()
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         HashZod3,
-        z22.number().optional()
+        z20.number().optional()
       ])
     },
     result: {
-      to: z22.array(SignedHydratedBlockZod),
-      from: z22.array(SignedHydratedBlockZod)
+      to: z20.array(SignedHydratedBlockZod),
+      from: z20.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
-      to: AddressZod,
-      from: AddressZod
+      to: AddressZod6,
+      from: AddressZod6
     }
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         BlockNumberZod3
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         BlockNumberZod3
       ])
     },
     result: {
-      to: AddressZod,
-      from: AddressZod
+      to: AddressZod6,
+      from: AddressZod6
     }
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -1173,8 +1155,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: HashZod3,
@@ -1183,8 +1165,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: XL1BlockNumberZod2,
@@ -1193,23 +1175,23 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
-      to: z22.record(z22.number(), AddressZod),
-      from: z22.record(z22.number(), AddressZod)
+      to: z20.record(z20.number(), AddressZod6),
+      from: z20.record(z20.number(), AddressZod6)
     }
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z22.tuple([
-        AddressZod,
-        z22.number()
+      to: z20.tuple([
+        AddressZod6,
+        z20.number()
       ]),
-      from: z22.tuple([
-        AddressZod,
-        z22.number()
+      from: z20.tuple([
+        AddressZod6,
+        z20.number()
       ])
     },
     result: {
@@ -1219,11 +1201,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z22.tuple([
-        z22.number()
+      to: z20.tuple([
+        z20.number()
       ]),
-      from: z22.tuple([
-        z22.number()
+      from: z20.tuple([
+        z20.number()
       ])
     },
     result: {
@@ -1231,57 +1213,43 @@ var XyoViewerRpcSchemas = {
       from: JsonToStakeZod
     }
   },
-  xyoViewer_stakedByStaker: {
-    params: {
-      to: z22.tuple([
-        AddressZod
-      ]),
-      from: z22.tuple([
-        AddressZod
-      ])
-    },
-    result: {
-      to: z22.array(AddressZod),
-      from: z22.array(AddressZod)
-    }
-  },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
-      to: z22.array(StakeToJsonZod),
-      from: z22.array(JsonToStakeZod)
+      to: z20.array(StakeToJsonZod),
+      from: z20.array(JsonToStakeZod)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z22.tuple([
-        AddressZod
+      to: z20.tuple([
+        AddressZod6
       ]),
-      from: z22.tuple([
-        AddressZod
+      from: z20.tuple([
+        AddressZod6
       ])
     },
     result: {
-      to: z22.array(StakeToJsonZod),
-      from: z22.array(JsonToStakeZod)
+      to: z20.array(StakeToJsonZod),
+      from: z20.array(JsonToStakeZod)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         HashZod3,
-        z22.number()
+        z20.number()
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         HashZod3,
-        z22.number()
+        z20.number()
       ])
     },
     result: {
@@ -1291,13 +1259,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z22.tuple([
-        z22.number(),
-        z22.number()
+      to: z20.tuple([
+        z20.number(),
+        z20.number()
       ]),
-      from: z22.tuple([
-        z22.number(),
-        z22.number()
+      from: z20.tuple([
+        z20.number(),
+        z20.number()
       ])
     },
     result: {
@@ -1307,10 +1275,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z22.tuple([
+      to: z20.tuple([
         HashZod3
       ]),
-      from: z22.tuple([
+      from: z20.tuple([
         HashZod3
       ])
     },
@@ -1331,85 +1299,85 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z23 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z23.undefined()) => z23.object({
-  id: z23.union([
-    z23.string(),
-    z23.number()
+import * as z21 from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z21.undefined()) => z21.object({
+  id: z21.union([
+    z21.string(),
+    z21.number()
   ]),
-  jsonrpc: z23.literal(jsonrpc),
-  method: z23.literal(methodName),
+  jsonrpc: z21.literal(jsonrpc),
+  method: z21.literal(methodName),
   params: paramsSchema
 }), "createRequestSchema");
 
 // src/types/schema/createResponseSchema.ts
-import * as z24 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z24.undefined()) => z24.object({
-  id: z24.union([
-    z24.string(),
-    z24.number()
+import * as z22 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z22.undefined()) => z22.object({
+  id: z22.union([
+    z22.string(),
+    z22.number()
   ]),
-  jsonrpc: z24.literal(jsonrpc),
+  jsonrpc: z22.literal(jsonrpc),
   result: resultSchema
 }), "createResponseSchema");
 
 // src/types/schema/DataLakeViewerRpcSchema.ts
 import { HashZod as HashZod4 } from "@xylabs/hex";
-import { PayloadZod as PayloadZod3 } from "@xyo-network/payload-model";
-import * as z25 from "zod";
+import { PayloadZod as PayloadZod2 } from "@xyo-network/payload-model";
+import * as z23 from "zod";
 var DataLakeViewerRpcSchemas = {
   dataLakeViewer_get: {
     params: {
-      to: z25.tuple([
+      to: z23.tuple([
         HashZod4
       ]),
-      from: z25.tuple([
+      from: z23.tuple([
         HashZod4
       ])
     },
     result: {
-      to: z25.union([
-        PayloadZod3,
+      to: z23.union([
+        PayloadZod2,
         ArrayBufferToJsonZod
       ]).optional(),
-      from: z25.union([
-        PayloadZod3,
+      from: z23.union([
+        PayloadZod2,
         JsonToArrayBufferZod
       ]).optional()
     }
   },
   dataLakeViewer_getMany: {
     params: {
-      to: z25.tuple([
-        z25.array(HashZod4)
+      to: z23.tuple([
+        z23.array(HashZod4)
       ]),
-      from: z25.tuple([
-        z25.array(HashZod4)
+      from: z23.tuple([
+        z23.array(HashZod4)
       ])
     },
     result: {
-      to: z25.array(z25.union([
-        PayloadZod3,
+      to: z23.array(z23.union([
+        PayloadZod2,
         ArrayBufferToJsonZod
       ])),
-      from: z25.array(z25.union([
-        PayloadZod3,
+      from: z23.array(z23.union([
+        PayloadZod2,
         JsonToArrayBufferZod
       ]))
     }
   },
   dataLakeViewer_has: {
     params: {
-      to: z25.tuple([
+      to: z23.tuple([
         HashZod4
       ]),
-      from: z25.tuple([
+      from: z23.tuple([
         HashZod4
       ])
     },
     result: {
-      to: z25.boolean(),
-      from: z25.boolean()
+      to: z23.boolean(),
+      from: z23.boolean()
     }
   }
 };
@@ -1417,228 +1385,228 @@ var DataLakeViewerRpcSchemas = {
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/hex";
 import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
-import z26 from "zod";
+import z24 from "zod";
 var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z26.tuple([
+      from: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), BigIntToJsonZod4)
+      from: z24.record(z24.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
+      to: z24.record(z24.number(), BigIntToJsonZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      from: z26.tuple([
+      from: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z24.record(z24.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      from: z26.tuple([
+      from: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z24.record(z24.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      from: z26.tuple([
+      from: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z24.record(z24.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      from: z26.tuple([
+      from: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z24.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z24.record(z24.number(), JsonToBigIntZod4)
     }
   }
 };
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/hex";
-import z27 from "zod";
+import { AddressZod as AddressZod7, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/hex";
+import z25 from "zod";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      from: z27.tuple([
+      from: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod5),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z25.record(AddressZod7, BigIntToJsonZod5),
+      to: z25.record(AddressZod7, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      from: z27.tuple([
+      from: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod5),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z25.record(AddressZod7, BigIntToJsonZod5),
+      to: z25.record(AddressZod7, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      from: z27.tuple([
+      from: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod5),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z25.record(AddressZod7, BigIntToJsonZod5),
+      to: z25.record(AddressZod7, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      from: z27.tuple([
+      from: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod5),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z25.record(AddressZod7, BigIntToJsonZod5),
+      to: z25.record(AddressZod7, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      from: z27.tuple([
+      from: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z25.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod5),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z25.record(AddressZod7, BigIntToJsonZod5),
+      to: z25.record(AddressZod7, JsonToBigIntZod5)
     }
   }
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/hex";
-import z28 from "zod";
+import { AddressZod as AddressZod8, BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/hex";
+import z26 from "zod";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      from: z28.tuple([
+      from: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod6),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z26.record(AddressZod8, BigIntToJsonZod6),
+      to: z26.record(AddressZod8, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      from: z28.tuple([
+      from: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod6),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z26.record(AddressZod8, BigIntToJsonZod6),
+      to: z26.record(AddressZod8, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      from: z28.tuple([
+      from: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod6),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z26.record(AddressZod8, BigIntToJsonZod6),
+      to: z26.record(AddressZod8, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_total: {
     params: {
-      from: z28.tuple([
+      from: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod6),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z26.record(AddressZod8, BigIntToJsonZod6),
+      to: z26.record(AddressZod8, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      from: z28.tuple([
+      from: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z26.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod6),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z26.record(AddressZod8, BigIntToJsonZod6),
+      to: z26.record(AddressZod8, JsonToBigIntZod6)
     }
   }
 };
@@ -1646,14 +1614,14 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/hex";
 import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
-import * as z29 from "zod";
+import * as z27 from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z29.tuple([
+      from: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1664,10 +1632,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      from: z29.tuple([
+      from: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1678,10 +1646,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      from: z29.tuple([
+      from: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1692,10 +1660,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_total: {
     params: {
-      from: z29.tuple([
+      from: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1706,10 +1674,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z29.tuple([
+      from: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z27.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1723,6 +1691,83 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
 // src/types/schema/StepRewardsViewerRpcSchemas.ts
 var NetworkStakingStepRewardsViewerRpcSchemas = {};
 
+// src/types/schema/TimeSyncViewerRpcSchema.ts
+import { TimePayloadZod } from "@xyo-network/xl1-protocol";
+import * as z28 from "zod";
+var TimeSyncViewerRpcSchemas = {
+  timeSyncViewer_convertTime: {
+    params: {
+      from: z28.tuple([
+        TimeDomainZod,
+        TimeDomainZod,
+        z28.number()
+      ]),
+      to: z28.tuple([
+        TimeDomainZod,
+        TimeDomainZod,
+        z28.number()
+      ])
+    },
+    result: {
+      from: z28.number(),
+      to: z28.number()
+    }
+  },
+  timeSyncViewer_currentTime: {
+    params: {
+      from: z28.tuple([
+        TimeDomainZod
+      ]),
+      to: z28.tuple([
+        TimeDomainZod
+      ])
+    },
+    result: {
+      from: z28.tuple([
+        TimeDomainZod,
+        z28.number()
+      ]),
+      to: z28.tuple([
+        TimeDomainZod,
+        z28.number()
+      ])
+    }
+  },
+  timeSyncViewer_currentTimeAndHash: {
+    params: {
+      from: z28.tuple([
+        TimeDomainZod
+      ]),
+      to: z28.tuple([
+        TimeDomainZod
+      ])
+    },
+    result: {
+      from: z28.tuple([
+        z28.number(),
+        z28.nullable(z28.string())
+      ]),
+      to: z28.tuple([
+        z28.number(),
+        z28.nullable(z28.string())
+      ])
+    }
+  },
+  timeSyncViewer_currentTimePayload: {
+    params: {
+      from: z28.tuple([]),
+      to: z28.tuple([])
+    },
+    result: {
+      from: TimePayloadZod,
+      to: TimePayloadZod
+    }
+  }
+};
+
+// src/types/TimeSyncViewerRpc.ts
+var TimeSyncViewerRpcNamespace = "timeSyncViewer";
+
 // src/transport/HttpRpcTransport.ts
 var HttpRpcTransport = class {
   static {
@@ -1854,12 +1899,12 @@ var NodeXyoRunner = class {
   }
   getArchivist = /* @__PURE__ */ __name(async (identifier) => {
     const archivist = await this.node.resolve(identifier);
-    return assertEx2(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+    return assertEx2(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
   }, "getArchivist");
   getPendingArchivist = /* @__PURE__ */ __name(async () => {
     if (this._pendingArchivist) return this._pendingArchivist;
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
-    return assertEx2(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${this.pendingArchivistPath}`);
+    return assertEx2(this._pendingArchivist, () => `Could not resolve pending archivist at ${this.pendingArchivistPath}`);
   }, "getPendingArchivist");
 };
 
@@ -1932,9 +1977,51 @@ var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
   }
 };
 
+// src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts
+var JsonRpcTimeSyncViewerMethods = class {
+  static {
+    __name(this, "JsonRpcTimeSyncViewerMethods");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async convertTime(fromDomain, toDomain, from) {
+    return await this.transport.sendRequest("timeSyncViewer_convertTime", [
+      fromDomain,
+      toDomain,
+      from
+    ]);
+  }
+  async currentTime(domain) {
+    return await this.transport.sendRequest("timeSyncViewer_currentTime", [
+      domain
+    ]);
+  }
+  async currentTimeAndHash(domain) {
+    return await this.transport.sendRequest("timeSyncViewer_currentTimeAndHash", [
+      domain
+    ]);
+  }
+  async currentTimePayload() {
+    return await this.transport.sendRequest("timeSyncViewer_currentTimePayload", []);
+  }
+};
+
+// src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts
+var JsonRpcTimeSyncViewer = class extends JsonRpcTimeSyncViewerMethods {
+  static {
+    __name(this, "JsonRpcTimeSyncViewer");
+  }
+  constructor(transport) {
+    super(transport);
+  }
+};
+
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { asHash, isHash } from "@xylabs/hex";
-import { asAttoXL1 as asAttoXL14, asHydratedBlock, asXL1BlockRange, isRange } from "@xyo-network/xl1-protocol";
+import { isHash } from "@xylabs/hex";
+import { isDefined } from "@xylabs/typeof";
+import { asAttoXL1 as asAttoXL14, asHydratedBlock } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
@@ -1954,18 +2041,16 @@ var JsonRpcXyoViewer = class {
     ]));
   }
   async accountBalanceHistory(address, headOrRange) {
-    const head = asHash(headOrRange);
-    const range = asXL1BlockRange(headOrRange);
-    if (isHash(head)) {
-      return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
-        address,
-        head
-      ]);
-    }
-    if (isRange(range)) {
+    if (isDefined(headOrRange)) {
+      if (isHash(headOrRange)) {
+        return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
+          address,
+          headOrRange
+        ]);
+      }
       return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
         address,
-        range
+        headOrRange
       ]);
     }
     return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
@@ -2122,11 +2207,6 @@ var JsonRpcXyoViewer = class {
       slot
     ]);
   }
-  async stakedByStaker(staker) {
-    return await this.transport.sendRequest("xyoViewer_stakedByStaker", [
-      staker
-    ]);
-  }
   async stakesByStaked(staked) {
     return await this.transport.sendRequest("xyoViewer_stakesByStaked", [
       staked
@@ -2296,7 +2376,6 @@ var RpcXyoSigner = class {
   }
 };
 export {
-  AddressZod,
   AllRpcSchemas,
   AnyBoundWitnessZod,
   AnySignedBoundWitnessWithStorageMetaZod,
@@ -2314,6 +2393,7 @@ export {
   CaveatTypesZod,
   CaveatsZod,
   ChainZod,
+  DataLakeViewerRpcNamespace,
   DataLakeViewerRpcSchemas,
   HttpRpcTransport,
   HttpRpcXyoConnection,
@@ -2329,6 +2409,8 @@ export {
   JsonRpcNetworkStakeViewerMethods,
   JsonRpcNetworkStakingStepRewardsViewer,
   JsonRpcNetworkStakingStepRewardsViewerMethods,
+  JsonRpcTimeSyncViewer,
+  JsonRpcTimeSyncViewerMethods,
   JsonRpcViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
@@ -2352,7 +2434,6 @@ export {
   NetworkStakingStepRewardsViewerRpcNamespace,
   NetworkStakingStepRewardsViewerRpcSchemas,
   NodeXyoRunner,
-  PayloadZodOfSchema,
   PermissionRequestZod,
   PermissionZod,
   QualifiedSequenceFromStringZod,
@@ -2374,15 +2455,15 @@ export {
   SignedTransactionBoundWitnessZod,
   StakeToJsonZod,
   StakeZod,
-  StepIdentityZod,
+  TimeDomainZod,
+  TimeSyncViewerRpcNamespace,
+  TimeSyncViewerRpcSchemas,
   TransactionBoundWitnessZod,
   TransactionFeesBigIntToJsonZod,
   TransactionFeesBigIntZod,
   TransactionFeesHexZod,
   TransactionFeesJsonToBigIntZod,
-  TransferFieldsZod,
   TransferPairZod,
-  TransferZod,
   UnsignedBoundWitnessWithStorageMetaZod,
   UnsignedBoundWitnessZod,
   UnsignedHydratedTransactionZod,