@xyo-network/xl1-rpc 1.16.0 → 1.16.2

package/dist/neutral/index.mjs

@@ -114,23 +114,6 @@ var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
   };
 }, "rpcMethodHandlersFromSigner");
 
-// src/provider/client/MemoryXyoClient.ts
-var MemoryXyoClient = class {
-  static {
-    __name(this, "MemoryXyoClient");
-  }
-  gateways;
-  permissions;
-  constructor(gateways, permissions) {
-    this.gateways = gateways;
-    this.permissions = permissions;
-  }
-};
-
-// src/provider/connection/HttpRpcXyoConnection.ts
-import { isString as isString2 } from "@xylabs/typeof";
-import { isDataLakeProvider } from "@xyo-network/xl1-protocol-sdk";
-
 // src/transport/HttpRpcTransport.ts
 import { AxiosJson } from "@xylabs/axios";
 import { isError, isUndefinedOrNull } from "@xylabs/typeof";
@@ -184,57 +167,91 @@ var NetworkStakingStepRewardsViewerRpcNamespace = "networkStakingStepRewardsView
 
 // src/types/schema/NetworkStakeViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod2, JsonToBigIntZod as JsonToBigIntZod2 } from "@xylabs/hex";
-import * as z19 from "zod";
+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 { HashZod as HashZod2 } from "@xylabs/hex";
 import { asXL1BlockNumber } from "@xyo-network/xl1-protocol";
-import * as z6 from "zod";
+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);
@@ -242,57 +259,55 @@ 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 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 BlockNumberZod = z7.number().int().nonnegative();
 var XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber);
-var HexZod2 = z6.string().regex(/^[0-9a-f]+$/);
-var HashZod2 = HexZod2.transform((v) => v);
-var BlockBoundWitnessFieldsZod = z6.object({
+var BlockBoundWitnessFieldsZod = z7.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
   previous: HashZod2.nullable(),
-  protocol: z6.number(),
-  step_hashes: z6.array(HashZod2).optional()
+  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);
@@ -300,57 +315,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 { BigIntToJsonZod, HexZod as HexZod2, 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({
-  base: HexZod3,
-  gasLimit: HexZod3,
-  gasPrice: HexZod3,
-  priority: HexZod3
+var TransactionFeesHexZod = z10.object({
+  base: HexZod2,
+  gasLimit: HexZod2,
+  gasPrice: HexZod2,
+  priority: HexZod2
 });
-var TransactionFeesBigIntZod = z9.object({
+var TransactionFeesBigIntZod = z10.object({
   base: AttoZod,
   gasLimit: AttoZod,
   gasPrice: AttoZod,
@@ -370,23 +385,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
 });
@@ -394,17 +409,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,
@@ -416,79 +431,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 { HexZod as HexZod3 } from "@xylabs/hex";
+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,
@@ -500,7 +515,7 @@ var StakeToJsonZod = StakeZod.transform((val) => ({
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({
-  amount: HexZod4
+  amount: HexZod3
 }).transform((val) => ({
   addBlock: val.addBlock,
   amount: JsonToAttoZod.parse(val.amount),
@@ -512,23 +527,23 @@ var JsonToStakeZod = StakeZod.extend({
 }));
 
 // src/types/schema/common/Transfer.ts
-import { HexZod as HexZod5 } from "@xylabs/hex";
+import { HexZod as HexZod4 } 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({
-  $opCodes: z17.array(z17.string()).optional(),
-  context: z17.object().optional(),
-  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, HexZod5)
+  transfers: z18.record(AddressZod, HexZod4)
 });
 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
 ]);
@@ -537,79 +552,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([
+      to: z20.tuple([
         BigIntToJsonZod2,
-        z19.number()
+        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
       ])
     },
@@ -622,12 +637,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,
@@ -636,10 +651,10 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z22.tuple([
+      to: z23.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z22.tuple([
+      from: z23.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
@@ -654,14 +669,14 @@ var XyoSignerRpcSchemas = {
 
 // src/types/schema/XyoViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod3, HashZod as HashZod3, JsonToBigIntZod as JsonToBigIntZod3, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
-import * as z23 from "zod";
+import * as z24 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
@@ -672,51 +687,51 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod,
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod,
         AddressZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod3),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod3),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod,
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod,
         AddressZod
       ])
     },
     result: {
-      to: z23.tuple([
+      to: z24.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -724,11 +739,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod,
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod,
         AddressZod
       ])
@@ -740,10 +755,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
@@ -754,27 +769,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod3),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod,
-        z23.number()
+        z24.number()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod,
-        z23.number()
+        z24.number()
       ])
     },
     result: {
@@ -784,13 +799,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod,
-        z23.number()
+        z24.number()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod,
-        z23.number()
+        z24.number()
       ])
     },
     result: {
@@ -800,10 +815,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod
       ])
     },
@@ -814,10 +829,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod
       ])
     },
