@xyo-network/xl1-rpc 1.16.23 → 1.16.25

package/dist/neutral/index.mjs

@@ -4,6 +4,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/engine/requestSchemas.ts
 var requestSchemas = {};
 
+// src/engine/rpcMethodHandlersFromAccountBalanceViewer.ts
+var rpcMethodHandlersFromAccountBalanceViewer = /* @__PURE__ */ __name((viewer) => {
+  return {
+    accountBalanceViewer_accountsBalances: /* @__PURE__ */ __name((params) => viewer.accountsBalances(params[0], params[1]), "accountBalanceViewer_accountsBalances"),
+    accountBalanceViewer_accountsBalancesHistory: /* @__PURE__ */ __name((params) => viewer.accountsBalancesHistory(params[0], params[1]), "accountBalanceViewer_accountsBalancesHistory")
+  };
+}, "rpcMethodHandlersFromAccountBalanceViewer");
+
 // src/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts
 var rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer = /* @__PURE__ */ __name((viewer) => {
   return {
@@ -88,6 +96,13 @@ var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection, networ
       ...rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position)
     };
   }
+  const accountBalanceViewer = viewer?.account?.balance;
+  if (accountBalanceViewer) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromAccountBalanceViewer(accountBalanceViewer)
+    };
+  }
   return result;
 }, "rpcMethodHandlersFromConnection");
 
@@ -117,9 +132,13 @@ var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
 
 // src/transport/HttpRpcTransport.ts
 import { axiosJsonConfig } from "@xylabs/axios";
-import { isError, isUndefinedOrNull } from "@xylabs/sdk-js";
+import { isDefined, isError, isUndefinedOrNull } from "@xylabs/sdk-js";
 import { Axios, isAxiosError } from "axios";
 import { v4 } from "uuid";
+import * as z16 from "zod";
+
+// src/types/AccountBalanceViewerRpc.ts
+var AccountBalanceViewerRpcNamespace = "accountBalanceViewer";
 
 // src/types/DataLakeViewerRpc.ts
 var DataLakeViewerRpcNamespace = "dataLakeViewer";
@@ -169,88 +188,160 @@ 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()
       ])
     }
   }
 };
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
-import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol-sdk";
-import * as z2 from "zod";
+import { InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod } from "@xyo-network/xl1-protocol";
+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)
     }
   }
 };
 
 // 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 { SignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
+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,555 +353,552 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { AddressZod } 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 { AddressZod as AddressZod2 } from "@xylabs/sdk-js";
+import { SignedHydratedTransactionWithHashMetaZod, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
+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
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod2,
-      from: SignedHydratedTransactionZod2.transform((data) => asHydratedTransactionWithStorageMeta(data, {
-        required: true
-      }))
+      to: SignedHydratedTransactionWithHashMetaZod,
+      from: SignedHydratedTransactionWithHashMetaZod
     }
   }
 };
 
 // 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, JsonToStakeZod, SignedHydratedBlockZod, SignedHydratedTransactionZod as SignedHydratedTransactionZod2, StakeToJsonZod, StepIdentityZod, TransferPairZod, XL1BlockNumberZod, XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
