@xyo-network/xl1-rpc 1.15.28 → 1.16.1

package/dist/node/index-node.mjs

@@ -163,58 +163,91 @@ var NetworkStakingStepRewardsTotalViewerRpcNamespace = "networkStakingStepReward
 var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsViewer";
 
 // src/types/schema/NetworkStakeViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod3, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/hex";
-import * as z19 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/hex";
+import * as z20 from "zod";
 
 // src/types/schema/common/Address.ts
 import { AddressRegEx, toAddress } from "@xylabs/hex";
 import * as z from "zod";
 var AddressZod = z.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
+// src/types/schema/common/ArrayBuffer.ts
+import * as z2 from "zod";
+function base64Encode(u8) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return Buffer.from(u8).toString("base64");
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < u8.length; i += chunk) {
+    binary += String.fromCharCode(...u8.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+__name(base64Encode, "base64Encode");
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const u8 = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i);
+  return u8;
+}
+__name(base64Decode, "base64Decode");
+var ArrayBufferToJsonZod = z2.instanceof(ArrayBuffer).transform((x) => {
+  const u8 = new Uint8Array(x);
+  return base64Encode(u8);
+});
+var JsonToArrayBufferZod = z2.string().transform((x) => {
+  const u8 = base64Decode(x);
+  return u8.buffer;
+});
+
 // src/types/schema/common/BlockBoundWitness.ts
-import { HexZod as HexZod2 } from "@xylabs/hex";
-import * as z6 from "zod";
+import { asXL1BlockNumber } from "@xyo-network/xl1-protocol";
+import * as z7 from "zod";
 
 // src/types/schema/common/BoundWitness.ts
 import { HashZod, HexZod } from "@xylabs/hex";
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import * as z4 from "zod";
+import * as z5 from "zod";
 
 // src/types/schema/common/Payload.ts
 import { HashToJsonZod } from "@xylabs/hex";
-import * as z3 from "zod";
+import * as z4 from "zod";
 
 // src/types/schema/common/Sequence.ts
 import { HexRegExMinMax, toHex } from "@xylabs/hex";
 import { SequenceConstants } from "@xyo-network/payload-model";