@@ -828,49 +843,49 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: z23.number(),
-      from: z23.number()
+      to: z24.number(),
+      from: z24.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod
       ])
     },
     result: {
-      to: z23.record(AddressZod, BigIntToJsonZod3),
-      from: z23.record(AddressZod, JsonToBigIntZod3)
+      to: z24.record(AddressZod, BigIntToJsonZod3),
+      from: z24.record(AddressZod, JsonToBigIntZod3)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         StepIdentityZod,
-        z23.number()
+        z24.number()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         StepIdentityZod,
-        z23.number()
+        z24.number()
       ])
     },
     result: {
-      to: z23.tuple([
+      to: z24.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -878,27 +893,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z23.tuple([
-        z23.number(),
-        z23.tuple([
-          z23.number(),
-          z23.number()
+      to: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: 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([
+      to: z24.tuple([
         BigIntToJsonZod3,
         BigIntToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToBigIntZod3,
         JsonToBigIntZod3
       ])
@@ -906,16 +921,16 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z23.tuple([
-        z23.tuple([
-          z23.number(),
-          z23.number()
+      to: z24.tuple([
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: z23.tuple([
-        z23.tuple([
-          z23.number(),
-          z23.number()
+      from: z24.tuple([
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ])
     },
@@ -926,18 +941,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z23.tuple([
-        z23.number(),
-        z23.tuple([
-          z23.number(),
-          z23.number()
+      to: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: z23.tuple([
-        z23.number(),
-        z23.tuple([
-          z23.number(),
-          z23.number()
+      from: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ])
     },
@@ -948,27 +963,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z23.tuple([
-        z23.number(),
-        z23.tuple([
-          z23.number(),
-          z23.number()
+      to: z24.tuple([
+        z24.number(),
+        z24.tuple([
+          z24.number(),
+          z24.number()
         ])
       ]),
-      from: 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([
+      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
       ]))
@@ -976,10 +991,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
@@ -990,22 +1005,22 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod,
         BlockRangeZod.optional()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod,
         BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z23.array(z23.tuple([
+      to: z24.array(z24.tuple([
         BlockBoundWitnessZod,
         TransactionBoundWitnessZod.nullable(),
         TransferZodWithStorageMeta
       ])),
-      from: z23.array(z23.tuple([
+      from: z24.array(z24.tuple([
         BlockBoundWitnessZod,
         TransactionBoundWitnessZod.nullable(),
         TransferZodWithStorageMeta
@@ -1014,10 +1029,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferPairBalance: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         TransferPairZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         TransferPairZod
       ])
     },
@@ -1028,27 +1043,27 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferPairBalanceHistory: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         TransferPairZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         TransferPairZod
       ])
     },
     result: {
-      to: z23.array(z23.tuple([
+      to: z24.array(z24.tuple([
         BlockBoundWitnessWithStorageMetaZod,
-        z23.union([
+        z24.union([
           TransactionBoundWitnessZod,
-          z23.null()
+          z24.null()
         ]),
         PayloadZod
       ])),
-      from: z23.array(z23.tuple([
+      from: z24.array(z24.tuple([
         BlockBoundWitnessWithStorageMetaZod,
-        z23.union([
+        z24.union([
           TransactionBoundWitnessZod,
-          z23.null()
+          z24.null()
         ]),
         PayloadZod
       ]))
@@ -1056,10 +1071,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferBalance: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod
       ])
     },
@@ -1070,29 +1085,29 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transferBalanceHistory: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         AddressZod,
         BlockRangeZod.optional()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         AddressZod,
         BlockRangeZod.optional()
       ])
     },
     result: {
-      to: z23.array(z23.tuple([
+      to: z24.array(z24.tuple([
         BlockBoundWitnessWithStorageMetaZod,
-        z23.union([
+        z24.union([
           TransactionBoundWitnessZod,
-          z23.null()
+          z24.null()
         ]),
         PayloadZod
       ])),
-      from: z23.array(z23.tuple([
+      from: z24.array(z24.tuple([
         BlockBoundWitnessWithStorageMetaZod,
-        z23.union([
+        z24.union([
           TransactionBoundWitnessZod,
-          z23.null()
+          z24.null()
         ]),
         PayloadZod
       ]))
@@ -1100,10 +1115,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         HashToJsonZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         JsonToHashZod2
       ])
     },
@@ -1114,11 +1129,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: {
@@ -1128,24 +1143,24 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         HashZod3,
-        z23.number().optional()
+        z24.number().optional()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         HashZod3,
-        z23.number().optional()
+        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,
@@ -1154,10 +1169,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         BlockNumberZod
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         BlockNumberZod
       ])
     },
@@ -1168,8 +1183,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,
@@ -1178,8 +1193,8 @@ 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: HashZod3,
@@ -1188,8 +1203,8 @@ var XyoViewerRpcSchemas = {
   },
   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,
@@ -1198,23 +1213,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: {
@@ -1224,11 +1239,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: {
@@ -1238,55 +1253,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([
+      to: z24.tuple([
         HashZod3,
-        z23.number()
+        z24.number()
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         HashZod3,
-        z23.number()
+        z24.number()
       ])
     },
     result: {
@@ -1296,13 +1311,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: {
@@ -1312,10 +1327,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z23.tuple([
+      to: z24.tuple([
         HashZod3
       ]),
-      from: z23.tuple([
+      from: z24.tuple([
         HashZod3
       ])
     },
@@ -1336,253 +1351,314 @@ 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 { HashZod as HashZod4 } from "@xylabs/hex";
+import { PayloadZod as PayloadZod2 } from "@xyo-network/payload-model";
+import * as z27 from "zod";
+var DataLakeViewerRpcSchemas = {
+  dataLakeViewer_get: {
+    params: {
+      to: z27.tuple([
+        HashZod4
+      ]),
+      from: z27.tuple([
+        HashZod4
+      ])
+    },
+    result: {
+      to: z27.union([
+        PayloadZod2,
+        ArrayBufferToJsonZod
+      ]).optional(),
+      from: z27.union([
+        PayloadZod2,
+        JsonToArrayBufferZod
+      ]).optional()
+    }
+  },
+  dataLakeViewer_getMany: {
+    params: {
+      to: z27.tuple([
+        z27.array(HashZod4)
+      ]),
+      from: z27.tuple([
+        z27.array(HashZod4)
+      ])
+    },
+    result: {
+      to: z27.array(z27.union([
+        PayloadZod2,
+        ArrayBufferToJsonZod
+      ])),
+      from: z27.array(z27.union([
+        PayloadZod2,
+        JsonToArrayBufferZod
+      ]))
+    }
+  },
+  dataLakeViewer_has: {
+    params: {
+      to: z27.tuple([
+        HashZod4
+      ]),
+      from: z27.tuple([
+        HashZod4
+      ])
+    },
+    result: {
+      to: z27.boolean(),
+      from: z27.boolean()
+    }
+  }
+};
+
 // src/types/schema/RewardsByPositionViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod4, JsonToBigIntZod as JsonToBigIntZod4 } from "@xylabs/hex";
 import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
-import z26 from "zod";
+import 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(), BigIntToJsonZod4)
+      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(), BigIntToJsonZod4.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(), BigIntToJsonZod4.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(), BigIntToJsonZod4.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(), BigIntToJsonZod4.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 BigIntToJsonZod5, JsonToBigIntZod as JsonToBigIntZod5 } from "@xylabs/hex";
-import z27 from "zod";
+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, BigIntToJsonZod5),
-      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, BigIntToJsonZod5),
-      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, BigIntToJsonZod5),
-      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, BigIntToJsonZod5),
-      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, BigIntToJsonZod5),
-      to: z27.record(AddressZod, JsonToBigIntZod5)
+      from: z29.record(AddressZod, BigIntToJsonZod5),
+      to: z29.record(AddressZod, JsonToBigIntZod5)
     }
   }
 };
 
 // src/types/schema/RewardsByStepViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod6, JsonToBigIntZod as JsonToBigIntZod6 } from "@xylabs/hex";
-import z28 from "zod";
+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, BigIntToJsonZod6),
-      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, BigIntToJsonZod6),
-      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, BigIntToJsonZod6),
-      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, BigIntToJsonZod6),
-      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, BigIntToJsonZod6),
-      to: z28.record(AddressZod, JsonToBigIntZod6)
+      from: z30.record(AddressZod, BigIntToJsonZod6),
+      to: z30.record(AddressZod, JsonToBigIntZod6)
     }
   }
 };
@@ -1590,14 +1666,14 @@ var NetworkStakingStepRewardsByStepViewerRpcSchemas = {
 // src/types/schema/RewardsTotalViewerRpcSchemas.ts
 import { BigIntToJsonZod as BigIntToJsonZod7, JsonToBigIntZod as JsonToBigIntZod7 } from "@xylabs/hex";
 import { asAttoXL1 as asAttoXL13 } from "@xyo-network/xl1-protocol";
-import * as z29 from "zod";
+import * as z31 from "zod";
 var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   networkStakingStepRewardsTotalViewer_bonus: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1608,10 +1684,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_claimed: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1622,10 +1698,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_earned: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1636,10 +1712,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_total: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1650,10 +1726,10 @@ var NetworkStakingStepRewardsTotalViewerRpcSchemas = {
   },
   networkStakingStepRewardsTotalViewer_unclaimed: {
     params: {
-      from: z29.tuple([
+      from: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ]),
-      to: z29.tuple([
+      to: z31.tuple([
         RewardsRangeOptionsZod.optional()
       ])
     },
@@ -1749,194 +1825,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 {
@@ -1953,36 +1841,12 @@ 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 { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
-var MemoryXyoRunner = class {
-  static {
-    __name(this, "MemoryXyoRunner");
-  }
-  _archivist;
-  async broadcastTransaction(transaction) {
-    const archivist = await this.getArchivist();
-    await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder2.hash(transaction[0]);
-  }
-  async getArchivist() {
-    if (!this._archivist) {
-      this._archivist = await MemoryArchivist.create({
-        account: "random"
-      });
-    }
-    return this._archivist;
-  }
-};
-
 // 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 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
-import { flattenHydratedTransaction as flattenHydratedTransaction2 } from "@xyo-network/xl1-protocol-sdk";
+import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var NodeXyoRunner = class {
   static {
     __name(this, "NodeXyoRunner");
@@ -1995,9 +1859,9 @@ var NodeXyoRunner = class {
     this.node = node;
   }
   async broadcastTransaction(transaction) {
-    const flattened = flattenHydratedTransaction2(transaction);
+    const flattened = flattenHydratedTransaction(transaction);
     const pendingArchivist = await this.getPendingArchivist();
-    const txHash = await PayloadBuilder3.hash(transaction[0]);
+    const txHash = await PayloadBuilder.hash(transaction[0]);
     const payloadBundle = {
       schema: PayloadBundleSchema,
       payloads: flattened,
@@ -2010,12 +1874,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");
 };
 
@@ -2030,155 +1894,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 {
@@ -2191,28 +1906,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;
   }
 };
 
@@ -2244,20 +1953,20 @@ var JsonRpcNetworkStakeViewer = class extends JsonRpcNetworkStakeViewerMethods {
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { isDefined as isDefined2 } from "@xylabs/typeof";
+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", [
@@ -2265,7 +1974,7 @@ var JsonRpcXyoViewer = class {
     ]));
   }
   async accountBalanceHistory(address, range) {
-    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", isDefined2(range) ? [
+    return await this.transport.sendRequest("xyoViewer_accountBalanceHistory", isDefined(range) ? [
       address,
       range
     ] : [
@@ -2459,7 +2168,7 @@ var JsonRpcXyoViewer = class {
       address
     ]));
   }
-  transferBalanceHistory(address, range) {
+  transferBalanceHistory(_address, _range) {
     throw new Error("Method not implemented.");
   }
   async transferPairBalance(pair) {
@@ -2467,7 +2176,7 @@ var JsonRpcXyoViewer = class {
       pair
     ]));
   }
-  transferPairBalanceHistory(pair) {
+  transferPairBalanceHistory(_pair) {
     throw new Error("Method not implemented.");
   }
 };
@@ -2515,8 +2224,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,
@@ -2525,203 +2236,29 @@ var HttpRpcXyoConnection = class extends XyoBaseConnection {
   }
 };
 
-// src/provider/gateway/Abstract.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
-import { isDefined as isDefined3 } from "@xylabs/typeof";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
-var AbstractXyoGateway = class {
-  static {
-    __name(this, "AbstractXyoGateway");
-  }
-  async addPayloadsToChain(onChain, offChain, options) {
-    const connection = await this.connection();
-    const viewer = assertEx5(connection.viewer, () => "No viewer available on connection");
-    const signer = await this.signer();
-    const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined3(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = isDefined3(nbf) ? nbf : await viewer?.currentBlockNumber();
-    const resolvedExp = isDefined3(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 signedTx = await signer.signTransaction(tx);
-    const hash = await runner.broadcastTransaction(signedTx);
-    return [
-      hash,
-      signedTx
-    ];
-  }
-  async addTransactionToChain(tx) {
-    const connection = await this.connection();
-    const signer = await this.signer();
-    const runner = assertEx5(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])
-    ]);
-  }
-};
-
-// src/provider/gateway/MemoryXyoGateway.ts
-var MemoryXyoGateway = class extends AbstractXyoGateway {
-  static {
-    __name(this, "MemoryXyoGateway");
-  }
-  _connection;
-  _signer;
-  constructor(signer, connection) {
-    super();
-    this._signer = signer;
-    this._connection = connection;
-  }
-  connection() {
-    return this._connection;
-  }
-  signer() {
-    return this._signer;
-  }
-};
-
-// src/provider/network/MemoryXyoNetwork.ts
-import { isUndefined } from "@xylabs/typeof";
-import { isNetworkStatus } from "@xyo-network/xl1-protocol";
-import axios from "axios";
-
-// src/provider/network/lib/FailedNetworkStatusPayloads.ts
-import { NetworkStatusSchema } from "@xyo-network/xl1-protocol";
-var unknownStatus = {
-  description: "Unknown Network Status",
-  schema: NetworkStatusSchema,
-  state: "unknown"
-};
-var errorStatus = {
-  description: "Error Fetching Network Status",
-  schema: NetworkStatusSchema,
-  state: "unknown"
-};
-
-// src/provider/network/lib/StatusNetworks.ts
-var MainNetworkStats = {
-  id: "mainnet",
-  statusUrl: "https://xyo.network/chain-network-status-mainnet.json"
-};
-var SequenceNetworkStats = {
-  id: "sequence",
-  statusUrl: "https://beta.xyo.network/chain-network-status-sequence.json"
-};
-var LocalNetworkStats = {
-  id: "local",
-  statusUrl: "http://localhost:3002/chain-network-status-local.json"
-};
-var StatusNetworks = {
-  ["mainnet"]: MainNetworkStats,
-  ["sequence"]: SequenceNetworkStats,
-  ["local"]: LocalNetworkStats
-};
-
-// src/provider/network/MemoryXyoNetwork.ts
-var MemoryXyoNetwork = class {
+// src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
+var JsonRpcDataLakeViewerMethods = class extends JsonRpcViewer {
   static {
-    __name(this, "MemoryXyoNetwork");
+    __name(this, "JsonRpcDataLakeViewerMethods");
   }
-  _networkId;
-  constructor(networkId) {
-    this._networkId = networkId;
+  get(_id) {
+    throw new Error("Method not implemented.");
   }
-  async status() {
-    const statusNetwork = StatusNetworks[this._networkId];
-    if (isUndefined(statusNetwork)) {
-      throw new Error(`Unknown status network ID: ${this._networkId}`);
-    }
-    return await this.makeRequest(statusNetwork.statusUrl);
+  getMany(_id) {
+    throw new Error("Method not implemented.");
   }
-  async makeRequest(url) {
-    try {
-      const response = await axios.get(url);
-      if (isNetworkStatus(response.data)) {
-        return response.data;
-      } else {
-        if (response.status === 200) {
-          console.error("Unknown network status response:", response.data);
-          return unknownStatus;
-        }
-        return errorStatus;
-      }
-    } catch (error) {
-      console.error("Error fetching network status:", error);
-      return errorStatus;
-    }
+  has(_id) {
+    throw new Error("Method not implemented.");
   }
 };
 
-// src/provider/permissions/MemoryXyoPermissions.ts
-import { assertEx as assertEx6 } from "@xylabs/assert";
-var MemoryXyoPermissions = class {
+// src/provider/datalake/JsonRpcDataLakeViewer.ts
+var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
   static {
-    __name(this, "MemoryXyoPermissions");
-  }
-  invoker;
-  _store;
-  constructor(store) {
-    this._store = store;
-    this.invoker = store.invoker;
-  }
-  get store() {
-    return assertEx6(this._store, () => "Store must be defined to get permissions");
-  }
-  async getPermissions() {
-    return await this.store.getPermissions();
-  }
-  // assumed the permissions are always granted
-  async requestPermissions(permissions) {
-    await Promise.resolve();
-    const newPermissions = [];
-    const now = Date.now();
-    for (const req of permissions) {
-      for (const parentCapability in req) {
-        newPermissions.push({
-          invoker: this.invoker,
-          parentCapability,
-          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({
-            type,
-            value
-          })),
-          date: now
-        });
-      }
-    }
-    const existingPermissions = await this.getPermissions();
-    for (const perm of newPermissions) {
-      const idx = existingPermissions.findIndex((p) => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability);
-      if (idx === -1) {
-        existingPermissions.push(perm);
-      } else {
-        existingPermissions[idx] = perm;
-      }
-    }
-    await this.store.setPermissions(existingPermissions);
-    return newPermissions.map(({ parentCapability, date }) => ({
-      parentCapability,
-      date
-    }));
+    __name(this, "JsonRpcDataLakeViewer");
   }
-  // Assumes the permissions are always revoked
-  async revokePermissions(permissions) {
-    const existingPermissions = await this.getPermissions();
-    const revoked = [];
-    for (const parentCapability in permissions) {
-      const idx = existingPermissions.findIndex((p) => p.invoker === this.invoker && p.parentCapability === parentCapability);
-      if (idx !== -1) {
-        const removed = existingPermissions.splice(idx, 1)[0];
-        revoked.push({
-          parentCapability: removed.parentCapability,
-          date: removed.date
-        });
-      }
-    }
-    await this.store.setPermissions(existingPermissions);
-    return revoked;
+  constructor(transport) {
+    super(transport);
   }
 };
 
@@ -2748,30 +2285,6 @@ var RpcXyoPermissions = class {
   }
 };
 
-// src/provider/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
-var MemoryPermissionsStore = class {
-  static {
-    __name(this, "MemoryPermissionsStore");
-  }
-  _invoker;
-  permissions = [];
-  constructor(invoker) {
-    this._invoker = invoker;
-  }
-  get invoker() {
-    return assertEx7(this._invoker, () => "Invoker must be defined to get permissions");
-  }
-  async getPermissions() {
-    await Promise.resolve();
-    return this.permissions;
-  }
-  async setPermissions(permissions) {
-    await Promise.resolve();
-    this.permissions = permissions;
-  }
-};
-
 // src/provider/signer/JsonRpcXyoSigner.ts
 var RpcXyoSigner = class {
   static {
@@ -2791,36 +2304,7 @@ var RpcXyoSigner = class {
     return ret;
   }
 };
-
-// src/provider/signer/MemoryXyoSigner.ts
-import { buildTransaction, signTransaction } from "@xyo-network/xl1-protocol-sdk";
-var MemoryXyoSigner = class {
-  static {
-    __name(this, "MemoryXyoSigner");
-  }
-  _account;
-  constructor(account) {
-    this._account = account;
-  }
-  address() {
-    return this._account.address;
-  }
-  async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
-    const fromAddress = from ?? this._account.address;
-    const transaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, this._account, nbf, exp, fromAddress, fees);
-    return transaction[0];
-  }
-  async signTransaction(tx) {
-    const txBW = await signTransaction(tx[0], this._account);
-    return [
-      txBW,
-      tx[1]
-    ];
-  }
-};
 export {
-  AbstractXyoDataLake,
-  AbstractXyoGateway,
   AddressZod,
   AllRpcSchemas,
   AnyBoundWitnessZod,
@@ -2829,7 +2313,7 @@ export {
   AnySignedBoundWitnessWithStorageMetaZod,
   AnySignedBoundWitnessZod,
   AnyUnsignedBoundWitnessZod,
-  ArchivistXyoDataLake,
+  ArrayBufferToJsonZod,
   AttoToJsonZod,
   AttoZod,
   BlockBoundWitnessWithStorageMetaZod,
@@ -2844,36 +2328,31 @@ export {
   CaveatTypesZod,
   CaveatsZod,
   ChainZod,
-  HashZod2 as HashZod,
-  HexZod2 as HexZod,
+  DataLakeViewerRpcSchemas,
   HttpRpcTransport,
   HttpRpcXyoConnection,
-  HttpXyoDataLake,
   HydratedBlockWithStorageMetaZod,
   HydratedBlockZod,
   HydratedTransactionZod,
   InvokerPermissionZod,
   JsonObjectZod,
+  JsonRpcDataLakeViewer,
+  JsonRpcDataLakeViewerMethods,
   JsonRpcErrorCodes,
   JsonRpcNetworkStakeViewer,
   JsonRpcNetworkStakeViewerMethods,
   JsonRpcNetworkStakingStepRewardsViewer,
   JsonRpcNetworkStakingStepRewardsViewerMethods,
+  JsonRpcViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoViewer,
+  JsonToArrayBufferZod,
   JsonToAttoZod,
   JsonToSignedHydratedTransactionZod,
   JsonToStakeZod,
   LocalSequenceFromStringZod,
   LocalSequenceToStringZod,
-  MemoryPermissionsStore,
   MemoryRpcTransport,
-  MemoryXyoClient,
-  MemoryXyoGateway,
-  MemoryXyoNetwork,
-  MemoryXyoPermissions,
-  MemoryXyoRunner,
-  MemoryXyoSigner,
   NetworkStakeViewerRpcNamespace,
   NetworkStakeViewerRpcSchemas,
   NetworkStakingStepRewardsByPositionViewerRpcNamespace,