+import { AccountBalanceHistoryItemZod as AccountBalanceHistoryItemZod2 } 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 +909,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 +923,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 +973,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 +993,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 +1019,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,82 +1033,83 @@ 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: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
     }
   },
   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: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
     }
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z5.tuple([
-        HashZod
+      to: z6.tuple([
+        HashZod2
       ]),
-      from: z5.tuple([
-        HashZod
+      from: z6.tuple([
+        HashZod2
       ])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
     }
   }
 };
 
 // src/types/schema/AllRpcSchemas.ts
 var AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,
@@ -1029,49 +1118,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 { ArrayBufferToJsonZod, JsonToArrayBufferZod } from "@xyo-network/xl1-protocol";
+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 +1168,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 +1188,345 @@ 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/MempoolViewerRpcSchemas.ts
+import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2 } from "@xyo-network/xl1-protocol";
+import { PendingTransactionsOptionsZod } from "@xyo-network/xl1-protocol-sdk";
+import * as z10 from "zod";
+var MempoolViewerRpcSchemas = {
+  mempoolViewer_pendingTransactions: {
+    params: {
+      to: z10.tuple([
+        PendingTransactionsOptionsZod.optional()
+      ]),
+      from: z10.tuple([
+        PendingTransactionsOptionsZod.optional()
+      ])
+    },
+    result: {
+      to: z10.array(SignedHydratedTransactionWithHashMetaZod2),
+      from: z10.array(SignedHydratedTransactionWithHashMetaZod2)
     }
   }
 };
 
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
-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";
+import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/sdk-js";
+import { asAttoXL1, RewardsRangeOptionsZod } from "@xyo-network/xl1-protocol";
+import z11 from "zod";
 var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z9.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), JsonToBigIntZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), BigIntToJsonZod3)
