@xyo-network/xl1-rpc 1.16.23 → 1.16.24

package/dist/neutral/index.mjs

@@ -121,6 +121,9 @@ import { isError, isUndefinedOrNull } from "@xylabs/sdk-js";
 import { Axios, isAxiosError } from "axios";
 import { v4 } from "uuid";
 
+// src/types/AccountBalanceViewerRpc.ts
+var AccountBalanceViewerRpcNamespace = "accountBalanceViewer";
+
 // src/types/DataLakeViewerRpc.ts
 var DataLakeViewerRpcNamespace = "dataLakeViewer";
 
@@ -169,28 +172,100 @@ var NetworkStakingStepRewardsTotalViewerRpcNamespace = "networkStakingStepReward
 // src/types/NetworkStakingStepRewardsViewerRpc.ts
 var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsViewer";
 
+// src/types/schema/AccountBalanceViewerRpcSchemas.ts
+import { AddressZod, BigIntToJsonZod, HashZod, JsonToBigIntZod } from "@xylabs/sdk-js";
+import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
+import { AccountBalanceHistoryItemZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z from "zod";
+var AccountBalanceViewerRpcSchemas = {
+  accountBalanceViewer_accountsBalances: {
+    params: {
+      to: z.union([
+        z.tuple([
+          z.array(AddressZod)
+        ]),
+        z.tuple([
+          z.array(AddressZod),
+          z.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ]),
+      from: z.union([
+        z.tuple([
+          z.array(AddressZod)
+        ]),
+        z.tuple([
+          z.array(AddressZod),
+          z.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: z.record(AddressZod, BigIntToJsonZod),
+      from: z.record(AddressZod, JsonToBigIntZod)
+    }
+  },
+  accountBalanceViewer_accountsBalancesHistory: {
+    params: {
+      to: z.union([
+        z.tuple([
+          z.array(AddressZod)
+        ]),
+        z.tuple([
+          z.array(AddressZod),
+          z.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ]),
+      from: z.union([
+        z.tuple([
+          z.array(AddressZod)
+        ]),
+        z.tuple([
+          z.array(AddressZod),
+          z.union([
+            XL1BlockRangeZod,
+            HashZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)),
+      from: z.record(AddressZod, z.array(AccountBalanceHistoryItemZod))
+    }
+  }
+};
+
 // src/types/schema/NetworkStakeViewerRpcSchemas.ts
-import { BigIntToJsonZod, JsonToBigIntZod } from "@xylabs/sdk-js";
+import { BigIntToJsonZod as BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/sdk-js";
 import { BlockNumberZod } from "@xyo-network/xl1-protocol";
-import * as z from "zod";
+import * as z2 from "zod";
 var NetworkStakeViewerRpcSchemas = {
   networkStakeViewer_active: {
     params: {
-      from: z.tuple([
+      from: z2.tuple([
         BlockNumberZod.optional()
       ]),
-      to: z.tuple([
+      to: z2.tuple([
         BlockNumberZod.optional()
       ])
     },
     result: {
-      from: z.tuple([
-        JsonToBigIntZod,
-        z.number()
+      from: z2.tuple([
+        JsonToBigIntZod2,
+        z2.number()
       ]),
-      to: z.tuple([
-        BigIntToJsonZod,
-        z.number()
+      to: z2.tuple([
+        BigIntToJsonZod2,
+        z2.number()
       ])
     }
   }
@@ -198,44 +273,44 @@ var NetworkStakeViewerRpcSchemas = {
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
 import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol-sdk";
-import * as z2 from "zod";
+import * as z3 from "zod";
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
-      to: z2.array(z2.any()).length(0),
-      from: z2.array(z2.any()).length(0)
+      to: z3.array(z3.any()).length(0),
+      from: z3.array(z3.any()).length(0)
     },
     result: {
-      to: z2.array(InvokerPermissionZod),
-      from: z2.array(InvokerPermissionZod)
+      to: z3.array(InvokerPermissionZod),
+      from: z3.array(InvokerPermissionZod)
     }
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z2.tuple([
-        z2.array(PermissionRequestZod)
+      to: z3.tuple([
+        z3.array(PermissionRequestZod)
       ]),
-      from: z2.tuple([
-        z2.array(PermissionRequestZod)
+      from: z3.tuple([
+        z3.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z2.array(RequestedPermissionZod),
-      from: z2.array(RequestedPermissionZod)
+      to: z3.array(RequestedPermissionZod),
+      from: z3.array(RequestedPermissionZod)
     }
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z2.tuple([
-        z2.array(PermissionRequestZod)
+      to: z3.tuple([
+        z3.array(PermissionRequestZod)
       ]),
-      from: z2.tuple([
-        z2.array(PermissionRequestZod)
+      from: z3.tuple([
+        z3.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z2.array(RequestedPermissionZod),
-      from: z2.array(RequestedPermissionZod)
+      to: z3.array(RequestedPermissionZod),
+      from: z3.array(RequestedPermissionZod)
     }
   }
 };
@@ -243,14 +318,14 @@ var XyoPermissionsRpcSchemas = {
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod, JsonToHashZod } from "@xylabs/sdk-js";
 import { SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol-sdk";
-import * as z3 from "zod";
+import * as z4 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z3.tuple([
+      to: z4.tuple([
         SignedHydratedTransactionZod
       ]),
-      from: z3.tuple([
+      from: z4.tuple([
         SignedHydratedTransactionZod
       ])
     },
@@ -262,27 +337,27 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { AddressZod } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod2 } from "@xylabs/sdk-js";
 import { asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
 import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol-sdk";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z4.array(z4.any()).length(0).optional(),
-      from: z4.array(z4.any()).length(0).optional()
+      to: z5.array(z5.any()).length(0).optional(),
+      from: z5.array(z5.any()).length(0).optional()
     },
     result: {
-      to: AddressZod,
-      from: AddressZod
+      to: AddressZod2,
+      from: AddressZod2
     }
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z4.tuple([
+      to: z5.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z4.tuple([
+      from: z5.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
@@ -296,521 +371,521 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-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";
+import { AddressZod as AddressZod3, BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod2, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/sdk-js";
+import { BlockNumberZod as BlockNumberZod2, BlockRangeZod, StepIdentityZod, XL1BlockNumberZod, XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
+import { AccountBalanceHistoryItemZod as AccountBalanceHistoryItemZod2, JsonToStakeZod, SignedHydratedBlockZod, SignedHydratedTransactionZod as SignedHydratedTransactionZod3, StakeToJsonZod, TransferPairZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z6 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z5.tuple([
-        AddressZod2
+      to: z6.tuple([
+        AddressZod3
       ]),
-      from: z5.tuple([
-        AddressZod2
+      from: z6.tuple([
+        AddressZod3
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod,
-        AddressZod2
+        AddressZod3
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod,
-        AddressZod2
+        AddressZod3
       ])
     },
     result: {
-      to: z5.record(AddressZod2, BigIntToJsonZod2),
-      from: z5.record(AddressZod2, JsonToBigIntZod2)
+      to: z6.record(AddressZod3, BigIntToJsonZod3),
+      from: z6.record(AddressZod3, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z5.tuple([
-        AddressZod2
+      to: z6.tuple([
+        AddressZod3
       ]),
-      from: z5.tuple([
-        AddressZod2
+      from: z6.tuple([
+        AddressZod3
       ])
     },
     result: {
-      to: z5.record(AddressZod2, BigIntToJsonZod2),
-      from: z5.record(AddressZod2, JsonToBigIntZod2)
+      to: z6.record(AddressZod3, BigIntToJsonZod3),
+      from: z6.record(AddressZod3, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod,
-        AddressZod2
+        AddressZod3
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod,
-        AddressZod2
+        AddressZod3
       ])
     },
     result: {
-      to: z5.tuple([
-        BigIntToJsonZod2,
-        BigIntToJsonZod2
+      to: z6.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ]),
-      from: z5.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z6.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod,
-        AddressZod2
+        AddressZod3
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod,
-        AddressZod2
+        AddressZod3
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z5.tuple([
-        AddressZod2
+      to: z6.tuple([
+        AddressZod3
       ]),
-      from: z5.tuple([
-        AddressZod2
+      from: z6.tuple([
+        AddressZod3
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: z5.record(AddressZod2, BigIntToJsonZod2),
-      from: z5.record(AddressZod2, JsonToBigIntZod2)
+      to: z6.record(AddressZod3, BigIntToJsonZod3),
+      from: z6.record(AddressZod3, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod,
-        z5.number()
+        z6.number()
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod,
-        z5.number()
+        z6.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod,
-        z5.number()
+        z6.number()
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod,
-        z5.number()
+        z6.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: z5.number(),
-      from: z5.number()
+      to: z6.number(),
+      from: z6.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: z5.record(AddressZod2, BigIntToJsonZod2),
-      from: z5.record(AddressZod2, JsonToBigIntZod2)
+      to: z6.record(AddressZod3, BigIntToJsonZod3),
+      from: z6.record(AddressZod3, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         StepIdentityZod,
-        z5.number()
+        z6.number()
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         StepIdentityZod,
-        z5.number()
+        z6.number()
       ])
     },
     result: {
-      to: z5.tuple([
-        BigIntToJsonZod2,
-        BigIntToJsonZod2
+      to: z6.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ]),
-      from: z5.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z6.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z5.tuple([
-        z5.number(),
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      to: z6.tuple([
+        z6.number(),
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ]),
-      from: z5.tuple([
-        z5.number(),
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      from: z6.tuple([
+        z6.number(),
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ])
     },
     result: {
-      to: z5.tuple([
-        BigIntToJsonZod2,
-        BigIntToJsonZod2
+      to: z6.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ]),
-      from: z5.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z6.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ])
     }
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z5.tuple([
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      to: z6.tuple([
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ]),
-      from: z5.tuple([
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      from: z6.tuple([
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z5.tuple([
-        z5.number(),
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      to: z6.tuple([
+        z6.number(),
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ]),
-      from: z5.tuple([
-        z5.number(),
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      from: z6.tuple([
+        z6.number(),
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z5.tuple([
-        z5.number(),
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      to: z6.tuple([
+        z6.number(),
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ]),
-      from: z5.tuple([
-        z5.number(),
-        z5.tuple([
-          z5.number(),
-          z5.number()
+      from: z6.tuple([
+        z6.number(),
+        z6.tuple([
+          z6.number(),
+          z6.number()
         ])
       ])
     },
     result: {
-      to: z5.record(z5.string(), z5.tuple([
-        BigIntToJsonZod2,
-        BigIntToJsonZod2
+      to: z6.record(z6.string(), z6.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ])),
-      from: z5.record(z5.string(), z5.tuple([
-        JsonToBigIntZod2,
-        JsonToBigIntZod2
+      from: z6.record(z6.string(), z6.tuple([
+        JsonToBigIntZod3,
+        JsonToBigIntZod3
       ]))
     }
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z5.union([
-        z5.tuple([
-          AddressZod2
+      to: z6.union([
+        z6.tuple([
+          AddressZod3
         ]),
-        z5.tuple([
-          AddressZod2,
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          AddressZod3,
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ]),
-      from: z5.union([
-        z5.tuple([
-          AddressZod2
+      from: z6.union([
+        z6.tuple([
+          AddressZod3
         ]),
-        z5.tuple([
-          AddressZod2,
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          AddressZod3,
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z5.union([
-        z5.tuple([
-          AddressZod2
+      to: z6.union([
+        z6.tuple([
+          AddressZod3
         ]),
-        z5.tuple([
-          AddressZod2,
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          AddressZod3,
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ]),
-      from: z5.union([
-        z5.tuple([
-          AddressZod2
+      from: z6.union([
+        z6.tuple([
+          AddressZod3
         ]),
-        z5.tuple([
-          AddressZod2,
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          AddressZod3,
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ])
     },
     result: {
-      to: z5.array(AccountBalanceHistoryItemZod),
-      from: z5.array(AccountBalanceHistoryItemZod)
+      to: z6.array(AccountBalanceHistoryItemZod2),
+      from: z6.array(AccountBalanceHistoryItemZod2)
     }
   },
   xyoViewer_accountsBalances: {
     params: {
-      to: z5.union([
-        z5.tuple([
-          z5.array(AddressZod2)
+      to: z6.union([
+        z6.tuple([
+          z6.array(AddressZod3)
         ]),
-        z5.tuple([
-          z5.array(AddressZod2),
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          z6.array(AddressZod3),
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ]),
-      from: z5.union([
-        z5.tuple([
-          z5.array(AddressZod2)
+      from: z6.union([
+        z6.tuple([
+          z6.array(AddressZod3)
         ]),
-        z5.tuple([
-          z5.array(AddressZod2),
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          z6.array(AddressZod3),
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ])
     },
     result: {
-      to: z5.record(AddressZod2, BigIntToJsonZod2),
-      from: z5.record(AddressZod2, JsonToBigIntZod2)
+      to: z6.record(AddressZod3, BigIntToJsonZod3),
+      from: z6.record(AddressZod3, JsonToBigIntZod3)
     }
   },
   xyoViewer_accountsBalancesHistory: {
     params: {
-      to: z5.union([
-        z5.tuple([
-          z5.array(AddressZod2)
+      to: z6.union([
+        z6.tuple([
+          z6.array(AddressZod3)
         ]),
-        z5.tuple([
-          z5.array(AddressZod2),
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          z6.array(AddressZod3),
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ]),
-      from: z5.union([
-        z5.tuple([
-          z5.array(AddressZod2)
+      from: z6.union([
+        z6.tuple([
+          z6.array(AddressZod3)
         ]),
-        z5.tuple([
-          z5.array(AddressZod2),
-          z5.union([
-            XL1BlockRangeZod,
-            HashZod
+        z6.tuple([
+          z6.array(AddressZod3),
+          z6.union([
+            XL1BlockRangeZod2,
+            HashZod2
           ])
         ])
       ])
     },
     result: {
-      to: z5.record(AddressZod2, AccountBalanceHistoryItemZod),
-      from: z5.record(AddressZod2, AccountBalanceHistoryItemZod)
+      to: z6.record(AddressZod3, AccountBalanceHistoryItemZod2),
+      from: z6.record(AddressZod3, AccountBalanceHistoryItemZod2)
     }
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         TransferPairZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         TransferPairZod
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         TransferPairZod
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         TransferPairZod
       ])
     },
     result: {
-      to: z5.array(AccountBalanceHistoryItemZod),
-      from: z5.array(AccountBalanceHistoryItemZod)
+      to: z6.array(AccountBalanceHistoryItemZod2),
+      from: z6.array(AccountBalanceHistoryItemZod2)
     }
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z5.tuple([
-        AddressZod2
+      to: z6.tuple([
+        AddressZod3
       ]),
-      from: z5.tuple([
-        AddressZod2
+      from: z6.tuple([
+        AddressZod3
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z5.tuple([
-        AddressZod2,
+      to: z6.tuple([
+        AddressZod3,
         BlockRangeZod.optional()
       ]),
-      from: z5.tuple([
-        AddressZod2,
+      from: z6.tuple([
+        AddressZod3,
         BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z5.array(AccountBalanceHistoryItemZod),
-      from: z5.array(AccountBalanceHistoryItemZod)
+      to: z6.array(AccountBalanceHistoryItemZod2),
+      from: z6.array(AccountBalanceHistoryItemZod2)
     }
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         HashToJsonZod2
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         JsonToHashZod2
       ])
     },
@@ -821,11 +896,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z5.tuple([
-        z5.number()
+      to: z6.tuple([
+        z6.number()
       ]),
-      from: z5.tuple([
-        z5.number()
+      from: z6.tuple([
+        z6.number()
       ])
     },
     result: {
@@ -835,48 +910,48 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z5.tuple([
-        HashZod,
-        z5.number().optional()
+      to: z6.tuple([
+        HashZod2,
+        z6.number().optional()
       ]),
-      from: z5.tuple([
-        HashZod,
-        z5.number().optional()
+      from: z6.tuple([
+        HashZod2,
+        z6.number().optional()
       ])
     },
     result: {
-      to: z5.array(SignedHydratedBlockZod),
-      from: z5.array(SignedHydratedBlockZod)
+      to: z6.array(SignedHydratedBlockZod),
+      from: z6.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z5.array(z5.any()).length(0).optional(),
-      from: z5.array(z5.any()).length(0).optional()
+      to: z6.array(z6.any()).length(0).optional(),
+      from: z6.array(z6.any()).length(0).optional()
     },
     result: {
-      to: AddressZod2,
-      from: AddressZod2
+      to: AddressZod3,
+      from: AddressZod3
     }
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z5.tuple([
+      to: z6.tuple([
         BlockNumberZod2
       ]),
-      from: z5.tuple([
+      from: z6.tuple([
         BlockNumberZod2
       ])
     },
     result: {
-      to: AddressZod2,
-      from: AddressZod2
+      to: AddressZod3,
+      from: AddressZod3
     }
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z5.array(z5.any()).length(0).optional(),
-      from: z5.array(z5.any()).length(0).optional()
+      to: z6.array(z6.any()).length(0).optional(),
+      from: z6.array(z6.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -885,18 +960,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z5.array(z5.any()).length(0).optional(),
-      from: z5.array(z5.any()).length(0).optional()
+      to: z6.array(z6.any()).length(0).optional(),
+      from: z6.array(z6.any()).length(0).optional()
     },
     result: {
-      to: HashZod,
-      from: HashZod
+      to: HashZod2,
+      from: HashZod2
     }
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z5.array(z5.any()).length(0).optional(),
-      from: z5.array(z5.any()).length(0).optional()
+      to: z6.array(z6.any()).length(0).optional(),
+      from: z6.array(z6.any()).length(0).optional()
     },
     result: {
       to: XL1BlockNumberZod,
@@ -905,23 +980,23 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z5.array(z5.any()).length(0).optional(),
-      from: z5.array(z5.any()).length(0).optional()
+      to: z6.array(z6.any()).length(0).optional(),
+      from: z6.array(z6.any()).length(0).optional()
     },
     result: {
-      to: z5.record(z5.number(), AddressZod2),
-      from: z5.record(z5.number(), AddressZod2)
+      to: z6.record(z6.number(), AddressZod3),
+      from: z6.record(z6.number(), AddressZod3)
     }
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z5.tuple([
-        AddressZod2,
-        z5.number()
+      to: z6.tuple([
+        AddressZod3,
+        z6.number()
       ]),
-      from: z5.tuple([
-        AddressZod2,
-        z5.number()
+      from: z6.tuple([
+        AddressZod3,
+        z6.number()
       ])
     },
     result: {
@@ -931,11 +1006,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z5.tuple([
-        z5.number()
+      to: z6.tuple([
+        z6.number()
       ]),
-      from: z5.tuple([
-        z5.number()
+      from: z6.tuple([
+        z6.number()
       ])
     },
     result: {
@@ -945,41 +1020,41 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z5.tuple([
-        AddressZod2
+      to: z6.tuple([
+        AddressZod3
       ]),
-      from: z5.tuple([
-        AddressZod2
+      from: z6.tuple([
+        AddressZod3
       ])
     },
     result: {
-      to: z5.array(StakeToJsonZod),
-      from: z5.array(JsonToStakeZod)
+      to: z6.array(StakeToJsonZod),
+      from: z6.array(JsonToStakeZod)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z5.tuple([
-        AddressZod2
+      to: z6.tuple([
+        AddressZod3
       ]),
-      from: z5.tuple([
-        AddressZod2
+      from: z6.tuple([
+        AddressZod3
       ])
     },
     result: {
-      to: z5.array(StakeToJsonZod),
-      from: z5.array(JsonToStakeZod)
+      to: z6.array(StakeToJsonZod),
+      from: z6.array(JsonToStakeZod)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z5.tuple([
-        HashZod,
-        z5.number()
+      to: z6.tuple([
+        HashZod2,
+        z6.number()
       ]),
-      from: z5.tuple([
-        HashZod,
-        z5.number()
+      from: z6.tuple([
+        HashZod2,
+        z6.number()
       ])
     },
     result: {
@@ -989,13 +1064,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z5.tuple([
-        z5.number(),
-        z5.number()
+      to: z6.tuple([
+        z6.number(),
+        z6.number()
       ]),
-      from: z5.tuple([
-        z5.number(),
-        z5.number()
+      from: z6.tuple([
+        z6.number(),
+        z6.number()
       ])
     },
     result: {
@@ -1005,11 +1080,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z5.tuple([
-        HashZod
+      to: z6.tuple([
+        HashZod2
       ]),
-      from: z5.tuple([
-        HashZod
+      from: z6.tuple([
+        HashZod2
       ])
     },
     result: {
@@ -1021,6 +1096,7 @@ var XyoViewerRpcSchemas = {
 
 // src/types/schema/AllRpcSchemas.ts
 var AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,
@@ -1029,49 +1105,49 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z6 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z6.undefined()) => z6.object({
-  id: z6.union([
-    z6.string(),
-    z6.number()
-  ]),
-  jsonrpc: z6.literal(jsonrpc),
-  method: z6.literal(methodName),
-  params: paramsSchema
-}), "createRequestSchema");
-
-// src/types/schema/createResponseSchema.ts
 import * as z7 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z7.undefined()) => z7.object({
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z7.undefined()) => z7.object({
   id: z7.union([
     z7.string(),
     z7.number()
   ]),
   jsonrpc: z7.literal(jsonrpc),
+  method: z7.literal(methodName),
+  params: paramsSchema
+}), "createRequestSchema");
+
+// src/types/schema/createResponseSchema.ts
+import * as z8 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z8.undefined()) => z8.object({
+  id: z8.union([
+    z8.string(),
+    z8.number()
+  ]),
+  jsonrpc: z8.literal(jsonrpc),
   result: resultSchema
 }), "createResponseSchema");
 
 // src/types/schema/DataLakeViewerRpcSchema.ts
-import { HashZod as HashZod2 } from "@xylabs/sdk-js";
+import { HashZod as HashZod3 } 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";
+import * as z9 from "zod";
 var DataLakeViewerRpcSchemas = {
   dataLakeViewer_get: {
     params: {
-      to: z8.tuple([
-        HashZod2
+      to: z9.tuple([
+        HashZod3
       ]),
-      from: z8.tuple([
-        HashZod2
+      from: z9.tuple([
+        HashZod3
       ])
     },
     result: {
-      to: z8.union([
+      to: z9.union([
         PayloadZod,
         ArrayBufferToJsonZod
       ]).optional(),
-      from: z8.union([
+      from: z9.union([
         PayloadZod,
         JsonToArrayBufferZod
       ]).optional()
@@ -1079,19 +1155,19 @@ var DataLakeViewerRpcSchemas = {
   },
   dataLakeViewer_getMany: {
     params: {
-      to: z8.tuple([
-        z8.array(HashZod2)
+      to: z9.tuple([
+        z9.array(HashZod3)
       ]),
-      from: z8.tuple([
-        z8.array(HashZod2)
+      from: z9.tuple([
+        z9.array(HashZod3)
       ])
     },
     result: {
-      to: z8.array(z8.union([
+      to: z9.array(z9.union([
         PayloadZod,
         ArrayBufferToJsonZod
       ])),
-      from: z8.array(z8.union([
+      from: z9.array(z9.union([
         PayloadZod,
         JsonToArrayBufferZod
       ]))
@@ -1099,326 +1175,326 @@ var DataLakeViewerRpcSchemas = {
   },
   dataLakeViewer_has: {
     params: {
-      to: z8.tuple([
-        HashZod2
+      to: z9.tuple([
+        HashZod3
       ]),
-      from: z8.tuple([
-        HashZod2
+      from: z9.tuple([
+        HashZod3
       ])
     },
     result: {
-      to: z8.boolean(),
-      from: z8.boolean()
+      to: z9.boolean(),
+      from: z9.boolean()
     }
   }
 };
 
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod3 } from "@xylabs/sdk-js";
+import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
 import { asAttoXL1 } from "@xyo-network/xl1-protocol";
 import { RewardsRangeOptionsZod } from "@xyo-network/xl1-protocol-sdk";
-import z9 from "zod";
+import z10 from "zod";
 var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z9.tuple([
+      from: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), JsonToBigIntZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), BigIntToJsonZod3)
+      from: z10.record(z10.number(), JsonToBigIntZod4.transform((val) => asAttoXL1(val))),
+      to: z10.record(z10.number(), BigIntToJsonZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      from: z9.tuple([
+      from: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z10.record(z10.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z10.record(z10.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      from: z9.tuple([
+      from: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z10.record(z10.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z10.record(z10.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      from: z9.tuple([
+      from: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z10.record(z10.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z10.record(z10.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      from: z9.tuple([
+      from: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z10.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z10.record(z10.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z10.record(z10.number(), JsonToBigIntZod4)
     }
   }
 };
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-import { AddressZod as AddressZod3, BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
 import { RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol-sdk";
-import z10 from "zod";
+import z11 from "zod";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      from: z10.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      from: z10.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      from: z10.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      from: z10.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      from: z10.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z11.record(AddressZod4, BigIntToJsonZod5),
+      to: z11.record(AddressZod4, JsonToBigIntZod5)
     }
   }
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
-import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
+import { AddressZod as AddressZod5, BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
 import { RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol-sdk";
-import z11 from "zod";
+import z12 from "zod";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      from: z11.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z12.record(AddressZod5, BigIntToJsonZod6),
+      to: z12.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      from: z11.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z12.record(AddressZod5, BigIntToJsonZod6),
+      to: z12.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      from: z11.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z12.record(AddressZod5, BigIntToJsonZod6),
+      to: z12.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_total: {
     params: {
-      from: z11.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z12.record(AddressZod5, BigIntToJsonZod6),
+      to: z12.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      from: z11.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z12.record(AddressZod5, BigIntToJsonZod6),
+      to: z12.record(AddressZod5, JsonToBigIntZod6)
     }
   }
 };
 
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
+import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } 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";
+import * as z13 from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z12.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod6
+      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      from: z12.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod6
+      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      from: z12.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod6
+      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_total: {
     params: {
-      from: z12.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod6
+      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z12.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod6
+      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod7
     }
   }
 };
@@ -1429,70 +1505,70 @@ var NetworkStakingStepRewardsViewerRpcSchemas = {};
 // src/types/schema/TimeSyncViewerRpcSchema.ts
 import { TimePayloadZod } from "@xyo-network/xl1-protocol";
 import { TimeDomainZod } from "@xyo-network/xl1-protocol-sdk";
-import * as z13 from "zod";
+import * as z14 from "zod";
 var TimeSyncViewerRpcSchemas = {
   timeSyncViewer_convertTime: {
     params: {
-      from: z13.tuple([
+      from: z14.tuple([
         TimeDomainZod,
         TimeDomainZod,
-        z13.number()
+        z14.number()
       ]),
-      to: z13.tuple([
+      to: z14.tuple([
         TimeDomainZod,
         TimeDomainZod,
-        z13.number()
+        z14.number()
       ])
     },
     result: {
-      from: z13.number(),
-      to: z13.number()
+      from: z14.number(),
+      to: z14.number()
     }
   },
   timeSyncViewer_currentTime: {
     params: {
-      from: z13.tuple([
+      from: z14.tuple([
         TimeDomainZod
       ]),
-      to: z13.tuple([
+      to: z14.tuple([
         TimeDomainZod
       ])
     },
     result: {
-      from: z13.tuple([
+      from: z14.tuple([
         TimeDomainZod,
-        z13.number()
+        z14.number()
       ]),
-      to: z13.tuple([
+      to: z14.tuple([
         TimeDomainZod,
-        z13.number()
+        z14.number()
       ])
     }
   },
   timeSyncViewer_currentTimeAndHash: {
     params: {
-      from: z13.tuple([
+      from: z14.tuple([
         TimeDomainZod
       ]),
-      to: z13.tuple([
+      to: z14.tuple([
         TimeDomainZod
       ])
     },
     result: {
-      from: z13.tuple([
-        z13.number(),
-        z13.nullable(z13.string())
+      from: z14.tuple([
+        z14.number(),
+        z14.nullable(z14.string())
       ]),
-      to: z13.tuple([
-        z13.number(),
-        z13.nullable(z13.string())
+      to: z14.tuple([
+        z14.number(),
+        z14.nullable(z14.string())
       ])
     }
   },
   timeSyncViewer_currentTimePayload: {
     params: {
-      from: z13.tuple([]),
-      to: z13.tuple([])
+      from: z14.tuple([]),
+      to: z14.tuple([])
     },
     result: {
       from: TimePayloadZod,
@@ -1643,6 +1719,56 @@ var NodeXyoRunner = class {
   }, "getPendingArchivist");
 };
 
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
+
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts
+var JsonRpcAccountBalanceViewerMethods = class {
+  static {
+    __name(this, "JsonRpcAccountBalanceViewerMethods");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async accountsBalances(address, headOrRange) {
+    return await this.transport.sendRequest("accountBalanceViewer_accountsBalances", headOrRange ? [
+      address,
+      headOrRange
+    ] : [
+      address
+    ]);
+  }
+  async accountsBalancesHistory(address, headOrRange) {
+    return await this.transport.sendRequest("accountBalanceViewer_accountsBalancesHistory", headOrRange ? [
+      address,
+      headOrRange
+    ] : [
+      address
+    ]);
+  }
+};
+
+// src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts
+var JsonRpcAccountBalanceViewer = class extends JsonRpcAccountBalanceViewerMethods {
+  static {
+    __name(this, "JsonRpcAccountBalanceViewer");
+  }
+  constructor(transport) {
+    super(transport);
+  }
+  async accountBalance(address, headOrRange) {
+    return (await this.accountsBalances([
+      address
+    ], headOrRange))[address] ?? asAttoXL13(0);
+  }
+  async accountBalanceHistory(address, headOrRange) {
+    return (await this.accountsBalancesHistory([
+      address
+    ], headOrRange))[address] ?? [];
+  }
+};
+
 // src/provider/viewer/JsonRpcViewer.ts
 var JsonRpcViewer = class {
   static {
@@ -1755,7 +1881,7 @@ var JsonRpcTimeSyncViewer = class extends JsonRpcTimeSyncViewerMethods {
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
 import { isDefined, isHash } from "@xylabs/sdk-js";
-import { asAttoXL1 as asAttoXL13, asHydratedBlock } from "@xyo-network/xl1-protocol";
+import { asAttoXL1 as asAttoXL14, asHydratedBlock } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
@@ -1987,7 +2113,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async transferBalance(address) {
-    return asAttoXL13(await this.transport.sendRequest("xyoViewer_transferBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferBalance", [
       address
     ]));
   }
@@ -1995,7 +2121,7 @@ var JsonRpcXyoViewer = class {
     throw new Error("Method not implemented.");
   }
   async transferPairBalance(pair) {
-    return asAttoXL13(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
+    return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
       pair
     ]));
   }
@@ -2128,11 +2254,15 @@ var RpcXyoSigner = class {
   }
 };
 export {
+  AccountBalanceViewerRpcNamespace,
+  AccountBalanceViewerRpcSchemas,
   AllRpcSchemas,
   DataLakeViewerRpcNamespace,
   DataLakeViewerRpcSchemas,
   HttpRpcTransport,
   HttpRpcXyoConnection,
+  JsonRpcAccountBalanceViewer,
+  JsonRpcAccountBalanceViewerMethods,
   JsonRpcDataLakeViewer,
   JsonRpcDataLakeViewerMethods,
   JsonRpcErrorCodes,