@xyo-network/xl1-rpc 1.16.21 → 1.16.23

package/dist/neutral/index.mjs

@@ -45,6 +45,8 @@ var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
     xyoViewer_networkStakeStepRewardsForStepLevel: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardsForStepLevel?.(...params ?? []), "xyoViewer_networkStakeStepRewardsForStepLevel"),
     xyoViewer_accountBalance: /* @__PURE__ */ __name((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
     xyoViewer_accountBalanceHistory: /* @__PURE__ */ __name((params) => viewer.accountBalanceHistory(...params ?? []), "xyoViewer_accountBalanceHistory"),
+    xyoViewer_accountsBalances: /* @__PURE__ */ __name((params) => viewer.accountsBalances(...params ?? []), "xyoViewer_accountsBalances"),
+    xyoViewer_accountsBalancesHistory: /* @__PURE__ */ __name((params) => viewer.accountsBalancesHistory(...params ?? []), "xyoViewer_accountsBalancesHistory"),
     xyoViewer_blockByHash: /* @__PURE__ */ __name((params) => viewer.blockByHash(...params ?? []), "xyoViewer_blockByHash"),
     xyoViewer_blockByNumber: /* @__PURE__ */ __name((params) => viewer.blockByNumber(...params ?? []), "xyoViewer_blockByNumber"),
     xyoViewer_blocksByHash: /* @__PURE__ */ __name((params) => viewer.blocksByHash(...params ?? []), "xyoViewer_blocksByHash"),
@@ -195,391 +197,60 @@ var NetworkStakeViewerRpcSchemas = {
 };
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
-import * as z17 from "zod";
-
-// src/types/schema/common/ArrayBuffer.ts
+import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol-sdk";
 import * as z2 from "zod";
-function base64Encode(u8) {
-  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
-    return Buffer.from(u8).toString("base64");
-  }
-  let binary = "";
-  const chunk = 32768;
-  for (let i = 0; i < u8.length; i += chunk) {
-    binary += String.fromCharCode(...u8.subarray(i, i + chunk));
-  }
-  return btoa(binary);
-}
-__name(base64Encode, "base64Encode");
-function base64Decode(b64) {
-  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
-    return new Uint8Array(Buffer.from(b64, "base64"));
-  }
-  const binary = atob(b64);
-  const u8 = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
-  return u8;
-}
-__name(base64Decode, "base64Decode");
-var ArrayBufferToJsonZod = z2.instanceof(ArrayBuffer).transform((x) => {
-  const u8 = new Uint8Array(x);
-  return base64Encode(u8);
-});
-var JsonToArrayBufferZod = z2.string().transform((x) => {
-  const u8 = base64Decode(x);
-  return u8.buffer;
-});
-
-// src/types/schema/common/BlockBoundWitness.ts
-import { HashZod as HashZod2 } from "@xylabs/sdk-js";
-import { StorageMetaZod as StorageMetaZod2 } from "@xyo-network/payload-model";
-import { XL1BlockNumberZod } from "@xyo-network/xl1-protocol";
-import * as z5 from "zod";
-
-// src/types/schema/common/BoundWitness.ts
-import { AddressZod, HashZod, HexZod } from "@xylabs/sdk-js";
-import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import { PayloadZod, SchemaZod, StorageMetaZod } from "@xyo-network/payload-model";
-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 = z3.object({
-  $destination: AddressZod.optional(),
-  $sourceQuery: HashZod.optional(),
-  $signatures: z3.array(z3.union([
-    HexZod,
-    z3.null()
-  ]))
-});
-var BoundWitnessZod = PayloadZod.extend({
-  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(z3.any());
-var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), {
-  message: "all $signatures must be null"
-});
-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(z3.any());
-var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z3.any());
-
-// src/types/schema/common/Chain.ts
-import { AddressRegEx, toAddress } from "@xylabs/sdk-js";
-import * as z4 from "zod";
-var ChainZod = z4.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
-
-// src/types/schema/common/BlockBoundWitness.ts
-var BlockBoundWitnessFieldsZod = z5.object({
-  block: XL1BlockNumberZod,
-  chain: ChainZod,
-  previous: HashZod2.nullable(),
-  protocol: z5.number(),
-  step_hashes: z5.array(HashZod2).optional()
-});
-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 z6 from "zod";
-var HydratedBlockZod = z6.tuple([
-  BlockBoundWitnessZod,
-  z6.array(PayloadZodLoose)
-]);
-var HydratedBlockWithStorageMetaZod = z6.tuple([
-  WithStorageMetaZod(BlockBoundWitnessZod),
-  z6.array(WithStorageMetaZod(PayloadZodLoose))
-]);
-var SignedHydratedBlockZod = z6.tuple([
-  SignedBlockBoundWitnessZod,
-  z6.array(PayloadZodLoose)
-]);
-var SignedHydratedBlockToJsonZod = z6.tuple([
-  SignedBlockBoundWitnessZod,
-  z6.array(PayloadZodLoose)
-]);
-var SignedHydratedBlockWithStorageMetaZod = z6.tuple([
-  WithStorageMetaZod(SignedBlockBoundWitnessZod),
-  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 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 z8 from "zod";
-
-// src/types/schema/common/TransactionFees.ts
-import { BigIntToJsonZod as BigIntToJsonZod2, HexZod as HexZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/sdk-js";
-import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-import * as z7 from "zod";
-var AttoZod = z7.bigint();
-var JsonToAttoZod = JsonToBigIntZod2.transform((v) => asAttoXL1(v));
-var AttoToJsonZod = BigIntToJsonZod2;
-var TransactionFeesHexZod = z7.object({
-  base: HexZod2,
-  gasLimit: HexZod2,
-  gasPrice: HexZod2,
-  priority: HexZod2
-});
-var TransactionFeesBigIntZod = z7.object({
-  base: AttoZod,
-  gasLimit: AttoZod,
-  gasPrice: AttoZod,
-  priority: AttoZod
-});
-var TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform((val) => ({
-  base: JsonToBigIntZod2.parse(val.base),
-  gasLimit: JsonToBigIntZod2.parse(val.gasLimit),
-  gasPrice: JsonToBigIntZod2.parse(val.gasPrice),
-  priority: JsonToBigIntZod2.parse(val.priority)
-}));
-var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) => ({
-  base: BigIntToJsonZod2.parse(val.base),
-  gasLimit: BigIntToJsonZod2.parse(val.gasLimit),
-  gasPrice: BigIntToJsonZod2.parse(val.gasPrice),
-  priority: BigIntToJsonZod2.parse(val.priority)
-}));
-
-// src/types/schema/common/TransactionBoundWitness.ts
-var BlockStartZod = z8.object({
-  nbf: BlockNumberZod2
-});
-var BlockEndZod = z8.object({
-  exp: BlockNumberZod2
-});
-var BlockDurationZod = z8.object({
-  nbf: BlockNumberZod2,
-  exp: BlockNumberZod2
-});
-var BlockScriptsZod = z8.object({
-  script: z8.array(z8.string()).optional()
-});
-var WithTransactionFeesZod = z8.object({
-  fees: TransactionFeesHexZod
-});
-var TransactionBoundWitnessFields = z8.object({
-  chain: ChainZod,
-  from: ChainZod
-});
-var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod3.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod);
-var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod3.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
-
-// src/types/schema/common/HydratedTransaction.ts
-var HydratedTransactionZod = z9.tuple([
-  TransactionBoundWitnessZod,
-  z9.array(PayloadZodLoose2)
-]);
-var UnsignedHydratedTransactionZod = z9.tuple([
-  TransactionBoundWitnessZod,
-  z9.array(PayloadZodLoose2)
-]);
-var SignedHydratedTransactionZod = z9.tuple([
-  SignedTransactionBoundWitnessZod,
-  z9.array(PayloadZodLoose2)
-]);
-var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
-  tx,
-  payloads.map((payload) => payload)
-]));
-var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => [
-  asSignedHydratedTransaction(tx),
-  payloads.map((p) => asAnyPayload(p))
-]);
-
-// src/types/schema/common/Json.ts
-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 = z10.record(z10.string(), JsonValueZod);
-
-// src/types/schema/common/Permission.ts
-import { z as z11 } from "zod";
-var CaveatTypesZod = z11.enum([
-  "chain",
-  "expiration",
-  "filteredResponse",
-  "rateLimit",
-  "restrictReturnedAccounts"
-]);
-var CaveatsZod = z11.object({
-  type: CaveatTypesZod,
-  value: z11.json()
-});
-var PermissionZod = z11.object({
-  parentCapability: z11.string(),
-  caveats: CaveatsZod.array().optional(),
-  invoker: z11.string()
-});
-var InvokerPermissionZod = PermissionZod.extend({
-  date: z11.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 { AddressZod as AddressZod2 } from "@xylabs/sdk-js";
-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: z12.array(StepIdentityZod).optional(),
-  stakers: z12.array(AddressZod2).optional()
-});
-
-// src/types/schema/common/Sequence.ts
-import { HexRegExMinMax, toHex } from "@xylabs/sdk-js";
-import { SequenceConstants } from "@xyo-network/payload-model";
-import * as z13 from "zod";
-var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-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 = z13.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z13.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z13.union([
-  LocalSequenceToStringZod,
-  QualifiedSequenceToStringZod
-]);
-var SequenceFromStringZod = z13.union([
-  LocalSequenceFromStringZod,
-  QualifiedSequenceFromStringZod
-]);
-
-// src/types/schema/common/Stake.ts
-import { AddressZod as AddressZod3, HexZod as HexZod3 } from "@xylabs/sdk-js";
-import * as z14 from "zod";
-var StakeZod = z14.object({
-  amount: AttoZod,
-  // the block number when the stake was added
-  addBlock: z14.number(),
-  // the unique id for the stake item
-  id: z14.number(),
-  // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z14.number(),
-  // the address that is being staked
-  staked: AddressZod3,
-  // the address that owns the stake
-  staker: AddressZod3,
-  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z14.number()
-});
-var StakeToJsonZod = StakeZod.transform((val) => ({
-  addBlock: val.addBlock,
-  amount: AttoToJsonZod.parse(val.amount),
-  id: val.id,
-  removeBlock: val.removeBlock,
-  staked: AddressZod3.parse(val.staked),
-  staker: AddressZod3.parse(val.staker),
-  withdrawBlock: val.withdrawBlock
-}));
-var JsonToStakeZod = StakeZod.extend({
-  amount: HexZod3
-}).transform((val) => ({
-  addBlock: val.addBlock,
-  amount: JsonToAttoZod.parse(val.amount),
-  id: val.id,
-  removeBlock: val.removeBlock,
-  staked: val.staked,
-  staker: val.staker,
-  withdrawBlock: val.withdrawBlock
-}));
-
-// 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 { AddressZod as AddressZod4 } from "@xylabs/sdk-js";
-import z16 from "zod";
-var TransferPairZod = z16.tuple([
-  AddressZod4,
-  AddressZod4
-]);
-
-// src/types/schema/XyoPermissionsRpcSchemas.ts
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
-      to: z17.array(z17.any()).length(0),
-      from: z17.array(z17.any()).length(0)
+      to: z2.array(z2.any()).length(0),
+      from: z2.array(z2.any()).length(0)
     },
     result: {
-      to: z17.array(InvokerPermissionZod),
-      from: z17.array(InvokerPermissionZod)
+      to: z2.array(InvokerPermissionZod),
+      from: z2.array(InvokerPermissionZod)
     }
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z17.tuple([
-        z17.array(PermissionRequestZod)
+      to: z2.tuple([
+        z2.array(PermissionRequestZod)
       ]),
-      from: z17.tuple([
-        z17.array(PermissionRequestZod)
+      from: z2.tuple([
+        z2.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z17.array(RequestedPermissionZod),
-      from: z17.array(RequestedPermissionZod)
+      to: z2.array(RequestedPermissionZod),
+      from: z2.array(RequestedPermissionZod)
     }
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z17.tuple([
-        z17.array(PermissionRequestZod)
+      to: z2.tuple([
+        z2.array(PermissionRequestZod)
       ]),
-      from: z17.tuple([
-        z17.array(PermissionRequestZod)
+      from: z2.tuple([
+        z2.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z17.array(RequestedPermissionZod),
-      from: z17.array(RequestedPermissionZod)
+      to: z2.array(RequestedPermissionZod),
+      from: z2.array(RequestedPermissionZod)
     }
   }
 };
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod, JsonToHashZod } from "@xylabs/sdk-js";
-import * as z18 from "zod";
+import { SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z3 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z18.tuple([
+      to: z3.tuple([
         SignedHydratedTransactionZod
       ]),
-      from: z18.tuple([
+      from: z3.tuple([
         SignedHydratedTransactionZod
       ])
     },
@@ -591,32 +262,33 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { AddressZod as AddressZod5 } from "@xylabs/sdk-js";
+import { AddressZod } from "@xylabs/sdk-js";
 import { asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { z as z19 } from "zod";
+import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol-sdk";
+import { z as z4 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z19.array(z19.any()).length(0).optional(),
-      from: z19.array(z19.any()).length(0).optional()
+      to: z4.array(z4.any()).length(0).optional(),
+      from: z4.array(z4.any()).length(0).optional()
     },
     result: {
-      to: AddressZod5,
-      from: AddressZod5
+      to: AddressZod,
+      from: AddressZod
     }
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z19.tuple([
+      to: z4.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z19.tuple([
+      from: z4.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod,
-      from: SignedHydratedTransactionZod.transform((data) => asHydratedTransactionWithStorageMeta(data, {
+      to: SignedHydratedTransactionZod2,
+      from: SignedHydratedTransactionZod2.transform((data) => asHydratedTransactionWithStorageMeta(data, {
         required: true
       }))
     }
@@ -624,463 +296,521 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { AddressZod as AddressZod6, BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod2, HashZod as HashZod3, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/sdk-js";
-import { WithHashMetaZod } from "@xyo-network/payload-model";
-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";
+import { AddressZod as AddressZod2, BigIntToJsonZod as BigIntToJsonZod2, HashToJsonZod as HashToJsonZod2, HashZod, JsonToBigIntZod as JsonToBigIntZod2, JsonToHashZod as JsonToHashZod2 } from "@xylabs/sdk-js";
+import { BlockNumberZod as BlockNumberZod2, BlockRangeZod, StepIdentityZod, XL1BlockNumberZod, XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
+import { AccountBalanceHistoryItemZod, JsonToStakeZod, SignedHydratedBlockZod, SignedHydratedTransactionZod as SignedHydratedTransactionZod3, StakeToJsonZod, TransferPairZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z5 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.tuple([
+        AddressZod2
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.tuple([
+        AddressZod2
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2,
-        AddressZod6
+      to: z5.tuple([
+        StepIdentityZod,
+        AddressZod2
       ]),
-      from: z20.tuple([
-        StepIdentityZod2,
-        AddressZod6
+      from: z5.tuple([
+        StepIdentityZod,
+        AddressZod2
       ])
     },
     result: {
-      to: z20.record(AddressZod6, BigIntToJsonZod3),
-      from: z20.record(AddressZod6, JsonToBigIntZod3)
+      to: z5.record(AddressZod2, BigIntToJsonZod2),
+      from: z5.record(AddressZod2, JsonToBigIntZod2)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.tuple([
+        AddressZod2
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.tuple([
+        AddressZod2
       ])
     },
     result: {
-      to: z20.record(AddressZod6, BigIntToJsonZod3),
-      from: z20.record(AddressZod6, JsonToBigIntZod3)
+      to: z5.record(AddressZod2, BigIntToJsonZod2),
+      from: z5.record(AddressZod2, JsonToBigIntZod2)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2,
-        AddressZod6
+      to: z5.tuple([
+        StepIdentityZod,
+        AddressZod2
       ]),
-      from: z20.tuple([
-        StepIdentityZod2,
-        AddressZod6
+      from: z5.tuple([
+        StepIdentityZod,
+        AddressZod2
       ])
     },
     result: {
-      to: z20.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z5.tuple([
+        BigIntToJsonZod2,
+        BigIntToJsonZod2
       ]),
-      from: z20.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
+      from: z5.tuple([
+        JsonToBigIntZod2,
+        JsonToBigIntZod2
       ])
     }
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2,
-        AddressZod6
+      to: z5.tuple([
+        StepIdentityZod,
+        AddressZod2
       ]),
-      from: z20.tuple([
-        StepIdentityZod2,
-        AddressZod6
+      from: z5.tuple([
+        StepIdentityZod,
+        AddressZod2
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.tuple([
+        AddressZod2
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.tuple([
+        AddressZod2
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2
+      to: z5.tuple([
+        StepIdentityZod
       ]),
-      from: z20.tuple([
-        StepIdentityZod2
+      from: z5.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z20.record(AddressZod6, BigIntToJsonZod3),
-      from: z20.record(AddressZod6, JsonToBigIntZod3)
+      to: z5.record(AddressZod2, BigIntToJsonZod2),
+      from: z5.record(AddressZod2, JsonToBigIntZod2)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2,
-        z20.number()
+      to: z5.tuple([
+        StepIdentityZod,
+        z5.number()
       ]),
-      from: z20.tuple([
-        StepIdentityZod2,
-        z20.number()
+      from: z5.tuple([
+        StepIdentityZod,
+        z5.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2,
-        z20.number()
+      to: z5.tuple([
+        StepIdentityZod,
+        z5.number()
       ]),
-      from: z20.tuple([
-        StepIdentityZod2,
-        z20.number()
+      from: z5.tuple([
+        StepIdentityZod,
+        z5.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2
+      to: z5.tuple([
+        StepIdentityZod
       ]),
-      from: z20.tuple([
-        StepIdentityZod2
+      from: z5.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2
+      to: z5.tuple([
+        StepIdentityZod
       ]),
-      from: z20.tuple([
-        StepIdentityZod2
+      from: z5.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2
+      to: z5.tuple([
+        StepIdentityZod
       ]),
-      from: z20.tuple([
-        StepIdentityZod2
+      from: z5.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z20.number(),
-      from: z20.number()
+      to: z5.number(),
+      from: z5.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2
+      to: z5.tuple([
+        StepIdentityZod
       ]),
-      from: z20.tuple([
-        StepIdentityZod2
+      from: z5.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z20.record(AddressZod6, BigIntToJsonZod3),
-      from: z20.record(AddressZod6, JsonToBigIntZod3)
+      to: z5.record(AddressZod2, BigIntToJsonZod2),
+      from: z5.record(AddressZod2, JsonToBigIntZod2)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z20.tuple([
-        StepIdentityZod2,
-        z20.number()
+      to: z5.tuple([
+        StepIdentityZod,
+        z5.number()
       ]),
-      from: z20.tuple([
-        StepIdentityZod2,
-        z20.number()
+      from: z5.tuple([
+        StepIdentityZod,
+        z5.number()
       ])
     },
     result: {
-      to: z20.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z5.tuple([
+        BigIntToJsonZod2,
+        BigIntToJsonZod2
       ]),
-      from: z20.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
+      from: z5.tuple([
+        JsonToBigIntZod2,
+        JsonToBigIntZod2
       ])
     }
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z20.tuple([
-        z20.number(),
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      to: z5.tuple([
+        z5.number(),
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ]),
-      from: z20.tuple([
-        z20.number(),
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      from: z5.tuple([
+        z5.number(),
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ])
     },
     result: {
-      to: z20.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z5.tuple([
+        BigIntToJsonZod2,
+        BigIntToJsonZod2
       ]),
-      from: z20.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
+      from: z5.tuple([
+        JsonToBigIntZod2,
+        JsonToBigIntZod2
       ])
     }
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z20.tuple([
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      to: z5.tuple([
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ]),
-      from: z20.tuple([
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      from: z5.tuple([
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z20.tuple([
-        z20.number(),
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      to: z5.tuple([
+        z5.number(),
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ]),
-      from: z20.tuple([
-        z20.number(),
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      from: z5.tuple([
+        z5.number(),
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z20.tuple([
-        z20.number(),
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      to: z5.tuple([
+        z5.number(),
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ]),
-      from: z20.tuple([
-        z20.number(),
-        z20.tuple([
-          z20.number(),
-          z20.number()
+      from: z5.tuple([
+        z5.number(),
+        z5.tuple([
+          z5.number(),
+          z5.number()
         ])
       ])
     },
     result: {
-      to: z20.record(z20.string(), z20.tuple([
-        BigIntToJsonZod3,
-        BigIntToJsonZod3
+      to: z5.record(z5.string(), z5.tuple([
+        BigIntToJsonZod2,
+        BigIntToJsonZod2
       ])),
-      from: z20.record(z20.string(), z20.tuple([
-        JsonToBigIntZod3,
-        JsonToBigIntZod3
+      from: z5.record(z5.string(), z5.tuple([
+        JsonToBigIntZod2,
+        JsonToBigIntZod2
       ]))
     }
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.union([
+        z5.tuple([
+          AddressZod2
+        ]),
+        z5.tuple([
+          AddressZod2,
+          z5.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.union([
+        z5.tuple([
+          AddressZod2
+        ]),
+        z5.tuple([
+          AddressZod2,
+          z5.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z20.union([
-        z20.tuple([
-          AddressZod6
+      to: z5.union([
+        z5.tuple([
+          AddressZod2
         ]),
-        z20.tuple([
-          AddressZod6,
-          z20.union([
+        z5.tuple([
+          AddressZod2,
+          z5.union([
             XL1BlockRangeZod,
-            HashZod3
+            HashZod
           ])
         ])
       ]),
-      from: z20.union([
-        z20.tuple([
-          AddressZod6
+      from: z5.union([
+        z5.tuple([
+          AddressZod2
         ]),
-        z20.tuple([
-          AddressZod6,
-          z20.union([
+        z5.tuple([
+          AddressZod2,
+          z5.union([
             XL1BlockRangeZod,
-            HashZod3
+            HashZod
           ])
         ])
       ])
     },
     result: {
-      to: z20.array(z20.tuple([
-        WithHashMetaZod(BlockBoundWitnessZod),
-        WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-        WithHashMetaZod(TransferZod)
-      ])),
-      from: z20.array(z20.tuple([
-        WithHashMetaZod(BlockBoundWitnessZod),
-        WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-        WithHashMetaZod(TransferZod)
-      ]))
+      to: z5.array(AccountBalanceHistoryItemZod),
+      from: z5.array(AccountBalanceHistoryItemZod)
+    }
+  },
+  xyoViewer_accountsBalances: {
+    params: {
+      to: z5.union([
+        z5.tuple([
+          z5.array(AddressZod2)
+        ]),
+        z5.tuple([
+          z5.array(AddressZod2),
+          z5.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ]),
+      from: z5.union([
+        z5.tuple([
+          z5.array(AddressZod2)
+        ]),
+        z5.tuple([
+          z5.array(AddressZod2),
+          z5.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: z5.record(AddressZod2, BigIntToJsonZod2),
+      from: z5.record(AddressZod2, JsonToBigIntZod2)
+    }
+  },
+  xyoViewer_accountsBalancesHistory: {
+    params: {
+      to: z5.union([
+        z5.tuple([
+          z5.array(AddressZod2)
+        ]),
+        z5.tuple([
+          z5.array(AddressZod2),
+          z5.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ]),
+      from: z5.union([
+        z5.tuple([
+          z5.array(AddressZod2)
+        ]),
+        z5.tuple([
+          z5.array(AddressZod2),
+          z5.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: z5.record(AddressZod2, AccountBalanceHistoryItemZod),
+      from: z5.record(AddressZod2, AccountBalanceHistoryItemZod)
     }
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z20.tuple([
+      to: z5.tuple([
         TransferPairZod
       ]),
-      from: z20.tuple([
+      from: z5.tuple([
         TransferPairZod
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z20.tuple([
+      to: z5.tuple([
         TransferPairZod
       ]),
-      from: z20.tuple([
+      from: z5.tuple([
         TransferPairZod
       ])
     },
     result: {
-      to: z20.array(z20.tuple([
-        WithHashMetaZod(BlockBoundWitnessZod),
-        WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-        WithHashMetaZod(TransferZod)
-      ])),
-      from: z20.array(z20.tuple([
-        WithHashMetaZod(BlockBoundWitnessZod),
-        WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-        WithHashMetaZod(TransferZod)
-      ]))
+      to: z5.array(AccountBalanceHistoryItemZod),
+      from: z5.array(AccountBalanceHistoryItemZod)
     }
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.tuple([
+        AddressZod2
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.tuple([
+        AddressZod2
       ])
     },
     result: {
-      to: BigIntToJsonZod3,
-      from: JsonToBigIntZod3
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z20.tuple([
-        AddressZod6,
-        BlockRangeZod2.optional()
+      to: z5.tuple([
+        AddressZod2,
+        BlockRangeZod.optional()
       ]),
-      from: z20.tuple([
-        AddressZod6,
-        BlockRangeZod2.optional()
+      from: z5.tuple([
+        AddressZod2,
+        BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z20.array(z20.tuple([
-        WithHashMetaZod(BlockBoundWitnessZod),
-        WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-        WithHashMetaZod(TransferZod)
-      ])),
-      from: z20.array(z20.tuple([
-        WithHashMetaZod(BlockBoundWitnessZod),
-        WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-        WithHashMetaZod(TransferZod)
-      ]))
+      to: z5.array(AccountBalanceHistoryItemZod),
+      from: z5.array(AccountBalanceHistoryItemZod)
     }
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z20.tuple([
+      to: z5.tuple([
         HashToJsonZod2
       ]),
-      from: z20.tuple([
+      from: z5.tuple([
         JsonToHashZod2
       ])
     },
@@ -1091,11 +821,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z20.tuple([
-        z20.number()
+      to: z5.tuple([
+        z5.number()
       ]),
-      from: z20.tuple([
-        z20.number()
+      from: z5.tuple([
+        z5.number()
       ])
     },
     result: {
@@ -1105,48 +835,48 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z20.tuple([
-        HashZod3,
-        z20.number().optional()
+      to: z5.tuple([
+        HashZod,
+        z5.number().optional()
       ]),
-      from: z20.tuple([
-        HashZod3,
-        z20.number().optional()
+      from: z5.tuple([
+        HashZod,
+        z5.number().optional()
       ])
     },
     result: {
-      to: z20.array(SignedHydratedBlockZod),
-      from: z20.array(SignedHydratedBlockZod)
+      to: z5.array(SignedHydratedBlockZod),
+      from: z5.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z5.array(z5.any()).length(0).optional(),
+      from: z5.array(z5.any()).length(0).optional()
     },
     result: {
-      to: AddressZod6,
-      from: AddressZod6
+      to: AddressZod2,
+      from: AddressZod2
     }
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z20.tuple([
-        BlockNumberZod3
+      to: z5.tuple([
+        BlockNumberZod2
       ]),
-      from: z20.tuple([
-        BlockNumberZod3
+      from: z5.tuple([
+        BlockNumberZod2
       ])
     },
     result: {
-      to: AddressZod6,
-      from: AddressZod6
+      to: AddressZod2,
+      from: AddressZod2
     }
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z5.array(z5.any()).length(0).optional(),
+      from: z5.array(z5.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -1155,43 +885,43 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z5.array(z5.any()).length(0).optional(),
+      from: z5.array(z5.any()).length(0).optional()
     },
     result: {
-      to: HashZod3,
-      from: HashZod3
+      to: HashZod,
+      from: HashZod
     }
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z5.array(z5.any()).length(0).optional(),
+      from: z5.array(z5.any()).length(0).optional()
     },
     result: {
-      to: XL1BlockNumberZod2,
-      from: XL1BlockNumberZod2
+      to: XL1BlockNumberZod,
+      from: XL1BlockNumberZod
     }
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z5.array(z5.any()).length(0).optional(),
+      from: z5.array(z5.any()).length(0).optional()
     },
     result: {
-      to: z20.record(z20.number(), AddressZod6),
-      from: z20.record(z20.number(), AddressZod6)
+      to: z5.record(z5.number(), AddressZod2),
+      from: z5.record(z5.number(), AddressZod2)
     }
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z20.tuple([
-        AddressZod6,
-        z20.number()
+      to: z5.tuple([
+        AddressZod2,
+        z5.number()
       ]),
-      from: z20.tuple([
-        AddressZod6,
-        z20.number()
+      from: z5.tuple([
+        AddressZod2,
+        z5.number()
       ])
     },
     result: {
@@ -1201,11 +931,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z20.tuple([
-        z20.number()
+      to: z5.tuple([
+        z5.number()
       ]),
-      from: z20.tuple([
-        z20.number()
+      from: z5.tuple([
+        z5.number()
       ])
     },
     result: {
@@ -1215,76 +945,76 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.tuple([
+        AddressZod2
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.tuple([
+        AddressZod2
       ])
     },
     result: {
-      to: z20.array(StakeToJsonZod),
-      from: z20.array(JsonToStakeZod)
+      to: z5.array(StakeToJsonZod),
+      from: z5.array(JsonToStakeZod)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z20.tuple([
-        AddressZod6
+      to: z5.tuple([
+        AddressZod2
       ]),
-      from: z20.tuple([
-        AddressZod6
+      from: z5.tuple([
+        AddressZod2
       ])
     },
     result: {
-      to: z20.array(StakeToJsonZod),
-      from: z20.array(JsonToStakeZod)
+      to: z5.array(StakeToJsonZod),
+      from: z5.array(JsonToStakeZod)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z20.tuple([
-        HashZod3,
-        z20.number()
+      to: z5.tuple([
+        HashZod,
+        z5.number()
       ]),
-      from: z20.tuple([
-        HashZod3,
-        z20.number()
+      from: z5.tuple([
+        HashZod,
+        z5.number()
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod.nullable(),
-      from: SignedHydratedTransactionZod.nullable()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z20.tuple([
-        z20.number(),
-        z20.number()
+      to: z5.tuple([
+        z5.number(),
+        z5.number()
       ]),
-      from: z20.tuple([
-        z20.number(),
-        z20.number()
+      from: z5.tuple([
+        z5.number(),
+        z5.number()
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod.nullable(),
-      from: SignedHydratedTransactionZod.nullable()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z20.tuple([
-        HashZod3
+      to: z5.tuple([
+        HashZod
       ]),
-      from: z20.tuple([
-        HashZod3
+      from: z5.tuple([
+        HashZod
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod.nullable(),
-      from: SignedHydratedTransactionZod.nullable()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   }
 };
@@ -1299,391 +1029,396 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z21 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z21.undefined()) => z21.object({
-  id: z21.union([
-    z21.string(),
-    z21.number()
+import * as z6 from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z6.undefined()) => z6.object({
+  id: z6.union([
+    z6.string(),
+    z6.number()
   ]),
-  jsonrpc: z21.literal(jsonrpc),
-  method: z21.literal(methodName),
+  jsonrpc: z6.literal(jsonrpc),
+  method: z6.literal(methodName),
   params: paramsSchema
 }), "createRequestSchema");
 
 // src/types/schema/createResponseSchema.ts
-import * as z22 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z22.undefined()) => z22.object({
-  id: z22.union([
-    z22.string(),
-    z22.number()
+import * as z7 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z7.undefined()) => z7.object({
+  id: z7.union([
+    z7.string(),
+    z7.number()
   ]),
-  jsonrpc: z22.literal(jsonrpc),
+  jsonrpc: z7.literal(jsonrpc),
   result: resultSchema
 }), "createResponseSchema");
 
 // src/types/schema/DataLakeViewerRpcSchema.ts
-import { HashZod as HashZod4 } from "@xylabs/sdk-js";
-import { PayloadZod as PayloadZod2 } from "@xyo-network/payload-model";
-import * as z23 from "zod";
+import { HashZod as HashZod2 } from "@xylabs/sdk-js";
+import { PayloadZod } from "@xyo-network/payload-model";
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z8 from "zod";
 var DataLakeViewerRpcSchemas = {
   dataLakeViewer_get: {
     params: {
-      to: z23.tuple([
-        HashZod4
+      to: z8.tuple([
+        HashZod2
       ]),
-      from: z23.tuple([
-        HashZod4
+      from: z8.tuple([
+        HashZod2
       ])
     },
     result: {
-      to: z23.union([
-        PayloadZod2,
+      to: z8.union([
+        PayloadZod,
         ArrayBufferToJsonZod
       ]).optional(),
-      from: z23.union([
-        PayloadZod2,
+      from: z8.union([
+        PayloadZod,
         JsonToArrayBufferZod
       ]).optional()
     }
   },
   dataLakeViewer_getMany: {
     params: {
-      to: z23.tuple([
-        z23.array(HashZod4)
+      to: z8.tuple([
+        z8.array(HashZod2)
       ]),
-      from: z23.tuple([
-        z23.array(HashZod4)
+      from: z8.tuple([
+        z8.array(HashZod2)
       ])
     },
     result: {
-      to: z23.array(z23.union([
-        PayloadZod2,
+      to: z8.array(z8.union([
+        PayloadZod,
         ArrayBufferToJsonZod
       ])),
-      from: z23.array(z23.union([
-        PayloadZod2,
+      from: z8.array(z8.union([
+        PayloadZod,
         JsonToArrayBufferZod
       ]))
     }
   },
   dataLakeViewer_has: {
     params: {
-      to: z23.tuple([
-        HashZod4
+      to: z8.tuple([
+        HashZod2
       ]),
-      from: z23.tuple([
-        HashZod4
+      from: z8.tuple([
+        HashZod2
       ])
     },
     result: {
-      to: z23.boolean(),
-      from: z23.boolean()
+      to: z8.boolean(),
+      from: z8.boolean()
     }
   }
 };
 
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
-import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
-import z24 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod3 } from "@xylabs/sdk-js";
+import { asAttoXL1 } from "@xyo-network/xl1-protocol";
+import { RewardsRangeOptionsZod } from "@xyo-network/xl1-protocol-sdk";
+import z9 from "zod";
 var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z24.tuple([
+      from: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
+      to: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z24.record(z24.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
-      to: z24.record(z24.number(), BigIntToJsonZod4)
+      from: z9.record(z9.number(), JsonToBigIntZod3.transform((val) => asAttoXL1(val))),
+      to: z9.record(z9.number(), BigIntToJsonZod3)
     }
   },
   networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      from: z24.tuple([
+      from: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
+      to: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z24.record(z24.number(), JsonToBigIntZod4)
+      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z9.record(z9.number(), JsonToBigIntZod3)
     }
   },
   networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      from: z24.tuple([
+      from: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
+      to: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z24.record(z24.number(), JsonToBigIntZod4)
+      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z9.record(z9.number(), JsonToBigIntZod3)
     }
   },
   networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      from: z24.tuple([
+      from: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
+      to: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z24.record(z24.number(), JsonToBigIntZod4)
+      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z9.record(z9.number(), JsonToBigIntZod3)
     }
   },
   networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      from: z24.tuple([
+      from: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z24.tuple([
+      to: z9.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z24.record(z24.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
-      to: z24.record(z24.number(), JsonToBigIntZod4)
+      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
+      to: z9.record(z9.number(), JsonToBigIntZod3)
     }
   }
 };
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-import { AddressZod as AddressZod7, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
-import z25 from "zod";
+import { AddressZod as AddressZod3, BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
+import { RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol-sdk";
+import z10 from "zod";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      from: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      to: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z25.record(AddressZod7, BigIntToJsonZod5),
-      to: z25.record(AddressZod7, JsonToBigIntZod5)
+      from: z10.record(AddressZod3, BigIntToJsonZod4),
+      to: z10.record(AddressZod3, JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      from: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      to: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z25.record(AddressZod7, BigIntToJsonZod5),
-      to: z25.record(AddressZod7, JsonToBigIntZod5)
+      from: z10.record(AddressZod3, BigIntToJsonZod4),
+      to: z10.record(AddressZod3, JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      from: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      to: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z25.record(AddressZod7, BigIntToJsonZod5),
-      to: z25.record(AddressZod7, JsonToBigIntZod5)
+      from: z10.record(AddressZod3, BigIntToJsonZod4),
+      to: z10.record(AddressZod3, JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      from: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      to: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z25.record(AddressZod7, BigIntToJsonZod5),
-      to: z25.record(AddressZod7, JsonToBigIntZod5)
+      from: z10.record(AddressZod3, BigIntToJsonZod4),
+      to: z10.record(AddressZod3, JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      from: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ]),
-      to: z25.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z10.tuple([
+        RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z25.record(AddressZod7, BigIntToJsonZod5),
-      to: z25.record(AddressZod7, JsonToBigIntZod5)
+      from: z10.record(AddressZod3, BigIntToJsonZod4),
+      to: z10.record(AddressZod3, JsonToBigIntZod4)
     }
   }
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
-import { AddressZod as AddressZod8, BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
-import z26 from "zod";
+import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
+import { RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol-sdk";
+import z11 from "zod";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      from: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ]),
-      to: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z26.record(AddressZod8, BigIntToJsonZod6),
-      to: z26.record(AddressZod8, JsonToBigIntZod6)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      from: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ]),
-      to: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z26.record(AddressZod8, BigIntToJsonZod6),
-      to: z26.record(AddressZod8, JsonToBigIntZod6)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      from: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ]),
-      to: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z26.record(AddressZod8, BigIntToJsonZod6),
-      to: z26.record(AddressZod8, JsonToBigIntZod6)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStepViewer_total: {
     params: {
-      from: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ]),
-      to: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z26.record(AddressZod8, BigIntToJsonZod6),
-      to: z26.record(AddressZod8, JsonToBigIntZod6)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      from: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ]),
-      to: z26.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z11.tuple([
+        RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z26.record(AddressZod8, BigIntToJsonZod6),
-      to: z26.record(AddressZod8, JsonToBigIntZod6)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   }
 };
 
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/sdk-js";
-import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
-import * as z27 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
+import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
+import { RewardsRangeOptionsZod as RewardsRangeOptionsZod4 } from "@xyo-network/xl1-protocol-sdk";
+import * as z12 from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      to: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod7
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
   networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      from: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      to: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod7
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
   networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      from: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      to: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod7
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
   networkStakingStepRewardsTotalViewer_total: {
     params: {
-      from: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      to: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod7
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   },
   networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      from: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ]),
-      to: z27.tuple([
-        RewardsRangeOptionsZod.optional()
+      to: z12.tuple([
+        RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod7
+      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod6
     }
   }
 };
@@ -1693,70 +1428,71 @@ var NetworkStakingStepRewardsViewerRpcSchemas = {};
 
 // src/types/schema/TimeSyncViewerRpcSchema.ts
 import { TimePayloadZod } from "@xyo-network/xl1-protocol";
-import * as z28 from "zod";
+import { TimeDomainZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z13 from "zod";
 var TimeSyncViewerRpcSchemas = {
   timeSyncViewer_convertTime: {
     params: {
-      from: z28.tuple([
+      from: z13.tuple([
         TimeDomainZod,
         TimeDomainZod,
-        z28.number()
+        z13.number()
       ]),
-      to: z28.tuple([
+      to: z13.tuple([
         TimeDomainZod,
         TimeDomainZod,
-        z28.number()
+        z13.number()
       ])
     },
     result: {
-      from: z28.number(),
-      to: z28.number()
+      from: z13.number(),
+      to: z13.number()
     }
   },
   timeSyncViewer_currentTime: {
     params: {
-      from: z28.tuple([
+      from: z13.tuple([
         TimeDomainZod
       ]),
-      to: z28.tuple([
+      to: z13.tuple([
         TimeDomainZod
       ])
     },
     result: {
-      from: z28.tuple([
+      from: z13.tuple([
         TimeDomainZod,
-        z28.number()
+        z13.number()
       ]),
-      to: z28.tuple([
+      to: z13.tuple([
         TimeDomainZod,
-        z28.number()
+        z13.number()
       ])
     }
   },
   timeSyncViewer_currentTimeAndHash: {
     params: {
-      from: z28.tuple([
+      from: z13.tuple([
         TimeDomainZod
       ]),
-      to: z28.tuple([
+      to: z13.tuple([
         TimeDomainZod
       ])
     },
     result: {
-      from: z28.tuple([
-        z28.number(),
-        z28.nullable(z28.string())
+      from: z13.tuple([
+        z13.number(),
+        z13.nullable(z13.string())
       ]),
-      to: z28.tuple([
-        z28.number(),
-        z28.nullable(z28.string())
+      to: z13.tuple([
+        z13.number(),
+        z13.nullable(z13.string())
       ])
     }
   },
   timeSyncViewer_currentTimePayload: {
     params: {
-      from: z28.tuple([]),
-      to: z28.tuple([])
+      from: z13.tuple([]),
+      to: z13.tuple([])
     },
     result: {
       from: TimePayloadZod,
@@ -2018,9 +1754,8 @@ var JsonRpcTimeSyncViewer = class extends JsonRpcTimeSyncViewerMethods {
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { isHash } from "@xylabs/sdk-js";
-import { isDefined } from "@xylabs/sdk-js";
-import { asAttoXL1 as asAttoXL14, asHydratedBlock } from "@xyo-network/xl1-protocol";
+import { isDefined, isHash } from "@xylabs/sdk-js";
+import { asAttoXL1 as asAttoXL13, asHydratedBlock } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
@@ -2034,10 +1769,22 @@ var JsonRpcXyoViewer = class {
   get networkStakeViewer() {
     return this.providers?.networkStakeViewer;
   }
-  async accountBalance(address) {
-    return asAttoXL14(await this.transport.sendRequest("xyoViewer_accountBalance", [
+  async accountBalance(address, headOrRange) {
+    if (isDefined(headOrRange)) {
+      if (isHash(headOrRange)) {
+        return await this.transport.sendRequest("xyoViewer_accountBalance", [
+          address,
+          headOrRange
+        ]);
+      }
+      return await this.transport.sendRequest("xyoViewer_accountBalance", [
+        address,
+        headOrRange
+      ]);
+    }
+    return await this.transport.sendRequest("xyoViewer_accountBalance", [
       address
-    ]));
+    ]);
   }
   async accountBalanceHistory(address, headOrRange) {
     if (isDefined(headOrRange)) {
@@ -2056,6 +1803,12 @@ var JsonRpcXyoViewer = class {
       address
     ]);
   }
+  accountsBalances(address, headOrRange) {
+    throw new Error("Method not implemented.");
+  }
+  accountsBalancesHistory(address, headOrRange) {
+    throw new Error("Method not implemented.");
+  }
   async blockByHash(hash) {
     return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByHash", [
       hash
@@ -2234,7 +1987,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async transferBalance(address) {
-    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferBalance", [
+    return asAttoXL13(await this.transport.sendRequest("xyoViewer_transferBalance", [
       address
     ]));
   }
@@ -2242,7 +1995,7 @@ var JsonRpcXyoViewer = class {
     throw new Error("Method not implemented.");
   }
   async transferPairBalance(pair) {
-    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
+    return asAttoXL13(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
       pair
     ]));
   }
@@ -2376,31 +2129,10 @@ var RpcXyoSigner = class {
 };
 export {
   AllRpcSchemas,
-  AnyBoundWitnessZod,
-  AnySignedBoundWitnessWithStorageMetaZod,
-  AnySignedBoundWitnessZod,
-  AnyUnsignedBoundWitnessZod,
-  ArrayBufferToJsonZod,
-  AttoToJsonZod,
-  AttoZod,
-  BlockBoundWitnessZod,
-  BlockDurationZod,
-  BlockEndZod,
-  BlockScriptsZod,
-  BlockStartZod,
-  BoundWitnessZod,
-  CaveatTypesZod,
-  CaveatsZod,
-  ChainZod,
   DataLakeViewerRpcNamespace,
   DataLakeViewerRpcSchemas,
   HttpRpcTransport,
   HttpRpcXyoConnection,
-  HydratedBlockWithStorageMetaZod,
-  HydratedBlockZod,
-  HydratedTransactionZod,
-  InvokerPermissionZod,
-  JsonObjectZod,
   JsonRpcDataLakeViewer,
   JsonRpcDataLakeViewerMethods,
   JsonRpcErrorCodes,
@@ -2413,12 +2145,6 @@ export {
   JsonRpcViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
-  JsonToArrayBufferZod,
-  JsonToAttoZod,
-  JsonToSignedHydratedTransactionZod,
-  JsonToStakeZod,
-  LocalSequenceFromStringZod,
-  LocalSequenceToStringZod,
   MemoryRpcTransport,
   NetworkStakeViewerRpcNamespace,
   NetworkStakeViewerRpcSchemas,
@@ -2433,40 +2159,10 @@ export {
   NetworkStakingStepRewardsViewerRpcNamespace,
   NetworkStakingStepRewardsViewerRpcSchemas,
   NodeXyoRunner,
-  PermissionRequestZod,
-  PermissionZod,
-  QualifiedSequenceFromStringZod,
-  QualifiedSequenceToStringZod,
-  RequestedPermissionZod,
-  RewardsRangeOptionsZod,
   RpcXyoPermissions,
   RpcXyoSigner,
-  SequenceFromStringZod,
-  SequenceToStringZod,
-  SignedBlockBoundWitnessZod,
-  SignedBoundWitnessWithStorageMetaZod,
-  SignedBoundWitnessZod,
-  SignedHydratedBlockToJsonZod,
-  SignedHydratedBlockWithStorageMetaZod,
-  SignedHydratedBlockZod,
-  SignedHydratedTransactionToJsonZod,
-  SignedHydratedTransactionZod,
-  SignedTransactionBoundWitnessZod,
-  StakeToJsonZod,
-  StakeZod,
-  TimeDomainZod,
   TimeSyncViewerRpcNamespace,
   TimeSyncViewerRpcSchemas,
-  TransactionBoundWitnessZod,
-  TransactionFeesBigIntToJsonZod,
-  TransactionFeesBigIntZod,
-  TransactionFeesHexZod,
-  TransactionFeesJsonToBigIntZod,
-  TransferPairZod,
-  UnsignedBoundWitnessWithStorageMetaZod,
-  UnsignedBoundWitnessZod,
-  UnsignedHydratedTransactionZod,
-  WithTransactionFeesZod,
   XyoBaseConnection,
   XyoPermissionsRpcSchemas,
   XyoRunnerRpcSchemas,