+      from: z11.record(z11.number(), JsonToBigIntZod4.transform((val) => asAttoXL1(val))),
+      to: z11.record(z11.number(), BigIntToJsonZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      from: z9.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z11.record(z11.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z11.record(z11.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      from: z9.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z11.record(z11.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z11.record(z11.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      from: z9.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z11.record(z11.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z11.record(z11.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      from: z9.tuple([
+      from: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z9.tuple([
+      to: z11.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z9.record(z9.number(), BigIntToJsonZod3.transform((val) => asAttoXL1(val))),
-      to: z9.record(z9.number(), JsonToBigIntZod3)
+      from: z11.record(z11.number(), BigIntToJsonZod4.transform((val) => asAttoXL1(val))),
+      to: z11.record(z11.number(), JsonToBigIntZod4)
     }
   }
 };
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-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";
+import { AddressZod as AddressZod4, BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/sdk-js";
+import { RewardsRangeOptionsZod as RewardsRangeOptionsZod2 } from "@xyo-network/xl1-protocol";
+import z12 from "zod";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      from: z10.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z12.record(AddressZod4, BigIntToJsonZod5),
+      to: z12.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      from: z10.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z12.record(AddressZod4, BigIntToJsonZod5),
+      to: z12.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      from: z10.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z12.record(AddressZod4, BigIntToJsonZod5),
+      to: z12.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      from: z10.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z12.record(AddressZod4, BigIntToJsonZod5),
+      to: z12.record(AddressZod4, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      from: z10.tuple([
+      from: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ]),
-      to: z10.tuple([
+      to: z12.tuple([
         RewardsRangeOptionsZod2.optional()
       ])
     },
     result: {
-      from: z10.record(AddressZod3, BigIntToJsonZod4),
-      to: z10.record(AddressZod3, JsonToBigIntZod4)
+      from: z12.record(AddressZod4, BigIntToJsonZod5),
+      to: z12.record(AddressZod4, JsonToBigIntZod5)
     }
   }
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
-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";
+import { AddressZod as AddressZod5, BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/sdk-js";
+import { RewardsRangeOptionsZod as RewardsRangeOptionsZod3 } from "@xyo-network/xl1-protocol";
+import z13 from "zod";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      from: z11.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z13.record(AddressZod5, BigIntToJsonZod6),
+      to: z13.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      from: z11.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z13.record(AddressZod5, BigIntToJsonZod6),
+      to: z13.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      from: z11.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z13.record(AddressZod5, BigIntToJsonZod6),
+      to: z13.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_total: {
     params: {
-      from: z11.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z13.record(AddressZod5, BigIntToJsonZod6),
+      to: z13.record(AddressZod5, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      from: z11.tuple([
+      from: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ]),
-      to: z11.tuple([
+      to: z13.tuple([
         RewardsRangeOptionsZod3.optional()
       ])
     },
     result: {
-      from: z11.record(AddressZod4, BigIntToJsonZod5),
-      to: z11.record(AddressZod4, JsonToBigIntZod5)
+      from: z13.record(AddressZod5, BigIntToJsonZod6),
+      to: z13.record(AddressZod5, JsonToBigIntZod6)
     }
   }
 };
 
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
-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";
+import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/sdk-js";
+import { asAttoXL1 as asAttoXL12, RewardsRangeOptionsZod as RewardsRangeOptionsZod4 } from "@xyo-network/xl1-protocol";
+import * as z14 from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z12.tuple([
+      from: z14.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z14.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: z14.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z14.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: z14.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z14.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: z14.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z14.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: z14.tuple([
         RewardsRangeOptionsZod4.optional()
       ]),
-      to: z12.tuple([
+      to: z14.tuple([
         RewardsRangeOptionsZod4.optional()
       ])
     },
     result: {
-      from: JsonToBigIntZod6.transform((val) => asAttoXL12(val)),
-      to: BigIntToJsonZod6
+      from: JsonToBigIntZod7.transform((val) => asAttoXL12(val)),
+      to: BigIntToJsonZod7
     }
   }
 };
@@ -1427,72 +1535,71 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
 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 { TimeDomainZod, TimePayloadZod } from "@xyo-network/xl1-protocol";
+import * as z15 from "zod";
 var TimeSyncViewerRpcSchemas = {
   timeSyncViewer_convertTime: {
     params: {
-      from: z13.tuple([
+      from: z15.tuple([
         TimeDomainZod,
         TimeDomainZod,
-        z13.number()
+        z15.number()
       ]),
-      to: z13.tuple([
+      to: z15.tuple([
         TimeDomainZod,
         TimeDomainZod,
-        z13.number()
+        z15.number()
       ])
     },
     result: {
-      from: z13.number(),
-      to: z13.number()
+      from: z15.number(),
+      to: z15.number()
     }
   },
   timeSyncViewer_currentTime: {
     params: {
-      from: z13.tuple([
+      from: z15.tuple([
         TimeDomainZod
       ]),
-      to: z13.tuple([
+      to: z15.tuple([
         TimeDomainZod
       ])
     },
     result: {
-      from: z13.tuple([
+      from: z15.tuple([
         TimeDomainZod,
-        z13.number()
+        z15.number()
       ]),
-      to: z13.tuple([
+      to: z15.tuple([
         TimeDomainZod,
-        z13.number()
+        z15.number()
       ])
     }
   },
   timeSyncViewer_currentTimeAndHash: {
     params: {
-      from: z13.tuple([
+      from: z15.tuple([
         TimeDomainZod
       ]),
-      to: z13.tuple([
+      to: z15.tuple([
         TimeDomainZod
       ])
     },
     result: {
-      from: z13.tuple([
-        z13.number(),
-        z13.nullable(z13.string())
+      from: z15.tuple([
+        z15.number(),
+        z15.nullable(z15.string())
       ]),
-      to: z13.tuple([
-        z13.number(),
-        z13.nullable(z13.string())
+      to: z15.tuple([
+        z15.number(),
+        z15.nullable(z15.string())
       ])
     }
   },
   timeSyncViewer_currentTimePayload: {
     params: {
-      from: z13.tuple([]),
-      to: z13.tuple([])
+      from: z15.tuple([]),
+      to: z15.tuple([])
     },
     result: {
       from: TimePayloadZod,
@@ -1509,11 +1616,13 @@ var HttpRpcTransport = class {
   static {
     __name(this, "HttpRpcTransport");
   }
+  _passThrough;
   _rpcUrl;
   _schemas;
-  constructor(rpcUrl, schemas) {
+  constructor(rpcUrl, schemas, passThrough = false) {
     this._rpcUrl = rpcUrl;
     this._schemas = schemas;
+    this._passThrough = passThrough;
   }
   async sendRequest(method, params) {
     return await this.callRpc(this._rpcUrl, this._schemas, method, params);
@@ -1526,15 +1635,19 @@ var HttpRpcTransport = class {
         id,
         method
       };
+      const schema = schemas[method];
       if (params) {
-        body.params = schemas[method].params.to.parse(params);
+        body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z16.json().parse(params) : void 0;
+        if (!isDefined(body.params)) {
+          throw new Error(`RPC method ${String(method)} missing schema`);
+        }
       }
       const res = await new Axios(axiosJsonConfig()).post(url, body);
-      const json = res.data;
-      if (isUndefinedOrNull(json) || json.error) {
-        throw new Error(json.error.message);
+      const json2 = res.data;
+      if (isUndefinedOrNull(json2) || json2.error) {
+        throw new Error(json2.error.message);
       }
-      return schemas[method].result.from.parse(json.result);
+      return schemas[method].result.from.parse(json2.result);
     } catch (ex) {
       let message = isError(ex) ? ex.message : String(ex);
       if (isAxiosError(ex)) {
@@ -1643,6 +1756,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 {
@@ -1754,8 +1917,8 @@ 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 { isDefined as isDefined2, isHash } from "@xylabs/sdk-js";
+import { asAttoXL1 as asAttoXL14, asSignedHydratedBlockWithHashMeta } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
@@ -1770,7 +1933,7 @@ var JsonRpcXyoViewer = class {
     return this.providers?.networkStakeViewer;
   }
   async accountBalance(address, headOrRange) {
-    if (isDefined(headOrRange)) {
+    if (isDefined2(headOrRange)) {
       if (isHash(headOrRange)) {
         return await this.transport.sendRequest("xyoViewer_accountBalance", [
           address,
@@ -1787,7 +1950,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async accountBalanceHistory(address, headOrRange) {
-    if (isDefined(headOrRange)) {
+    if (isDefined2(headOrRange)) {
       if (isHash(headOrRange)) {
         return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
           address,
@@ -1810,12 +1973,12 @@ var JsonRpcXyoViewer = class {
     throw new Error("Method not implemented.");
   }
   async blockByHash(hash) {
-    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByHash", [
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByHash", [
       hash
     ])) ?? null;
   }
   async blockByNumber(blockNumber) {
-    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByNumber", [
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByNumber", [
       blockNumber
     ])) ?? null;
   }
@@ -1823,9 +1986,7 @@ var JsonRpcXyoViewer = class {
     return (await this.transport.sendRequest("xyoViewer_blocksByHash", [
       hash,
       limit
-    ])).map((b) => asHydratedBlock(b, {
-      required: true
-    }));
+    ])).map((b) => asSignedHydratedBlockWithHashMeta(b, true));
   }
   async chainId() {
     return await this.transport.sendRequest("xyoViewer_chainId");
@@ -1836,9 +1997,7 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async currentBlock() {
-    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_currentBlock"), {
-      required: true
-    });
+    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_currentBlock"), true);
   }
   async currentBlockHash() {
     return await this.transport.sendRequest("xyoViewer_currentBlockHash");
@@ -1987,7 +2146,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 +2154,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
     ]));
   }
@@ -2121,18 +2280,21 @@ var RpcXyoSigner = class {
     return await this.transport.sendRequest("xyoSigner_address");
   }
   async signTransaction(tx) {
-    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [
+    return await this.transport.sendRequest("xyoSigner_signTransaction", [
       tx
     ]);
-    return ret;
   }
 };
 export {
+  AccountBalanceViewerRpcNamespace,
+  AccountBalanceViewerRpcSchemas,
   AllRpcSchemas,
   DataLakeViewerRpcNamespace,
   DataLakeViewerRpcSchemas,
   HttpRpcTransport,
   HttpRpcXyoConnection,
+  JsonRpcAccountBalanceViewer,
+  JsonRpcAccountBalanceViewerMethods,
   JsonRpcDataLakeViewer,
   JsonRpcDataLakeViewerMethods,
   JsonRpcErrorCodes,
@@ -2146,6 +2308,7 @@ export {
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
   MemoryRpcTransport,
+  MempoolViewerRpcSchemas,
   NetworkStakeViewerRpcNamespace,
   NetworkStakeViewerRpcSchemas,
   NetworkStakingStepRewardsByPositionViewerRpcNamespace,