-import * as z2 from "zod";
+import * as z3 from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z2.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z2.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z3.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z3.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z2.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z2.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z2.union([
+var QualifiedSequenceToStringZod = z3.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z3.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z3.union([
   LocalSequenceToStringZod,
   QualifiedSequenceToStringZod
 ]);
-var SequenceFromStringZod = z2.union([
+var SequenceFromStringZod = z3.union([
   LocalSequenceFromStringZod,
   QualifiedSequenceFromStringZod
 ]);
 
 // src/types/schema/common/Payload.ts
-var StorageMetaZod = z3.object({
+var StorageMetaZod = z4.object({
   _hash: HashToJsonZod,
   _dataHash: HashToJsonZod,
   _sequence: SequenceToStringZod
 });
-var SchemaZod = z3.string();
-var PayloadZod = z3.object({
+var SchemaZod = z4.string();
+var PayloadZod = z4.object({
   schema: SchemaZod
-}).catchall(z3.any());
+}).catchall(z4.any());
 var PayloadWithStorageMetaZod = PayloadZod.extend(StorageMetaZod.shape);
-var AnyPayloadZod = PayloadZod.catchall(z3.json());
+var AnyPayloadZod = PayloadZod.catchall(z4.json());
 var AnyPayloadWithStorageMetaZod = AnyPayloadZod.extend(StorageMetaZod.shape);
 function WithStorageMetaZod(valueZod) {
   return StorageMetaZod.extend(valueZod.shape);
@@ -222,54 +255,57 @@ function WithStorageMetaZod(valueZod) {
 __name(WithStorageMetaZod, "WithStorageMetaZod");
 
 // src/types/schema/common/BoundWitness.ts
-var BoundWitnessRequiredFieldsZod = z4.object({
-  addresses: z4.array(AddressZod),
-  payload_hashes: z4.array(HashZod),
-  payload_schemas: z4.array(SchemaZod),
-  previous_hashes: z4.array(HashZod.nullable())
+var BoundWitnessRequiredFieldsZod = z5.object({
+  addresses: z5.array(AddressZod),
+  payload_hashes: z5.array(HashZod),
+  payload_schemas: z5.array(SchemaZod),
+  previous_hashes: z5.array(HashZod.nullable())
 });
-var BoundWitnessMetaZod = z4.object({
+var BoundWitnessMetaZod = z5.object({
   $destination: AddressZod.optional(),
   $sourceQuery: HashZod.optional(),
-  $signatures: z4.array(z4.union([
+  $signatures: z5.array(z5.union([
     HexZod,
-    z4.null()
+    z5.null()
   ]))
 });
 var BoundWitnessZod = PayloadZod.extend({
-  schema: z4.literal(BoundWitnessSchema)
+  schema: z5.literal(BoundWitnessSchema)
 }).extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape).refine((data) => data.$signatures.length === data.addresses.length, {
   message: "$signatures length must equal addresses length"
 });
-var AnyBoundWitnessZod = BoundWitnessZod.catchall(z4.any());
+var AnyBoundWitnessZod = BoundWitnessZod.catchall(z5.any());
 var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), {
   message: "all $signatures must be null"
 });
-var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z4.any());
-var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape);
+var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z5.any());
+var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape).safeExtend(StorageMetaZod.shape);
 var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), {
   message: "all $signatures must not be null"
 });
 var SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod;
-var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z4.any());
-var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z4.any());
+var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z5.any());
+var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z5.any());
 
 // src/types/schema/common/Chain.ts
 import { AddressRegEx as AddressRegEx2, toAddress as toAddress2 } from "@xylabs/hex";
-import * as z5 from "zod";
-var ChainZod = z5.string().toLowerCase().regex(AddressRegEx2).transform((v) => toAddress2(v));
+import * as z6 from "zod";
+var ChainZod = z6.string().toLowerCase().regex(AddressRegEx2).transform((v) => toAddress2(v));
 
 // src/types/schema/common/BlockBoundWitness.ts
-var BlockNumberZod = z6.number().int().nonnegative();
-var BlockBoundWitnessFieldsZod = z6.object({
-  block: BlockNumberZod,
+var BlockNumberZod = z7.number().int().nonnegative();
+var XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber);
+var HexZod2 = z7.string().regex(/^[0-9a-f]+$/);
+var HashZod2 = HexZod2.transform((v) => v);
+var BlockBoundWitnessFieldsZod = z7.object({
+  block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: HexZod2.nullable(),
-  protocol: z6.number().optional(),
-  step_hashes: z6.array(HexZod2).optional()
+  previous: HashZod2.nullable(),
+  protocol: z7.number(),
+  step_hashes: z7.array(HashZod2).optional()
 });
-var BlockBoundWitnessMetaZod = z6.object({
-  $epoch: z6.number()
+var BlockBoundWitnessMetaZod = z7.object({
+  $epoch: z7.number()
 });
 var BlockBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 var BlockBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
@@ -277,57 +313,57 @@ var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.part
 var SignedBlockBoundWitnessWithStorageMetaZod = SignedBoundWitnessWithStorageMetaZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 
 // src/types/schema/common/BlockRange.ts
-import { z as z7 } from "zod";
-var BlockRangeZod = z7.tuple([
-  z7.number().optional(),
-  z7.number().optional()
+import { z as z8 } from "zod";
+var BlockRangeZod = z8.tuple([
+  z8.number().optional(),
+  z8.number().optional()
 ]);
 
 // src/types/schema/common/HydratedBlock.ts
-import * as z8 from "zod";
-var HydratedBlockZod = z8.tuple([
+import * as z9 from "zod";
+var HydratedBlockZod = z9.tuple([
   BlockBoundWitnessZod,
-  z8.array(PayloadZod)
+  z9.array(PayloadZod)
 ]);
-var HydratedBlockWithStorageMetaZod = z8.tuple([
+var HydratedBlockWithStorageMetaZod = z9.tuple([
   BlockBoundWitnessWithStorageMetaZod,
-  z8.array(PayloadWithStorageMetaZod)
+  z9.array(PayloadWithStorageMetaZod)
 ]);
-var SignedHydratedBlockZod = z8.tuple([
+var SignedHydratedBlockZod = z9.tuple([
   SignedBlockBoundWitnessZod,
-  z8.array(PayloadZod)
+  z9.array(PayloadZod)
 ]);
-var SignedHydratedBlockToJsonZod = z8.tuple([
+var SignedHydratedBlockToJsonZod = z9.tuple([
   SignedBlockBoundWitnessZod,
-  z8.array(PayloadZod)
+  z9.array(PayloadZod)
 ]);
-var SignedHydratedBlockWithStorageMetaZod = z8.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z9.tuple([
   SignedBlockBoundWitnessWithStorageMetaZod,
-  z8.array(PayloadWithStorageMetaZod)
+  z9.array(PayloadWithStorageMetaZod)
 ]);
 
 // src/types/schema/common/HydratedTransaction.ts
 import { asAnyPayload } from "@xyo-network/payload-model";
 import { asSignedHydratedTransaction } from "@xyo-network/xl1-protocol";
-import * as z11 from "zod";
+import * as z12 from "zod";
 
 // src/types/schema/common/TransactionBoundWitness.ts
-import * as z10 from "zod";
+import * as z11 from "zod";
 
 // src/types/schema/common/TransactionFees.ts
 import { BigIntToJsonZod, HexZod as HexZod3, JsonToBigIntZod } from "@xylabs/hex";
 import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-import * as z9 from "zod";
-var AttoZod = z9.bigint();
+import * as z10 from "zod";
+var AttoZod = z10.bigint();
 var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
 var AttoToJsonZod = BigIntToJsonZod;
-var TransactionFeesHexZod = z9.object({
+var TransactionFeesHexZod = z10.object({
   base: HexZod3,
   gasLimit: HexZod3,
   gasPrice: HexZod3,
   priority: HexZod3
 });
-var TransactionFeesBigIntZod = z9.object({
+var TransactionFeesBigIntZod = z10.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
@@ -347,23 +383,23 @@ var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) =>
 }));
 
 // src/types/schema/common/TransactionBoundWitness.ts
-var BlockStartZod = z10.object({
+var BlockStartZod = z11.object({
   nbf: BlockNumberZod
 });
-var BlockEndZod = z10.object({
+var BlockEndZod = z11.object({
   exp: BlockNumberZod
 });
-var BlockDurationZod = z10.object({
+var BlockDurationZod = z11.object({
   nbf: BlockNumberZod,
   exp: BlockNumberZod
 });
-var BlockScriptsZod = z10.object({
-  script: z10.array(z10.string()).optional()
+var BlockScriptsZod = z11.object({
+  script: z11.array(z11.string()).optional()
 });
-var WithTransactionFeesZod = z10.object({
+var WithTransactionFeesZod = z11.object({
   fees: TransactionFeesHexZod
 });
-var TransactionBoundWitnessFields = z10.object({
+var TransactionBoundWitnessFields = z11.object({
   chain: ChainZod,
   from: ChainZod
 });
@@ -371,17 +407,17 @@ var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod.pa
 var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
 
 // src/types/schema/common/HydratedTransaction.ts
-var HydratedTransactionZod = z11.tuple([
+var HydratedTransactionZod = z12.tuple([
   TransactionBoundWitnessZod,
-  z11.array(PayloadZod)
+  z12.array(PayloadZod)
 ]);
-var UnsignedHydratedTransactionZod = z11.tuple([
+var UnsignedHydratedTransactionZod = z12.tuple([
   TransactionBoundWitnessZod,
-  z11.array(PayloadZod)
+  z12.array(PayloadZod)
 ]);
-var SignedHydratedTransactionZod = z11.tuple([
+var SignedHydratedTransactionZod = z12.tuple([
   SignedTransactionBoundWitnessZod,
-  z11.array(PayloadZod)
+  z12.array(PayloadZod)
 ]);
 var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
   tx,
@@ -393,79 +429,79 @@ var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(
 ]);
 
 // src/types/schema/common/Json.ts
-import * as z12 from "zod";
-var JsonValueZod = z12.lazy(() => z12.union([
-  z12.string(),
-  z12.number(),
-  z12.boolean(),
-  z12.null(),
-  z12.array(JsonValueZod),
-  z12.record(z12.string(), JsonValueZod)
+import * as z13 from "zod";
+var JsonValueZod = z13.lazy(() => z13.union([
+  z13.string(),
+  z13.number(),
+  z13.boolean(),
+  z13.null(),
+  z13.array(JsonValueZod),
+  z13.record(z13.string(), JsonValueZod)
 ]));
-var JsonObjectZod = z12.record(z12.string(), JsonValueZod);
+var JsonObjectZod = z13.record(z13.string(), JsonValueZod);
 
 // src/types/schema/common/Permission.ts
-import { z as z13 } from "zod";
-var CaveatTypesZod = z13.enum([
+import { z as z14 } from "zod";
+var CaveatTypesZod = z14.enum([
   "chain",
   "expiration",
   "filteredResponse",
   "rateLimit",
   "restrictReturnedAccounts"
 ]);
-var CaveatsZod = z13.object({
+var CaveatsZod = z14.object({
   type: CaveatTypesZod,
-  value: z13.json()
+  value: z14.json()
 });
-var PermissionZod = z13.object({
-  parentCapability: z13.string(),
+var PermissionZod = z14.object({
+  parentCapability: z14.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z13.string()
+  invoker: z14.string()
 });
 var InvokerPermissionZod = PermissionZod.extend({
-  date: z13.number().optional()
+  date: z14.number().optional()
 });
-var PermissionRequestZod = z13.record(z13.string(), z13.record(z13.string(), z13.any()));
-var RequestedPermissionZod = z13.object({
-  parentCapability: z13.string(),
-  date: z13.number().optional()
+var PermissionRequestZod = z14.record(z14.string(), z14.record(z14.string(), z14.any()));
+var RequestedPermissionZod = z14.object({
+  parentCapability: z14.string(),
+  date: z14.number().optional()
 });
 
 // src/types/schema/common/RewardsRangeOptions.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/types/schema/common/StepIdentity.ts
-import * as z14 from "zod";
-var StepIdentityZod = z14.object({
-  block: z14.number(),
-  step: z14.number()
+import * as z15 from "zod";
+var StepIdentityZod = z15.object({
+  block: z15.number(),
+  step: z15.number()
 });
 
 // src/types/schema/common/RewardsRangeOptions.ts
-var RewardsRangeOptionsZod = z15.object({
-  positions: z15.array(z15.number()).optional(),
+var RewardsRangeOptionsZod = z16.object({
+  positions: z16.array(z16.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z15.array(StepIdentityZod).optional(),
-  stakers: z15.array(AddressZod).optional()
+  steps: z16.array(StepIdentityZod).optional(),
+  stakers: z16.array(AddressZod).optional()
 });
 
 // src/types/schema/common/Stake.ts
 import { HexZod as HexZod4 } from "@xylabs/hex";
-import * as z16 from "zod";
-var StakeZod = z16.object({
+import * as z17 from "zod";
+var StakeZod = z17.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z16.number(),
+  addBlock: z17.number(),
   // the unique id for the stake item
-  id: z16.number(),
+  id: z17.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z16.number(),
+  removeBlock: z17.number(),
   // the address that is being staked
   staked: AddressZod,
   // the address that owns the stake
   staker: AddressZod,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z16.number()
+  withdrawBlock: z17.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
@@ -489,20 +525,23 @@ var JsonToStakeZod = StakeZod.extend({
 }));
 
 // src/types/schema/common/Transfer.ts
-import { BigIntToJsonZod as BigIntToJsonZod2 } from "@xylabs/hex";
-import { PayloadZodStrictOfSchema } from "@xyo-network/payload-model";
+import { HexZod as HexZod5 } from "@xylabs/hex";
+import { PayloadZodStrictOfSchema, StorageMetaZod as StorageMetaZod2 } from "@xyo-network/payload-model";
 import { TransferSchema } from "@xyo-network/xl1-protocol";
-import z17 from "zod";
-var TransferFieldsZod = z17.object({
-  epoch: z17.number(),
+import z18 from "zod";
+var TransferFieldsZod = z18.object({
+  $opCodes: z18.array(z18.string()).optional(),
+  context: z18.object().optional(),
+  epoch: z18.number(),
   from: AddressZod,
-  transfers: z17.record(AddressZod, BigIntToJsonZod2)
+  transfers: z18.record(AddressZod, HexZod5)
 });
 var TransferZod = PayloadZodStrictOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
+var TransferZodWithStorageMeta = TransferZod.extend(StorageMetaZod2.shape);
 
 // src/types/schema/common/TransferPair.ts
-import z18 from "zod";
-var TransferPairZod = z18.tuple([
+import z19 from "zod";
+var TransferPairZod = z19.tuple([
   AddressZod,
   AddressZod
 ]);
@@ -511,79 +550,79 @@ var TransferPairZod = z18.tuple([
 var NetworkStakeViewerRpcSchemas = {
   networkStakeViewer_active: {
     params: {
-      from: z19.tuple([
+      from: z20.tuple([
         BlockNumberZod.optional()
       ]),
-      to: z19.tuple([
+      to: z20.tuple([
         BlockNumberZod.optional()
       ])
     },
     result: {
-      from: z19.tuple([
+      from: z20.tuple([
         JsonToBigIntZod2,
-        z19.number()
+        z20.number()
       ]),
-      to: z19.tuple([
-        BigIntToJsonZod3,
-        z19.number()
+      to: z20.tuple([
+        BigIntToJsonZod2,
+        z20.number()
       ])
     }
   }
 };
 
 // src/types/schema/XyoPermissionsRpcSchemas.ts
-import * as z20 from "zod";
+import * as z21 from "zod";
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
-      to: z20.array(z20.any()).length(0),
-      from: z20.array(z20.any()).length(0)
+      to: z21.array(z21.any()).length(0),
+      from: z21.array(z21.any()).length(0)
     },
     result: {
-      to: z20.array(InvokerPermissionZod),
-      from: z20.array(InvokerPermissionZod)
+      to: z21.array(InvokerPermissionZod),
+      from: z21.array(InvokerPermissionZod)
     }
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z20.tuple([
-        z20.array(PermissionRequestZod)
+      to: z21.tuple([
+        z21.array(PermissionRequestZod)
       ]),
-      from: z20.tuple([
-        z20.array(PermissionRequestZod)
+      from: z21.tuple([
+        z21.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z20.array(RequestedPermissionZod),
-      from: z20.array(RequestedPermissionZod)
+      to: z21.array(RequestedPermissionZod),
+      from: z21.array(RequestedPermissionZod)
     }
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z20.tuple([
-        z20.array(PermissionRequestZod)
+      to: z21.tuple([
+        z21.array(PermissionRequestZod)
       ]),
-      from: z20.tuple([
-        z20.array(PermissionRequestZod)
+      from: z21.tuple([
+        z21.array(PermissionRequestZod)
       ])
     },
     result: {
-      to: z20.array(RequestedPermissionZod),
-      from: z20.array(RequestedPermissionZod)
+      to: z21.array(RequestedPermissionZod),
+      from: z21.array(RequestedPermissionZod)
     }
   }
 };
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod as HashToJsonZod2, JsonToHashZod } from "@xylabs/hex";
-import * as z21 from "zod";
+import * as z22 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z21.tuple([
+      to: z22.tuple([
         SignedHydratedTransactionZod
       ]),
-      from: z21.tuple([
+      from: z22.tuple([
         SignedHydratedTransactionZod
       ])
     },
@@ -596,12 +635,12 @@ var XyoRunnerRpcSchemas = {
 
 // src/types/schema/XyoSignerRpcSchemas.ts
 import { asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
       to: AddressZod,
@@ -610,10 +649,10 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z22.tuple([
+      to: z23.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z22.tuple([
+      from: z23.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
@@ -627,86 +666,70 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod4, HashToJsonZod as HashToJsonZod3, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
-import * as z23 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod3, HashZod as HashZod3, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
+import * as z24 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod,
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod,
+        AddressZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod4),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod4),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod,
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod,
+        AddressZod
       ])
     },
     result: {
-      to: z23.tuple([
-        BigIntToJsonZod4,
-        BigIntToJsonZod4
+      to: z24.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -714,193 +737,153 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod,
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          AddressZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod,
+        AddressZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod4),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          z23.number()
-        ])
+      to: z24.tuple([
+        StepIdentityZod,
+        z24.number()
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          z23.number()
-        ])
+      from: z24.tuple([
+        StepIdentityZod,
+        z24.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          z23.number()
-        ])
+      to: z24.tuple([
+        StepIdentityZod,
+        z24.number()
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          z23.number()
-        ])
+      from: z24.tuple([
+        StepIdentityZod,
+        z24.number()
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z23.number(),
-      from: z23.number()
+      to: z24.number(),
+      from: z24.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      to: z24.tuple([
+        StepIdentityZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod
-        ])
+      from: z24.tuple([
+        StepIdentityZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod4),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          z23.number()
-        ])
+      to: z24.tuple([
+        StepIdentityZod,
+        z24.number()
       ]),
-      from: z23.union([
-        z23.tuple([
-          StepIdentityZod,
-          z23.number()
-        ])
+      from: z24.tuple([
+        StepIdentityZod,
+        z24.number()
       ])
     },
     result: {
-      to: z23.tuple([
-        BigIntToJsonZod4,
-        BigIntToJsonZod4
+      to: z24.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -908,31 +891,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          z23.number(),
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      to: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: z23.union([
-        z23.tuple([
-          z23.number(),
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      from: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ])
     },
     result: {
-      to: z23.tuple([
-        BigIntToJsonZod4,
-        BigIntToJsonZod4
+      to: z24.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -940,81 +919,69 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      to: z24.tuple([
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: z23.union([
-        z23.tuple([
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      from: z24.tuple([
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          z23.number(),
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      to: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: z23.union([
-        z23.tuple([
-          z23.number(),
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      from: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          z23.number(),
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      to: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: z23.union([
-        z23.tuple([
-          z23.number(),
-          z23.tuple([
-            z23.number(),
-            z23.number()
-          ])
+      from: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ])
     },
     result: {
-      to: z23.record(z23.string(), z23.tuple([
-        BigIntToJsonZod4,
-        BigIntToJsonZod4
+      to: z24.record(z24.string(), z24.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
       ])),
-      from: z23.record(z23.string(), z23.tuple([
+      from: z24.record(z24.string(), z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ]))
@@ -1022,142 +989,134 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z23.array(z23.tuple([
-        HashZod2,
-        HashZod2,
-        TransferZod
+      to: z24.array(z24.tuple([
+        BlockBoundWitnessZod,
+        TransactionBoundWitnessZod.nullable(),
+        TransferZodWithStorageMeta
       ])),
-      from: z23.array(z23.tuple([
-        HashZod2,
-        HashZod2,
-        TransferZod
+      from: z24.array(z24.tuple([
+        BlockBoundWitnessZod,
+        TransactionBoundWitnessZod.nullable(),
+        TransferZodWithStorageMeta
       ]))
     }
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          TransferPairZod
-        ])
+      to: z24.tuple([
+        TransferPairZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          TransferPairZod
-        ])
+      from: z24.tuple([
+        TransferPairZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          TransferPairZod
-        ])
+      to: z24.tuple([
+        TransferPairZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          TransferPairZod
-        ])
+      from: z24.tuple([
+        TransferPairZod
       ])
     },
     result: {
-      to: z23.array(z23.tuple([
-        HashZod2,
-        HashZod2,
+      to: z24.array(z24.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z24.union([
+          TransactionBoundWitnessZod,
+          z24.null()
+        ]),
         PayloadZod
       ])),
-      from: z23.array(z23.tuple([
-        HashZod2,
-        HashZod2,
+      from: z24.array(z24.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z24.union([
+          TransactionBoundWitnessZod,
+          z24.null()
+        ]),
         PayloadZod
       ]))
     }
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod
       ])
     },
     result: {
-      to: BigIntToJsonZod4,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod3
     }
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      to: z24.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ]),
-      from: z23.union([
-        z23.tuple([
-          AddressZod
-        ])
+      from: z24.tuple([
+        AddressZod,
+        BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z23.array(z23.tuple([
-        HashZod2,
-        HashZod2,
+      to: z24.array(z24.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z24.union([
+          TransactionBoundWitnessZod,
+          z24.null()
+        ]),
         PayloadZod
       ])),
-      from: z23.array(z23.tuple([
-        HashZod2,
-        HashZod2,
+      from: z24.array(z24.tuple([
+        BlockBoundWitnessWithStorageMetaZod,
+        z24.union([
+          TransactionBoundWitnessZod,
+          z24.null()
+        ]),
         PayloadZod
       ]))
     }
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         HashToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToHashZod2
       ])
     },
@@ -1168,11 +1127,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z23.tuple([
-        z23.number()
+      to: z24.tuple([
+        z24.number()
       ]),
-      from: z23.tuple([
-        z23.number()
+      from: z24.tuple([
+        z24.number()
       ])
     },
     result: {
@@ -1182,24 +1141,24 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z23.tuple([
-        HashZod2,
-        z23.number().optional()
+      to: z24.tuple([
+        HashZod3,
+        z24.number().optional()
       ]),
-      from: z23.tuple([
-        HashZod2,
-        z23.number().optional()
+      from: z24.tuple([
+        HashZod3,
+        z24.number().optional()
       ])
     },
     result: {
-      to: z23.array(SignedHydratedBlockZod),
-      from: z23.array(SignedHydratedBlockZod)
+      to: z24.array(SignedHydratedBlockZod),
+      from: z24.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z23.array(z23.any()).length(0).optional(),
-      from: z23.array(z23.any()).length(0).optional()
+      to: z24.array(z24.any()).length(0).optional(),
+      from: z24.array(z24.any()).length(0).optional()
     },
     result: {
       to: AddressZod,
@@ -1208,10 +1167,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         BlockNumberZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         BlockNumberZod
       ])
     },
@@ -1222,8 +1181,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z23.array(z23.any()).length(0).optional(),
-      from: z23.array(z23.any()).length(0).optional()
+      to: z24.array(z24.any()).length(0).optional(),
+      from: z24.array(z24.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -1232,18 +1191,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z23.array(z23.any()).length(0).optional(),
-      from: z23.array(z23.any()).length(0).optional()
+      to: z24.array(z24.any()).length(0).optional(),
+      from: z24.array(z24.any()).length(0).optional()
     },
     result: {
-      to: HashZod2,
-      from: HashZod2
+      to: HashZod3,
+      from: HashZod3
     }
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z23.array(z23.any()).length(0).optional(),
-      from: z23.array(z23.any()).length(0).optional()
+      to: z24.array(z24.any()).length(0).optional(),
+      from: z24.array(z24.any()).length(0).optional()
     },
     result: {
       to: BlockNumberZod,
@@ -1252,23 +1211,23 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z23.array(z23.any()).length(0).optional(),
-      from: z23.array(z23.any()).length(0).optional()
+      to: z24.array(z24.any()).length(0).optional(),
+      from: z24.array(z24.any()).length(0).optional()
     },
     result: {
-      to: z23.record(z23.number(), AddressZod),
-      from: z23.record(z23.number(), AddressZod)
+      to: z24.record(z24.number(), AddressZod),
+      from: z24.record(z24.number(), AddressZod)
     }
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod,
-        z23.number()
+        z24.number()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod,
-        z23.number()
+        z24.number()
       ])
     },
     result: {
@@ -1278,11 +1237,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z23.tuple([
-        z23.number()
+      to: z24.tuple([
+        z24.number()
       ]),
-      from: z23.tuple([
-        z23.number()
+      from: z24.tuple([
+        z24.number()
       ])
     },
     result: {
@@ -1292,55 +1251,55 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakedByStaker: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z23.array(AddressZod),
-      from: z23.array(AddressZod)
+      to: z24.array(AddressZod),
+      from: z24.array(AddressZod)
     }
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z23.array(StakeToJsonZod),
-      from: z23.array(JsonToStakeZod)
+      to: z24.array(StakeToJsonZod),
+      from: z24.array(JsonToStakeZod)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z23.array(StakeToJsonZod),
-      from: z23.array(JsonToStakeZod)
+      to: z24.array(StakeToJsonZod),
+      from: z24.array(JsonToStakeZod)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z23.tuple([
-        HashZod2,
-        z23.number()
+      to: z24.tuple([
+        HashZod3,
+        z24.number()
       ]),
-      from: z23.tuple([
-        HashZod2,
-        z23.number()
+      from: z24.tuple([
+        HashZod3,
+        z24.number()
       ])
     },
     result: {
@@ -1350,13 +1309,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z23.tuple([
-        z23.number(),
-        z23.number()
+      to: z24.tuple([
+        z24.number(),
+        z24.number()
       ]),
-      from: z23.tuple([
-        z23.number(),
-        z23.number()
+      from: z24.tuple([
+        z24.number(),
+        z24.number()
       ])
     },
     result: {
@@ -1366,11 +1325,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z23.tuple([
-        HashZod2
+      to: z24.tuple([
+        HashZod3
       ]),
-      from: z23.tuple([
-        HashZod2
+      from: z24.tuple([
+        HashZod3
       ])
     },
     result: {
@@ -1390,330 +1349,390 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z24 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z24.undefined()) => z24.object({
-  id: z24.union([
-    z24.string(),
-    z24.number()
-  ]),
-  jsonrpc: z24.literal(jsonrpc),
-  method: z24.literal(methodName),
-  params: paramsSchema
-}), "createRequestSchema");
-
-// src/types/schema/createResponseSchema.ts
 import * as z25 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z25.undefined()) => z25.object({
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z25.undefined()) => z25.object({
   id: z25.union([
     z25.string(),
     z25.number()
   ]),
   jsonrpc: z25.literal(jsonrpc),
+  method: z25.literal(methodName),
+  params: paramsSchema
+}), "createRequestSchema");
+
+// src/types/schema/createResponseSchema.ts
+import * as z26 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z26.undefined()) => z26.object({
+  id: z26.union([
+    z26.string(),
+    z26.number()
+  ]),
+  jsonrpc: z26.literal(jsonrpc),
   result: resultSchema
 }), "createResponseSchema");
 
+// src/types/schema/DataLakeViewerRpcSchema.ts
+import { PayloadZod as PayloadZod2 } from "@xyo-network/payload-model";
+import * as z27 from "zod";
+var DataLakeViewerRpcSchemas = {
+  dataLakeViewer_get: {
+    params: {
+      to: z27.tuple([
+        HashZod2
+      ]),
+      from: z27.tuple([
+        HashZod2
+      ])
+    },
+    result: {
+      to: z27.union([
+        PayloadZod2,
+        ArrayBufferToJsonZod
+      ]).optional(),
+      from: z27.union([
+        PayloadZod2,
+        JsonToArrayBufferZod
+      ]).optional()
+    }
+  },
+  dataLakeViewer_getMany: {
+    params: {
+      to: z27.tuple([
+        z27.array(HashZod2)
+      ]),
+      from: z27.tuple([
+        z27.array(HashZod2)
+      ])
+    },
+    result: {
+      to: z27.array(z27.union([
+        PayloadZod2,
+        ArrayBufferToJsonZod
+      ])),
+      from: z27.array(z27.union([
+        PayloadZod2,
+        JsonToArrayBufferZod
+      ]))
+    }
+  },
+  dataLakeViewer_has: {
+    params: {
+      to: z27.tuple([
+        HashZod2
+      ]),
+      from: z27.tuple([
+        HashZod2
+      ])
+    },
+    result: {
+      to: z27.boolean(),
+      from: z27.boolean()
+    }
+  }
+};
+
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/hex";
+import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/hex";
 import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
-import z26 from "zod";
+import z28 from "zod";
 var NetworkStakingStepRewardsByPositionViewerRpcSchemas = {
   networkStakingStepRewardsByPositionViewer_bonus: {
     params: {
-      from: z26.tuple([
+      from: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), BigIntToJsonZod5)
+      from: z28.record(z28.number(), JsonToBigIntZod4.transform((val) => asAttoXL12(val))),
+      to: z28.record(z28.number(), BigIntToJsonZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_claimed: {
     params: {
-      from: z26.tuple([
+      from: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z28.record(z28.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z28.record(z28.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_earned: {
     params: {
-      from: z26.tuple([
+      from: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z28.record(z28.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z28.record(z28.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_total: {
     params: {
-      from: z26.tuple([
+      from: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z28.record(z28.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z28.record(z28.number(), JsonToBigIntZod4)
     }
   },
   networkStakingStepRewardsByPositionViewer_unclaimed: {
     params: {
-      from: z26.tuple([
+      from: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z26.tuple([
+      to: z28.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z26.record(z26.number(), BigIntToJsonZod5.transform((val) => asAttoXL12(val))),
-      to: z26.record(z26.number(), JsonToBigIntZod4)
+      from: z28.record(z28.number(), BigIntToJsonZod4.transform((val) => asAttoXL12(val))),
+      to: z28.record(z28.number(), JsonToBigIntZod4)
     }
   }
 };
 
 // src/types/schema/RewardsByStakerViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/hex";
-import z27 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/hex";
+import z29 from "zod";
 var NetworkStakingStepRewardsByStakerViewerRpcSchemas = {
   networkStakingStepRewardsByStakerViewer_bonus: {
     params: {
-      from: z27.tuple([
+      from: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod6),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z29.record(AddressZod, BigIntToJsonZod5),
+      to: z29.record(AddressZod, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_claimed: {
     params: {
-      from: z27.tuple([
+      from: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod6),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z29.record(AddressZod, BigIntToJsonZod5),
+      to: z29.record(AddressZod, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_earned: {
     params: {
-      from: z27.tuple([
+      from: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod6),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z29.record(AddressZod, BigIntToJsonZod5),
+      to: z29.record(AddressZod, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_total: {
     params: {
-      from: z27.tuple([
+      from: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod6),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z29.record(AddressZod, BigIntToJsonZod5),
+      to: z29.record(AddressZod, JsonToBigIntZod5)
     }
   },
   networkStakingStepRewardsByStakerViewer_unclaimed: {
     params: {
-      from: z27.tuple([
+      from: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z27.tuple([
+      to: z29.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z27.record(AddressZod, BigIntToJsonZod6),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z29.record(AddressZod, BigIntToJsonZod5),
+      to: z29.record(AddressZod, JsonToBigIntZod5)
     }
   }
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/hex";
-import z28 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/hex";
+import z30 from "zod";
 var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
   networkStakingStepRewardsByStepViewer_bonus: {
     params: {
-      from: z28.tuple([
+      from: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod7),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z30.record(AddressZod, BigIntToJsonZod6),
+      to: z30.record(AddressZod, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_claimed: {
     params: {
-      from: z28.tuple([
+      from: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod7),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z30.record(AddressZod, BigIntToJsonZod6),
+      to: z30.record(AddressZod, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_earned: {
     params: {
-      from: z28.tuple([
+      from: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod7),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z30.record(AddressZod, BigIntToJsonZod6),
+      to: z30.record(AddressZod, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_total: {
     params: {
-      from: z28.tuple([
+      from: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod7),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z30.record(AddressZod, BigIntToJsonZod6),
+      to: z30.record(AddressZod, JsonToBigIntZod6)
     }
   },
   networkStakingStepRewardsByStepViewer_unclaimed: {
     params: {
-      from: z28.tuple([
+      from: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z28.tuple([
+      to: z30.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
-      from: z28.record(AddressZod, BigIntToJsonZod7),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z30.record(AddressZod, BigIntToJsonZod6),
+      to: z30.record(AddressZod, JsonToBigIntZod6)
     }
   }
 };
 
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod8, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/hex";
+import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/hex";
 import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
-import * as z29 from "zod";
+import * as z31 from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
       from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod8
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
       from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod8
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
       from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod8
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_total: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
       from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod8
+      to: BigIntToJsonZod7
     }
   },
   networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
     result: {
       from: JsonToBigIntZod7.transform((val) => asAttoXL13(val)),
-      to: BigIntToJsonZod8
+      to: BigIntToJsonZod7
     }
   }
 };
@@ -1768,10 +1787,6 @@ var MemoryXyoClient = class {
   }
 };
 
-// src/provider/connection/HttpRpcXyoConnection.ts
-import { isString as isString2 } from "@xylabs/typeof";
-import { isDataLakeProvider } from "@xyo-network/xl1-protocol";
-
 // src/transport/HttpRpcTransport.ts
 import { AxiosJson } from "@xylabs/axios";
 import { isError, isUndefinedOrNull } from "@xylabs/typeof";
@@ -1858,194 +1873,6 @@ var MemoryRpcTransport = class {
   }
 };
 
-// src/provider/datalake/AbstractXyoDataLake.ts
-import { ObjectHasher } from "@xyo-network/hash";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { isAnyPayload } from "@xyo-network/payload-model";
-import { isHashPayload } from "@xyo-network/xl1-protocol";
-var AbstractXyoDataLake = class {
-  static {
-    __name(this, "AbstractXyoDataLake");
-  }
-  async fetch(hashes, maxDepth = 10) {
-    const results = await this.get(hashes);
-    if (maxDepth > 0) {
-      const hashPayloads = results.filter(isHashPayload);
-      const otherPayloads = results.filter((item) => !isHashPayload(item));
-      const found = await this.fetch(hashPayloads.map((item) => item.hash), maxDepth - 1);
-      const foundHashes = await Promise.all(found.map(async (item) => isAnyPayload(item) ? await PayloadBuilder.hash(item) : ObjectHasher.hashBytes(item)));
-      const notFound = hashPayloads.filter((item) => !foundHashes.includes(item.hash));
-      return [
-        ...otherPayloads,
-        ...found,
-        ...notFound
-      ];
-    }
-    return results;
-  }
-  async trace(hash) {
-    const [result] = await this.get([
-      hash
-    ]);
-    if (isHashPayload(result)) {
-      const [payload, route] = await this.trace(result.hash);
-      return [
-        payload,
-        [
-          result,
-          ...route
-        ]
-      ];
-    }
-    return [
-      result,
-      []
-    ];
-  }
-};
-
-// src/provider/datalake/ArchivistXyoDataLake.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
-var ArchivistXyoDataLake = class extends AbstractXyoDataLake {
-  static {
-    __name(this, "ArchivistXyoDataLake");
-  }
-  _archivist;
-  constructor(archivist) {
-    super();
-    this._archivist = archivist;
-  }
-  async add(items) {
-    const payloads = items.filter(isAnyPayload2);
-    assertEx2(payloads.length === items.length, () => "Some items are not payloads");
-    return await this._archivist.insert(payloads);
-  }
-  async get(hashes) {
-    return await this._archivist.get(hashes);
-  }
-};
-
-// src/provider/datalake/HttpXyoDataLake.ts
-import { isArrayBuffer } from "@xylabs/arraybuffer";
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { AxiosJson as AxiosJson2 } from "@xylabs/axios";
-import { exists } from "@xylabs/exists";
-import { isDefined } from "@xylabs/typeof";
-import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
-import { isHashPayload as isHashPayload2 } from "@xyo-network/xl1-protocol";
-import { Axios } from "axios";
-var HttpXyoDataLake = class extends AbstractXyoDataLake {
-  static {
-    __name(this, "HttpXyoDataLake");
-  }
-  _axiosGet;
-  _axiosInsertBlob;
-  _axiosInsertJson;
-  _endpoint;
-  constructor(endpoint) {
-    super();
-    this._endpoint = endpoint;
-    this._axiosInsertJson = new AxiosJson2({
-      baseURL: endpoint
-    });
-    this._axiosInsertBlob = new Axios({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "Accept": "application/octet-stream"
-      }
-    });
-    this._axiosGet = new Axios({
-      baseURL: endpoint,
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/octet-stream, application/json"
-      }
-    });
-  }
-  get endpoint() {
-    return this._endpoint;
-  }
-  async add(items) {
-    const results = [];
-    for (const item of items) {
-      if (isAnyPayload3(item)) {
-        const result = await this.addPayload(item);
-        if (isAnyPayload3(result)) {
-          results.push(result);
-        } else if (isDefined(result)) {
-          assertEx3(false, () => "Expected result to be a Payload");
-        }
-      } else if (isArrayBuffer(item)) {
-        const result = await this.addArrayBuffer(item);
-        if (isAnyPayload3(result)) {
-          results.push(result);
-        } else if (isDefined(result)) {
-          assertEx3(false, () => "Expected result to be a Payload");
-        }
-      }
-    }
-    return results;
-  }
-  async get(hashes) {
-    return (await Promise.all(hashes.map(async (hash) => {
-      return await this.getOne(hash);
-    }))).filter(exists);
-  }
-  async addArrayBuffer(item) {
-    const result = await this._axiosInsertBlob.post("/insert", item);
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
-    }
-    if (!isArrayBuffer(result.data)) {
-      throw new Error("Invalid response from server (expected a ArrayBuffer)");
-    }
-    return result.data;
-  }
-  async addPayload(item) {
-    const result = await this._axiosInsertJson.post("/insert", item);
-    if (result.status < 200 || result.status >= 300) {
-      throw new Error(`Failed to add items [${result.status}]: ${result.statusText}`);
-    }
-    if (!Array.isArray(result.data) || result.data.length !== 1) {
-      throw new Error("Invalid response from server (expected an Array of Payloads)");
-    }
-    const [response] = result.data;
-    if (!isAnyPayload3(response)) {
-      throw new Error("Invalid response from server (expected a Payload)");
-    }
-    return response;
-  }
-  async fetchOne(hash, maxDepth = Number.MAX_SAFE_INTEGER) {
-    if (maxDepth <= 0) {
-      return void 0;
-    }
-    const result = await this.getOne(hash);
-    if (isHashPayload2(result)) {
-      return await this.fetchOne(result.hash, maxDepth - 1);
-    }
-    return result;
-  }
-  getOne(hash) {
-    return this._axiosGet.get(`/get/${hash}`).then((response) => {
-      if (response.status < 200 || response.status >= 300) {
-        throw new Error(`Failed to get item [${response.status}]: ${response.statusText}`);
-      }
-      const contentType = response.headers["content-type"];
-      if (contentType && contentType.includes("application/json")) {
-        const parsed = JSON.parse(response.data);
-        if (!isAnyPayload3(parsed)) {
-          throw new Error("Invalid response from server (expected a Payload)");
-        }
-        return parsed;
-      } else {
-        throw new Error(`Unexpected content type: ${contentType}`);
-      }
-    });
-  }
-};
-
 // src/provider/runner/JsonRpcXyoRunner.ts
 var JsonRpcXyoRunner = class {
   static {
@@ -2064,7 +1891,7 @@ var JsonRpcXyoRunner = class {
 
 // src/provider/runner/MemoryXyoRunner.ts
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var MemoryXyoRunner = class {
   static {
@@ -2074,7 +1901,7 @@ var MemoryXyoRunner = class {
   async broadcastTransaction(transaction) {
     const archivist = await this.getArchivist();
     await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder2.hash(transaction[0]);
+    return await PayloadBuilder.hash(transaction[0]);
   }
   async getArchivist() {
     if (!this._archivist) {
@@ -2087,9 +1914,9 @@ var MemoryXyoRunner = class {
 };
 
 // src/provider/runner/NodeXyoRunner.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx2 } from "@xylabs/assert";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { flattenHydratedTransaction as flattenHydratedTransaction2 } from "@xyo-network/xl1-protocol-sdk";
 var NodeXyoRunner = class {
@@ -2106,7 +1933,7 @@ var NodeXyoRunner = class {
   async broadcastTransaction(transaction) {
     const flattened = flattenHydratedTransaction2(transaction);
     const pendingArchivist = await this.getPendingArchivist();
-    const txHash = await PayloadBuilder3.hash(transaction[0]);
+    const txHash = await PayloadBuilder2.hash(transaction[0]);
     const payloadBundle = {
       schema: PayloadBundleSchema,
       payloads: flattened,
@@ -2119,12 +1946,12 @@ var NodeXyoRunner = class {
   }
   getArchivist = /* @__PURE__ */ __name(async (identifier) => {
     const archivist = await this.node.resolve(identifier);
-    return assertEx4(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+    return assertEx2(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
   }, "getArchivist");
   getPendingArchivist = /* @__PURE__ */ __name(async () => {
     if (this._pendingArchivist) return this._pendingArchivist;
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
-    return assertEx4(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${this.pendingArchivistPath}`);
+    return assertEx2(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${this.pendingArchivistPath}`);
   }, "getPendingArchivist");
 };
 
@@ -2139,155 +1966,6 @@ var JsonRpcViewer = class {
   }
 };
 
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewerMethods.ts
-var JsonRpcNetworkStakingStepRewardsByPositionViewerMethods = class extends JsonRpcViewer {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsByPositionViewerMethods");
-  }
-  async bonus(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_bonus", [
-      options
-    ]);
-  }
-  async claimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_claimed", [
-      options
-    ]);
-  }
-  async earned(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_earned", [
-      options
-    ]);
-  }
-  async total(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_total", [
-      options
-    ]);
-  }
-  async unclaimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByPositionViewer_unclaimed", [
-      options
-    ]);
-  }
-};
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByPositionViewer/JsonRpcNetworkStakingStepRewardsByPositionViewer.ts
-var JsonRpcNetworkStakingStepRewardsByPositionViewer = class extends JsonRpcNetworkStakingStepRewardsByPositionViewerMethods {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsByPositionViewer");
-  }
-};
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStakerViewer/JsonRpcNetworkStakingStepRewardsByStakerViewerMethods.ts
-var JsonRpcNetworkStakingStepRewardsByStakerViewerMethods = class extends JsonRpcViewer {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsByStakerViewerMethods");
-  }
-  async bonus(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_bonus", [
-      options
-    ]);
-  }
-  async claimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_claimed", [
-      options
-    ]);
-  }
-  async earned(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_earned", [
-      options
-    ]);
-  }
-  async total(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_total", [
-      options
-    ]);
-  }
-  async unclaimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStakerViewer_unclaimed", [
-      options
-    ]);
-  }
-};
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewerMethods.ts
-var JsonRpcNetworkStakingStepRewardsByStepViewerMethods = class extends JsonRpcViewer {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsByStepViewerMethods");
-  }
-  async bonus(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_bonus", [
-      options
-    ]);
-  }
-  async claimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_claimed", [
-      options
-    ]);
-  }
-  async earned(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_earned", [
-      options
-    ]);
-  }
-  async total(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_total", [
-      options
-    ]);
-  }
-  async unclaimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsByStepViewer_unclaimed", [
-      options
-    ]);
-  }
-};
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsByStepViewer/JsonRpcNetworkStakingStepRewardsByStepViewer.ts
-var JsonRpcNetworkStakingStepRewardsByStepViewer = class extends JsonRpcNetworkStakingStepRewardsByStepViewerMethods {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsByStepViewer");
-  }
-};
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewerMethods.ts
-var JsonRpcNetworkStakingStepRewardsTotalViewerMethods = class extends JsonRpcViewer {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsTotalViewerMethods");
-  }
-  async bonus(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_bonus", [
-      options
-    ]);
-  }
-  async claimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_claimed", [
-      options
-    ]);
-  }
-  async earned(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_earned", [
-      options
-    ]);
-  }
-  async total(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_total", [
-      options
-    ]);
-  }
-  async unclaimed(options) {
-    return await this.transport.sendRequest("networkStakingStepRewardsTotalViewer_unclaimed", [
-      options
-    ]);
-  }
-};
-
-// src/provider/viewer/JsonRpcNetworkStakingStepRewardsTotalViewer/JsonRpcNetworkStakingStepRewardsTotalViewer.ts
-var JsonRpcNetworkStakingStepRewardsTotalViewer = class extends JsonRpcNetworkStakingStepRewardsTotalViewerMethods {
-  static {
-    __name(this, "JsonRpcNetworkStakingStepRewardsTotalViewer");
-  }
-};
-
 // src/provider/viewer/JsonRpcNetworkStakingStepRewardsViewer/JsonRpcNetworkStakingStepRewardsViewerMethods.ts
 var JsonRpcNetworkStakingStepRewardsViewerMethods = class extends JsonRpcViewer {
   static {
@@ -2300,28 +1978,22 @@ var JsonRpcNetworkStakingStepRewardsViewer = class extends JsonRpcNetworkStaking
   static {
     __name(this, "JsonRpcNetworkStakingStepRewardsViewer");
   }
-  _position;
-  _staker;
-  _step;
-  _total;
-  constructor(transport) {
+  providers;
+  constructor(transport, providers) {
     super(transport);
-    this._position = new JsonRpcNetworkStakingStepRewardsByPositionViewer(transport);
-    this._staker = new JsonRpcNetworkStakingStepRewardsByStakerViewerMethods(transport);
-    this._step = new JsonRpcNetworkStakingStepRewardsByStepViewer(transport);
-    this._total = new JsonRpcNetworkStakingStepRewardsTotalViewer(transport);
+    this.providers = providers ?? {};
   }
   get position() {
-    return this._position;
+    return this.providers.position;
   }
   get staker() {
-    return this._staker;
+    return this.providers.staker;
   }
   get step() {
-    return this._step;
+    return this.providers.step;
   }
   get total() {
-    return this._total;
+    return this.providers.total;
   }
 };
 
@@ -2353,27 +2025,31 @@ var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
+import { isDefined } from "@xylabs/typeof";
 import { asAttoXL1 as asAttoXL14, asHydratedBlock } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
   }
-  _networkStakeViewer;
+  providers;
   transport;
-  constructor(transport, networkStakeViewer) {
+  constructor(transport, providers) {
     this.transport = transport;
-    this._networkStakeViewer = networkStakeViewer;
+    this.providers = providers;
   }
   get networkStakeViewer() {
-    return this._networkStakeViewer;
+    return this.providers?.networkStakeViewer;
   }
   async accountBalance(address) {
     return asAttoXL14(await this.transport.sendRequest("xyoViewer_accountBalance", [
       address
     ]));
   }
-  async accountBalanceHistory(address) {
-    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", [
+  async accountBalanceHistory(address, range) {
+    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", isDefined(range) ? [
+      address,
+      range
+    ] : [
       address
     ]);
   }
@@ -2564,20 +2240,16 @@ var JsonRpcXyoViewer = class {
       address
     ]));
   }
-  async transferBalanceHistory(address) {
-    return await this.transport.sendRequest("xyoViewer_transferBalanceHistory", [
-      address
-    ]);
+  transferBalanceHistory(address, range) {
+    throw new Error("Method not implemented.");
   }
   async transferPairBalance(pair) {
     return asAttoXL14(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
       pair
     ]));
   }
-  async transferPairBalanceHistory(pair) {
-    return await this.transport.sendRequest("xyoViewer_transferPairBalanceHistory", [
-      pair
-    ]);
+  transferPairBalanceHistory(pair) {
+    throw new Error("Method not implemented.");
   }
 };
 
@@ -2624,8 +2296,10 @@ var HttpRpcXyoConnection = class extends XyoBaseConnection {
     });
     const runner = new JsonRpcXyoRunner(transport);
     const networkStakeViewer = new JsonRpcNetworkStakeViewer(transport);
-    const viewer = new JsonRpcXyoViewer(transport, networkStakeViewer);
-    const storage = isDataLakeProvider(storageParam) ? storageParam : isString2(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
+    const viewer = new JsonRpcXyoViewer(transport, {
+      networkStakeViewer
+    });
+    const storage = storageParam;
     super({
       runner,
       viewer,
@@ -2634,10 +2308,36 @@ var HttpRpcXyoConnection = class extends XyoBaseConnection {
   }
 };
 
+// src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
+  static {
+    __name(this, "JsonRpcDataLakeViewerMethods");
+  }
+  get(id) {
+    throw new Error("Method not implemented.");
+  }
+  getMany(id) {
+    throw new Error("Method not implemented.");
+  }
+  has(id) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// src/provider/datalake/JsonRpcDataLakeViewer.ts
+var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
+  static {
+    __name(this, "JsonRpcDataLakeViewer");
+  }
+  constructor(transport) {
+    super(transport);
+  }
+};
+
 // src/provider/gateway/Abstract.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { isDefined as isDefined2 } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var AbstractXyoGateway = class {
   static {
@@ -2645,14 +2345,14 @@ var AbstractXyoGateway = class {
   }
   async addPayloadsToChain(onChain, offChain, options) {
     const connection = await this.connection();
-    const viewer = assertEx5(connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx3(connection.viewer, () => "No viewer available on connection");
     const signer = await this.signer();
     const { nbf, exp, chain, fees } = options ?? {};
     const resolvedChainId = isDefined2(chain) ? chain : await viewer.chainId();
     const resolvedNbf = isDefined2(nbf) ? nbf : await viewer?.currentBlockNumber();
     const resolvedExp = isDefined2(exp) ? exp : resolvedNbf + 10;
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await signer.address(), fees);
-    const runner = assertEx5(connection.runner, () => "No runner available on connection");
+    const runner = assertEx3(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     const hash = await runner.broadcastTransaction(signedTx);
     return [
@@ -2663,11 +2363,11 @@ var AbstractXyoGateway = class {
   async addTransactionToChain(tx) {
     const connection = await this.connection();
     const signer = await this.signer();
-    const runner = assertEx5(connection.runner, () => "No runner available on connection");
+    const runner = assertEx3(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     return await runner.broadcastTransaction([
-      await PayloadBuilder4.addStorageMeta(signedTx[0]),
-      await PayloadBuilder4.addStorageMeta(signedTx[1])
+      await PayloadBuilder3.addStorageMeta(signedTx[0]),
+      await PayloadBuilder3.addStorageMeta(signedTx[1])
     ]);
   }
 };
@@ -2765,7 +2465,7 @@ var MemoryXyoNetwork = class {
 };
 
 // src/provider/permissions/MemoryXyoPermissions.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
+import { assertEx as assertEx4 } from "@xylabs/assert";
 var MemoryXyoPermissions = class {
   static {
     __name(this, "MemoryXyoPermissions");
@@ -2777,7 +2477,7 @@ var MemoryXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx6(this._store, () => "Store must be defined to get permissions");
+    return assertEx4(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -2858,7 +2558,7 @@ var RpcXyoPermissions = class {
 };
 
 // src/provider/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
+import { assertEx as assertEx5 } from "@xylabs/assert";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -2869,7 +2569,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx7(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx5(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -2928,7 +2628,6 @@ var MemoryXyoSigner = class {
   }
 };
 export {
-  AbstractXyoDataLake,
   AbstractXyoGateway,
   AddressZod,
   AllRpcSchemas,
@@ -2938,7 +2637,7 @@ export {
   AnySignedBoundWitnessWithStorageMetaZod,
   AnySignedBoundWitnessZod,
   AnyUnsignedBoundWitnessZod,
-  ArchivistXyoDataLake,
+  ArrayBufferToJsonZod,
   AttoToJsonZod,
   AttoZod,
   BlockBoundWitnessWithStorageMetaZod,
@@ -2953,21 +2652,27 @@ export {
   CaveatTypesZod,
   CaveatsZod,
   ChainZod,
+  DataLakeViewerRpcSchemas,
+  HashZod2 as HashZod,
+  HexZod2 as HexZod,
   HttpRpcTransport,
   HttpRpcXyoConnection,
-  HttpXyoDataLake,
   HydratedBlockWithStorageMetaZod,
   HydratedBlockZod,
   HydratedTransactionZod,
   InvokerPermissionZod,
   JsonObjectZod,
+  JsonRpcDataLakeViewer,
+  JsonRpcDataLakeViewerMethods,
   JsonRpcErrorCodes,
   JsonRpcNetworkStakeViewer,
   JsonRpcNetworkStakeViewerMethods,
   JsonRpcNetworkStakingStepRewardsViewer,
   JsonRpcNetworkStakingStepRewardsViewerMethods,
+  JsonRpcViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
+  JsonToArrayBufferZod,
   JsonToAttoZod,
   JsonToSignedHydratedTransactionZod,
   JsonToStakeZod,
@@ -3029,11 +2734,13 @@ export {
   TransferFieldsZod,
   TransferPairZod,
   TransferZod,
+  TransferZodWithStorageMeta,
   UnsignedBoundWitnessWithStorageMetaZod,
   UnsignedBoundWitnessZod,
   UnsignedHydratedTransactionZod,
   WithStorageMetaZod,
   WithTransactionFeesZod,
+  XL1BlockNumberZod,
   XyoBaseConnection,
   XyoPermissionsRpcSchemas,
   XyoRunnerRpcSchemas,