@xyo-network/xl1-rpc 1.9.0 → 1.10.1

package/dist/node/index-node.mjs

@@ -1,85 +1,61 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/engine/requestSchemas.ts
 var requestSchemas = {};
 
 // src/engine/rpcMethodHandlersFromRunner.ts
-var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
-  return {
-    xyoRunner_broadcastTransaction: /* @__PURE__ */ __name((params) => runner.broadcastTransaction(...params ?? []), "xyoRunner_broadcastTransaction")
-  };
-}, "rpcMethodHandlersFromRunner");
+var rpcMethodHandlersFromRunner = (runner) => {
+  return { xyoRunner_broadcastTransaction: (params) => runner.broadcastTransaction(...params ?? []) };
+};
 
 // src/engine/rpcMethodHandlersFromSigner.ts
-var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
+var rpcMethodHandlersFromSigner = (signer) => {
   return {
-    xyoSigner_address: /* @__PURE__ */ __name((params) => signer.address(...params ?? []), "xyoSigner_address"),
-    xyoSigner_createSignedTransaction: /* @__PURE__ */ __name((params) => signer.createSignedTransaction(...params ?? []), "xyoSigner_createSignedTransaction"),
-    xyoSigner_signTransaction: /* @__PURE__ */ __name((params) => signer.signTransaction(...params ?? []), "xyoSigner_signTransaction")
+    xyoSigner_address: (params) => signer.address(...params ?? []),
+    xyoSigner_createSignedTransaction: (params) => signer.createSignedTransaction(...params ?? []),
+    xyoSigner_signTransaction: (params) => signer.signTransaction(...params ?? [])
   };
-}, "rpcMethodHandlersFromSigner");
+};
 
 // src/engine/rpcMethodHandlersFromViewer.ts
-var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
+var rpcMethodHandlersFromViewer = (viewer) => {
   return {
-    xyoViewer_accountBalance: /* @__PURE__ */ __name((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
-    xyoViewer_accountHistory: /* @__PURE__ */ __name((params) => viewer.accountHistory(...params ?? []), "xyoViewer_accountHistory"),
-    xyoViewer_blockByHash: /* @__PURE__ */ __name((params) => viewer.blockByHash(...params ?? []), "xyoViewer_blockByHash"),
-    xyoViewer_blockByNumber: /* @__PURE__ */ __name((params) => viewer.blockByNumber(...params ?? []), "xyoViewer_blockByNumber"),
-    xyoViewer_blocksByHash: /* @__PURE__ */ __name((params) => viewer.blocksByHash(...params ?? []), "xyoViewer_blocksByHash"),
-    xyoViewer_chainId: /* @__PURE__ */ __name((params) => viewer.chainId(...params ?? []), "xyoViewer_chainId"),
-    xyoViewer_currentBlock: /* @__PURE__ */ __name((params) => viewer.currentBlock(...params ?? []), "xyoViewer_currentBlock"),
-    xyoViewer_currentBlockHash: /* @__PURE__ */ __name((params) => viewer.currentBlockHash(...params ?? []), "xyoViewer_currentBlockHash"),
-    xyoViewer_currentBlockNumber: /* @__PURE__ */ __name((params) => viewer.currentBlockNumber(...params ?? []), "xyoViewer_currentBlockNumber"),
-    xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
-    xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
-    xyoViewer_transactionByHash: /* @__PURE__ */ __name((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash")
+    xyoViewer_accountBalance: (params) => viewer.accountBalance(...params ?? []),
+    xyoViewer_accountHistory: (params) => viewer.accountHistory(...params ?? []),
+    xyoViewer_blockByHash: (params) => viewer.blockByHash(...params ?? []),
+    xyoViewer_blockByNumber: (params) => viewer.blockByNumber(...params ?? []),
+    xyoViewer_blocksByHash: (params) => viewer.blocksByHash(...params ?? []),
+    xyoViewer_chainId: (params) => viewer.chainId(...params ?? []),
+    xyoViewer_currentBlock: (params) => viewer.currentBlock(...params ?? []),
+    xyoViewer_currentBlockHash: (params) => viewer.currentBlockHash(...params ?? []),
+    xyoViewer_currentBlockNumber: (params) => viewer.currentBlockNumber(...params ?? []),
+    xyoViewer_transactionByBlockHashAndIndex: (params) => viewer.transactionByBlockHashAndIndex(...params ?? []),
+    xyoViewer_transactionByBlockNumberAndIndex: (params) => viewer.transactionByBlockNumberAndIndex(...params ?? []),
+    xyoViewer_transactionByHash: (params) => viewer.transactionByHash(...params ?? [])
   };
-}, "rpcMethodHandlersFromViewer");
+};
 
 // src/engine/rpcMethodHandlersFromProvider.ts
-var rpcMethodHandlersFromProvider = /* @__PURE__ */ __name((provider) => {
-  const { runner, signer, viewer } = provider;
-  let result = {
-    xyoProvider_send: /* @__PURE__ */ __name((params) => provider.send(...params ?? []), "xyoProvider_send")
-  };
-  if (runner) result = {
-    ...result,
-    ...rpcMethodHandlersFromRunner(runner)
-  };
-  if (signer) result = {
-    ...result,
-    ...rpcMethodHandlersFromSigner(signer)
-  };
-  if (viewer) result = {
-    ...result,
-    ...rpcMethodHandlersFromViewer(viewer)
-  };
+var rpcMethodHandlersFromProvider = (provider) => {
+  const {
+    runner,
+    signer,
+    viewer
+  } = provider;
+  let result = { xyoProvider_send: (params) => provider.send(...params ?? []) };
+  if (runner) result = { ...result, ...rpcMethodHandlersFromRunner(runner) };
+  if (signer) result = { ...result, ...rpcMethodHandlersFromSigner(signer) };
+  if (viewer) result = { ...result, ...rpcMethodHandlersFromViewer(viewer) };
   return result;
-}, "rpcMethodHandlersFromProvider");
+};
 
 // src/engine/rpcEngineFromProvider.ts
 import { createAsyncMiddleware, JsonRpcEngine } from "@metamask/json-rpc-engine";
 
 // src/types/ErrorCodes.ts
 var JsonRpcErrorCodes = {
-  InternalError: {
-    code: -32603,
-    message: "Internal JSON-RPC error (unexpected exception)."
-  },
-  InvalidParams: {
-    code: -32602,
-    message: "Invalid method parameter(s)."
-  },
-  InvalidRequest: {
-    code: -32600,
-    message: "The JSON sent is not a valid Request object."
-  },
-  MethodNotFound: {
-    code: -32601,
-    message: "The method does not exist or is not available."
-  }
+  InternalError: { code: -32603, message: "Internal JSON-RPC error (unexpected exception)." },
+  InvalidParams: { code: -32602, message: "Invalid method parameter(s)." },
+  InvalidRequest: { code: -32600, message: "The JSON sent is not a valid Request object." },
+  MethodNotFound: { code: -32601, message: "The method does not exist or is not available." }
 };
 
 // src/types/JsonRpc.ts
@@ -97,7 +73,11 @@ var AddressToStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx)
 var AddressFromStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx).transform((v) => toAddress(v));
 
 // src/types/schema/common/BigIntSchema.ts
-import { asHex, hexToBigInt, toHex } from "@xylabs/hex";
+import {
+  asHex,
+  hexToBigInt,
+  toHex
+} from "@xylabs/hex";
 import { HexRegEx } from "@xyo-network/payload-wrapper";
 import { z as z2 } from "zod";
 var CompiledHexRegEx = new RegExp(HexRegEx);
@@ -142,14 +122,8 @@ var LocalSequenceFromStringSchema = z5.string().regex(LocalSequenceRegex).transf
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
 var QualifiedSequenceToStringSchema = z5.string().regex(QualifiedSequenceRegex);
 var QualifiedSequenceFromStringSchema = z5.string().regex(QualifiedSequenceRegex).transform((v) => toHex3(v));
-var SequenceToStringSchema = z5.union([
-  LocalSequenceToStringSchema,
-  QualifiedSequenceToStringSchema
-]);
-var SequenceFromStringSchema = z5.union([
-  LocalSequenceFromStringSchema,
-  QualifiedSequenceFromStringSchema
-]);
+var SequenceToStringSchema = z5.union([LocalSequenceToStringSchema, QualifiedSequenceToStringSchema]);
+var SequenceFromStringSchema = z5.union([LocalSequenceFromStringSchema, QualifiedSequenceFromStringSchema]);
 
 // src/types/schema/common/StorageMetaSchema.ts
 var StorageMetaSchema = z6.object({
@@ -159,9 +133,7 @@ var StorageMetaSchema = z6.object({
 });
 
 // src/types/schema/common/PayloadSchema.ts
-var PayloadSchema = z7.object({
-  schema: z7.string()
-}).passthrough();
+var PayloadSchema = z7.object({ schema: z7.string() }).passthrough();
 var PayloadWithStorageMetaSchema = PayloadSchema.extend(StorageMetaSchema.shape).passthrough();
 
 // src/types/schema/common/BoundWitnessSchema.ts
@@ -176,18 +148,14 @@ var BoundWitnessMetaSchema = z8.object({
   $destination: AddressToStringSchema.optional(),
   $sourceQuery: HashToStringSchema.optional()
 });
-var UnsignedBoundWitnessSchema = PayloadSchema.extend({
-  schema: z8.literal(BoundWitnessSchema)
-}).merge(BoundWitnessRequiredFieldsSchema).merge(BoundWitnessMetaSchema).passthrough();
-var UnsignedBoundWitnessWithStorageMetaSchema = PayloadWithStorageMetaSchema.extend({
-  schema: z8.literal(BoundWitnessSchema)
-}).merge(BoundWitnessRequiredFieldsSchema).merge(BoundWitnessMetaSchema).passthrough();
-var SignedBoundWitnessSchema = UnsignedBoundWitnessSchema.extend({
-  $signatures: z8.array(HexToStringSchema)
-}).passthrough();
-var SignedBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema.extend({
-  $signatures: z8.array(HexToStringSchema)
-}).passthrough();
+var UnsignedBoundWitnessSchema = PayloadSchema.extend({ schema: z8.literal(BoundWitnessSchema) }).merge(BoundWitnessRequiredFieldsSchema).merge(BoundWitnessMetaSchema).passthrough();
+var UnsignedBoundWitnessWithStorageMetaSchema = PayloadWithStorageMetaSchema.extend({ schema: z8.literal(BoundWitnessSchema) }).merge(BoundWitnessRequiredFieldsSchema).merge(BoundWitnessMetaSchema).passthrough();
+var SignedBoundWitnessSchema = UnsignedBoundWitnessSchema.extend(
+  { $signatures: z8.array(HexToStringSchema) }
+).passthrough();
+var SignedBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema.extend(
+  { $signatures: z8.array(HexToStringSchema) }
+).passthrough();
 
 // src/types/schema/common/BlockBoundWitnessSchema.ts
 var BlockNumberSchema = z9.number().int().nonnegative();
@@ -227,16 +195,9 @@ import { z as z12 } from "zod";
 
 // src/types/schema/common/TransactionBoundWitnessSchema.ts
 import z11 from "zod";
-var BlockStartSchema = z11.object({
-  nbf: BlockNumberSchema
-});
-var BlockEndSchema = z11.object({
-  exp: BlockNumberSchema
-});
-var BlockDurationSchema = z11.object({
-  nbf: BlockNumberSchema,
-  exp: BlockNumberSchema
-});
+var BlockStartSchema = z11.object({ nbf: BlockNumberSchema });
+var BlockEndSchema = z11.object({ exp: BlockNumberSchema });
+var BlockDurationSchema = z11.object({ nbf: BlockNumberSchema, exp: BlockNumberSchema });
 var TransactionFeesSchema = z11.object({
   fees: z11.object({
     base: HexToStringSchema,
@@ -245,9 +206,7 @@ var TransactionFeesSchema = z11.object({
     priority: HexToStringSchema
   })
 });
-var TransactionBoundWitnessFields = z11.object({
-  chain: AddressToStringSchema
-});
+var TransactionBoundWitnessFields = z11.object({ chain: AddressToStringSchema });
 var TransactionBoundWitnessSchema = UnsignedBoundWitnessSchema.merge(BlockDurationSchema).merge(TransactionFeesSchema).merge(TransactionBoundWitnessFields).passthrough();
 var SignedTransactionBoundWitnessSchema = SignedBoundWitnessSchema.merge(BlockDurationSchema).merge(TransactionFeesSchema).merge(TransactionBoundWitnessFields).passthrough();
 
@@ -311,12 +270,8 @@ import { z as z15 } from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z15.tuple([
-        SignedHydratedTransactionSchema
-      ]),
-      from: z15.tuple([
-        SignedHydratedTransactionSchema
-      ])
+      to: z15.tuple([SignedHydratedTransactionSchema]),
+      from: z15.tuple([SignedHydratedTransactionSchema])
     },
     result: {
       to: HashToStringSchema,
@@ -366,12 +321,8 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z16.tuple([
-        HydratedTransactionSchema
-      ]),
-      from: z16.tuple([
-        HydratedTransactionSchema
-      ])
+      to: z16.tuple([HydratedTransactionSchema]),
+      from: z16.tuple([HydratedTransactionSchema])
     },
     result: {
       to: SignedHydratedTransactionSchema,
@@ -386,32 +337,14 @@ var XyoViewerRpcSchemas = {
   xyoViewer_accountBalance: {
     params: {
       to: z17.union([
-        z17.tuple([
-          AddressToStringSchema
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number(),
-          z17.boolean()
-        ])
+        z17.tuple([AddressToStringSchema]),
+        z17.tuple([AddressToStringSchema, z17.number()]),
+        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
       ]),
       from: z17.union([
-        z17.tuple([
-          AddressToStringSchema
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number(),
-          z17.boolean()
-        ])
+        z17.tuple([AddressToStringSchema]),
+        z17.tuple([AddressToStringSchema, z17.number()]),
+        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
       ])
     },
     result: {
@@ -422,32 +355,14 @@ var XyoViewerRpcSchemas = {
   xyoViewer_accountHistory: {
     params: {
       to: z17.union([
-        z17.tuple([
-          AddressToStringSchema
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number(),
-          z17.boolean()
-        ])
+        z17.tuple([AddressToStringSchema]),
+        z17.tuple([AddressToStringSchema, z17.number()]),
+        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
       ]),
       from: z17.union([
-        z17.tuple([
-          AddressToStringSchema
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressToStringSchema,
-          z17.number(),
-          z17.boolean()
-        ])
+        z17.tuple([AddressToStringSchema]),
+        z17.tuple([AddressToStringSchema, z17.number()]),
+        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
       ])
     },
     result: {
@@ -457,12 +372,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z17.tuple([
-        HashToStringSchema
-      ]),
-      from: z17.tuple([
-        HashFromStringSchema
-      ])
+      to: z17.tuple([HashToStringSchema]),
+      from: z17.tuple([HashFromStringSchema])
     },
     result: {
       to: SignedHydratedBlockSchema,
@@ -471,12 +382,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z17.tuple([
-        z17.number()
-      ]),
-      from: z17.tuple([
-        z17.number()
-      ])
+      to: z17.tuple([z17.number()]),
+      from: z17.tuple([z17.number()])
     },
     result: {
       to: SignedHydratedBlockSchema,
@@ -485,14 +392,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z17.tuple([
-        HashToStringSchema,
-        z17.number().optional()
-      ]),
-      from: z17.tuple([
-        HashFromStringSchema,
-        z17.number().optional()
-      ])
+      to: z17.tuple([HashToStringSchema, z17.number().optional()]),
+      from: z17.tuple([HashFromStringSchema, z17.number().optional()])
     },
     result: {
       to: z17.array(SignedHydratedBlockSchema),
@@ -541,14 +442,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z17.tuple([
-        HashToStringSchema,
-        z17.number()
-      ]),
-      from: z17.tuple([
-        HashFromStringSchema,
-        z17.number()
-      ])
+      to: z17.tuple([HashToStringSchema, z17.number()]),
+      from: z17.tuple([HashFromStringSchema, z17.number()])
     },
     result: {
       to: SignedHydratedTransactionSchema.nullable(),
@@ -557,14 +452,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z17.tuple([
-        z17.number(),
-        z17.number()
-      ]),
-      from: z17.tuple([
-        z17.number(),
-        z17.number()
-      ])
+      to: z17.tuple([z17.number(), z17.number()]),
+      from: z17.tuple([z17.number(), z17.number()])
     },
     result: {
       to: SignedHydratedTransactionSchema.nullable(),
@@ -573,12 +462,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z17.tuple([
-        HashToStringSchema
-      ]),
-      from: z17.tuple([
-        HashFromStringSchema
-      ])
+      to: z17.tuple([HashToStringSchema]),
+      from: z17.tuple([HashFromStringSchema])
     },
     result: {
       to: SignedHydratedTransactionSchema.nullable(),
@@ -597,55 +482,40 @@ var AllRpcSchemas = {
 
 // src/types/schema/createRequestSchema.ts
 import { z as z18 } from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z18.undefined()) => z18.object({
-  id: z18.union([
-    z18.string(),
-    z18.number()
-  ]),
+var createRequestSchema = (methodName, paramsSchema = z18.undefined()) => z18.object({
+  id: z18.union([z18.string(), z18.number()]),
   jsonrpc: z18.literal(jsonrpc),
   method: z18.literal(methodName),
   params: paramsSchema
-}), "createRequestSchema");
+});
 
 // src/types/schema/createResponseSchema.ts
 import { z as z19 } from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z19.undefined()) => z19.object({
-  id: z19.union([
-    z19.string(),
-    z19.number()
-  ]),
+var createResponseSchema = (resultSchema = z19.undefined()) => z19.object({
+  id: z19.union([z19.string(), z19.number()]),
   jsonrpc: z19.literal(jsonrpc),
   result: resultSchema
-}), "createResponseSchema");
+});
 
 // src/types/schema/XyoGatewayRpcSchemas.ts
 import { z as z20 } from "zod";
 var ChainConnectionSchema = z20.object({
-  chainId: z20.union([
-    z20.string(),
-    z20.custom()
-  ]).optional(),
+  chainId: z20.union([z20.string(), z20.custom()]).optional(),
   name: z20.string(),
   url: z20.string()
 });
-var CaveatTypesSchema = z20.enum([
-  "chain",
-  "expiration",
-  "filteredResponse",
-  "rateLimit"
-]);
+var CaveatTypesSchema = z20.enum(["chain", "expiration", "filteredResponse", "rateLimit"]);
 var CaveatsSchema = z20.object({
   type: CaveatTypesSchema,
   value: z20.unknown()
+  // JsonValue is usually unknown, adjust if you have a stricter type
 });
 var PermissionSchema = z20.object({
   capability: z20.string(),
   caveats: CaveatsSchema.array().optional(),
   invoker: z20.string()
 });
-var InvokerPermissionSchema = PermissionSchema.extend({
-  date: z20.number().optional()
-});
+var InvokerPermissionSchema = PermissionSchema.extend({ date: z20.number().optional() });
 var XyoGatewayRpcSchemas = {
   /*
   xyoGateway_addConnection: {
@@ -711,8 +581,12 @@ var XyoGatewayRpcSchemas = {
   */
   xyoGateway_submitTransaction: {
     params: {
-      from: z20.array(HydratedTransactionSchema),
-      to: z20.array(HydratedTransactionSchema)
+      from: z20.array(
+        HydratedTransactionSchema
+      ),
+      to: z20.array(
+        HydratedTransactionSchema
+      )
     },
     result: {
       from: BlockBoundWitnessSchema,
@@ -722,76 +596,67 @@ var XyoGatewayRpcSchemas = {
 };
 
 // src/engine/rpcEngineFromProvider.ts
-var rpcEngineFromProvider = /* @__PURE__ */ __name((provider) => {
+var rpcEngineFromProvider = (provider) => {
   const engine = new JsonRpcEngine();
   const handlers = rpcMethodHandlersFromProvider(provider);
-  engine.push(createAsyncMiddleware(async (req, res) => {
-    const method = req.method;
-    const handler = handlers[method];
-    const schema = AllRpcSchemas[method];
-    if (schema === void 0 || handler === void 0) {
-      res.error = JsonRpcErrorCodes.MethodNotFound;
-      return;
-    }
-    let requestSchema = requestSchemas[method];
-    if (requestSchema == void 0) {
-      requestSchema = createRequestSchema(method, schema.params.from);
-      requestSchemas[method] = requestSchema;
-    }
-    const parsed = requestSchema.safeParse(req);
-    if (!parsed.success) {
-      res.error = {
-        // Return invalid params error
-        ...JsonRpcErrorCodes.InvalidParams,
-        // with the specific validation error message
-        message: parsed.error.message
-      };
-      return;
-    }
-    const { params } = parsed.data;
-    const result = await handler(params);
-    res.result = schema.result.to.parse(result);
-  }));
+  engine.push(
+    createAsyncMiddleware(async (req, res) => {
+      const method = req.method;
+      const handler = handlers[method];
+      const schema = AllRpcSchemas[method];
+      if (schema === void 0 || handler === void 0) {
+        res.error = JsonRpcErrorCodes.MethodNotFound;
+        return;
+      }
+      let requestSchema = requestSchemas[method];
+      if (requestSchema == void 0) {
+        requestSchema = createRequestSchema(method, schema.params.from);
+        requestSchemas[method] = requestSchema;
+      }
+      const parsed = requestSchema.safeParse(req);
+      if (!parsed.success) {
+        res.error = {
+          // Return invalid params error
+          ...JsonRpcErrorCodes.InvalidParams,
+          // with the specific validation error message
+          message: parsed.error.message
+        };
+        return;
+      }
+      const { params } = parsed.data;
+      const result = await handler(params);
+      res.result = schema.result.to.parse(result);
+    })
+  );
   return engine;
-}, "rpcEngineFromProvider");
+};
 
 // src/provider/client/MemoryXyoClient.ts
 var MemoryXyoClient = class {
-  static {
-    __name(this, "MemoryXyoClient");
-  }
   gateways;
-  permissionsProvider;
-  constructor(gateways, permissionsProvider) {
+  permissions;
+  constructor(gateways, permissions) {
     this.gateways = gateways;
-    this.permissionsProvider = permissionsProvider;
+    this.permissions = permissions;
   }
 };
 
 // src/provider/client/PermissionsStore/getPermissionsStoreFromTransport.ts
-var getPermissionsStoreFromTransport = /* @__PURE__ */ __name((transport) => {
+var getPermissionsStoreFromTransport = (_transport) => {
   throw new Error("Not implemented");
-}, "getPermissionsStoreFromTransport");
+};
 
 // src/provider/client/PermissionsStore/MemoryPermissionsStore.ts
 var MemoryPermissionsStore = class {
-  static {
-    __name(this, "MemoryPermissionsStore");
-  }
   _store = /* @__PURE__ */ new Map();
   getPermissions() {
-    return [
-      ...this._store.values()
-    ];
+    return [...this._store.values()];
   }
   requestPermissions(permissions) {
     const now = Date.now();
     for (const perm of permissions) {
       const key = this.getKey(perm);
-      this._store.set(key, {
-        ...perm,
-        date: now
-      });
+      this._store.set(key, { ...perm, date: now });
     }
     return true;
   }
@@ -807,132 +672,9 @@ var MemoryPermissionsStore = class {
   }
 };
 
-// src/provider/host/Abstract.ts
-import { assertEx } from "@xylabs/assert";
-var AbstractXyoGateway = class {
-  static {
-    __name(this, "AbstractXyoGateway");
-  }
-  activeConnection() {
-    throw new Error("Deprecated method not implemented.");
-  }
-  addConnection(_config) {
-    throw new Error("Deprecated method not implemented.");
-  }
-  connections() {
-    throw new Error("Deprecated method not implemented.");
-  }
-  getPermissions() {
-    throw new Error("Deprecated method not implemented.");
-  }
-  requestPermissions(_permissions) {
-    throw new Error("Deprecated method not implemented.");
-  }
-  revokePermissions(_permissions) {
-    throw new Error("Deprecated method not implemented.");
-  }
-  async submitTransaction(elevatedPayloads, additionalPayloads) {
-    const connection = await this.connection();
-    assertEx(connection.submitTransaction, () => "Active connection does not support transaction submission");
-    const tx = await connection.submitTransaction?.(elevatedPayloads, additionalPayloads);
-    return assertEx(tx, () => "Transaction submission failed");
-  }
-};
-
-// src/provider/host/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 {
-  static {
-    __name(this, "MemoryXyoNetwork");
-  }
-  _networkId;
-  constructor(networkId) {
-    this._networkId = networkId;
-  }
-  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);
-  }
-  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;
-    }
-  }
-};
-
-// src/provider/provider/HttpRpcXyoConnection.ts
-import { isDefined as isDefined2 } from "@xylabs/typeof";
+// src/provider/connection/HttpRpcXyoConnection.ts
+import { isDefined as isDefined3, isString } from "@xylabs/typeof";
+import { isDataLakeProvider as isDataLakeProvider2 } from "@xyo-network/xl1-protocol";
 
 // src/transport/HttpRpcTransport.ts
 import { AxiosJson } from "@xylabs/axios";
@@ -940,9 +682,6 @@ import { isError, isUndefinedOrNull } from "@xylabs/typeof";
 import { isAxiosError } from "axios";
 import { v4 } from "uuid";
 var HttpRpcTransport = class {
-  static {
-    __name(this, "HttpRpcTransport");
-  }
   _rpcUrl;
   _schemas;
   constructor(rpcUrl, schemas) {
@@ -983,9 +722,6 @@ var HttpRpcTransport = class {
 import { isObject } from "@xylabs/typeof";
 import { v4 as v42 } from "uuid";
 var MemoryRpcTransport = class {
-  static {
-    __name(this, "MemoryRpcTransport");
-  }
   _rpcEngine;
   _schemas;
   requestSchemas = {};
@@ -1018,35 +754,45 @@ var MemoryRpcTransport = class {
   }
 };
 
-// src/transport/post-message/PostMessageRpcTransport.ts
+// src/transport/post-message/LegacyPostMessageRpcTransport.ts
+import {
+  isJsonRpcError,
+  isJsonRpcSuccess
+} from "@metamask/utils";
 import { isDefined } from "@xylabs/typeof";
 import { v4 as v43 } from "uuid";
 
 // src/transport/post-message/helpers.ts
-var isRpcError = /* @__PURE__ */ __name((data) => {
+var isRpcError = (data) => {
   return data && typeof data === "object" && "error" in data && data.error;
-}, "isRpcError");
+};
 
-// src/transport/post-message/SessionEnvelope.ts
-var buildSessionMessageRequest = /* @__PURE__ */ __name((data, destination) => {
-  const request = {
-    data,
-    destination,
-    sessionId: globalThis.xyo.walletExtensionId() ?? ""
-  };
-  return request;
-}, "buildSessionMessageRequest");
+// src/transport/post-message/resolveData.ts
+var hasMatchingId = (eventData, targetId) => {
+  return eventData?.id === targetId ? { legacyEventData: eventData } : false;
+};
+var hasMatchingNestedId = (eventData, targetId) => {
+  return eventData?.data?.id === targetId ? { eventData: eventData.data } : false;
+};
+var resolvedEvent = (event, targetId) => {
+  return hasMatchingId(event.data, targetId) || hasMatchingNestedId(event.data, targetId);
+};
 
-// src/transport/post-message/PostMessageRpcTransport.ts
-var PostMessageRpcTransport = class {
-  static {
-    __name(this, "PostMessageRpcTransport");
-  }
+// src/transport/post-message/LegacyPostMessageRpcTransport.ts
+var isValidBaseRpcEvent = (data) => {
+  return !!(data && typeof data === "object" && "jsonrpc" in data && data.jsonrpc === "2.0" && "method" in data && typeof data.method === "string" && "id" in data && typeof data.id === "string");
+};
+var isRpcResponse = (data, targetId) => {
+  return isValidBaseRpcEvent(data) && (isDefined(targetId) ? data.id === targetId : true) && "result" in data && Array.isArray(data.result);
+};
+var LegacyPostMessageRpcTransport = class {
   destination;
   schemas;
-  constructor(defaultDestination, schemas = XyoGatewayRpcSchemas) {
+  sessionId;
+  constructor(defaultDestination, schemas = XyoGatewayRpcSchemas, sessionId) {
     this.schemas = schemas;
     this.destination = defaultDestination;
+    this.sessionId = sessionId;
   }
   async sendRequest(method, params) {
     const id = v43();
@@ -1061,72 +807,234 @@ var PostMessageRpcTransport = class {
     body.params = isDefined(params) && isDefined(schemas[method]) ? schemas[method].params.to.parse(params) : params;
     return await new Promise((resolve, reject) => {
       const id2 = body.id;
-      const handler = /* @__PURE__ */ __name((event) => {
+      const handler = (event) => {
         if (event.origin !== globalThis.window.origin) return;
-        if (event.data.id !== id2) return;
+        if (!isRpcResponse(event.data, id2)) return;
+        const data = resolvedEvent(event, id2);
+        if (data === false) return;
         globalThis.removeEventListener("message", handler);
-        if (event.data.result.some(isRpcError)) {
-          reject(event.data.result[0]);
-        } else {
-          resolve(event.data.result[0]);
+        if (data.legacyEventData) {
+          if (data.legacyEventData.result.some(isRpcError)) {
+            reject(data.legacyEventData.result[0]);
+          } else {
+            resolve(data.legacyEventData.result[0]);
+          }
+          return;
         }
-      }, "handler");
+        if (data.eventData) {
+          if (isJsonRpcError(data.eventData)) {
+            reject(data.eventData);
+            return;
+          }
+          if (isJsonRpcSuccess(data.eventData)) {
+            resolve(data.eventData);
+            return;
+          }
+          reject(new Error("Unexpected response format"));
+        }
+      };
       globalThis.addEventListener("message", handler);
-      globalThis.postMessage(buildSessionMessageRequest(body, this.destination), globalThis.location.origin);
+      globalThis.postMessage(
+        {
+          data: body,
+          destination: this.destination,
+          sessionId: this.sessionId
+        },
+        globalThis.location.origin
+      );
+    });
+  }
+};
+var PostMessageRpcTransport = LegacyPostMessageRpcTransport;
+
+// src/transport/post-message/SessionEnvelope.ts
+var buildSessionMessageRequest = (data, destination) => {
+  const request = {
+    data,
+    destination,
+    sessionId: globalThis.xyo.walletExtensionId() ?? ""
+  };
+  return request;
+};
+
+// 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 {
+  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 } from "@xylabs/assert";
+import { isAnyPayload as isAnyPayload2 } from "@xyo-network/payload-model";
+var ArchivistXyoDataLake = class extends AbstractXyoDataLake {
+  _archivist;
+  constructor(archivist) {
+    super();
+    this._archivist = archivist;
+  }
+  async add(items) {
+    const payloads = items.filter(isAnyPayload2);
+    assertEx(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 { assertEx as assertEx2 } from "@xylabs/assert";
+import { AxiosJson as AxiosJson2 } from "@xylabs/axios";
+import { exists } from "@xylabs/exists";
+import { isArrayBuffer, isDefined as isDefined2 } 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 {
+  _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 (isDefined2(result)) {
+          assertEx2(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 (isDefined2(result)) {
+          assertEx2(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 (!isAnyPayload3(result.data)) {
+      throw new Error("Invalid response from server (expected a Payload)");
+    }
+    return result.data;
+  }
+  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}`);
+      }
+      if (!isAnyPayload3(response.data)) {
+        throw new Error("Invalid response from server (expected a Payload)");
+      }
+      return response.data;
     });
   }
 };
 
 // src/provider/runner/JsonRpcXyoRunner.ts
 var JsonRpcXyoRunner = class {
-  static {
-    __name(this, "JsonRpcXyoRunner");
-  }
   transport;
   constructor(transport) {
     this.transport = transport;
   }
   async broadcastTransaction(transaction) {
-    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [
-      transaction
-    ]);
+    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [transaction]);
   }
 };
 
 // src/provider/runner/MemoryXyoRunner.ts
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
+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 PayloadBuilder.hash(transaction[0]);
+    return await PayloadBuilder2.hash(transaction[0]);
   }
   async getArchivist() {
     if (!this._archivist) {
-      this._archivist = await MemoryArchivist.create({
-        account: "random"
-      });
+      this._archivist = await MemoryArchivist.create({ account: "random" });
     }
     return this._archivist;
   }
 };
 
 // src/provider/runner/NodeXyoRunner.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } 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 {
-  static {
-    __name(this, "NodeXyoRunner");
-  }
   // TODO: Make configurable with defaults
   node;
   pendingArchivistPath = "XYOChain:Pending:PendingTransactions";
@@ -1137,33 +1045,28 @@ var NodeXyoRunner = class {
   async broadcastTransaction(transaction) {
     const flattened = flattenHydratedTransaction2(transaction);
     const pendingArchivist = await this.getPendingArchivist();
-    const txHash = await PayloadBuilder2.hash(transaction[0]);
+    const txHash = await PayloadBuilder3.hash(transaction[0]);
     const payloadBundle = {
       schema: PayloadBundleSchema,
       payloads: flattened,
       root: txHash
     };
-    await pendingArchivist.insert([
-      payloadBundle
-    ]);
+    await pendingArchivist.insert([payloadBundle]);
     return txHash;
   }
-  getArchivist = /* @__PURE__ */ __name(async (identifier) => {
+  getArchivist = async (identifier) => {
     const archivist = await this.node.resolve(identifier);
-    return assertEx2(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
-  }, "getArchivist");
-  getPendingArchivist = /* @__PURE__ */ __name(async () => {
+    return assertEx3(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+  };
+  getPendingArchivist = async () => {
     if (this._pendingArchivist) return this._pendingArchivist;
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
-    return assertEx2(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${this.pendingArchivistPath}`);
-  }, "getPendingArchivist");
+    return assertEx3(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${this.pendingArchivistPath}`);
+  };
 };
 
 // src/provider/signer/JsonRpcXyoSigner.ts
 var RpcXyoSigner = class {
-  static {
-    __name(this, "RpcXyoSigner");
-  }
   transport;
   constructor(transport) {
     this.transport = transport;
@@ -1187,17 +1090,11 @@ var RpcXyoSigner = class {
   }
 };
 var JsonRpcXyoSigner = class extends RpcXyoSigner {
-  static {
-    __name(this, "JsonRpcXyoSigner");
-  }
 };
 
 // src/provider/signer/MemoryXyoSigner.ts
 import { buildTransaction } from "@xyo-network/xl1-protocol-sdk";
 var MemoryXyoSigner = class {
-  static {
-    __name(this, "MemoryXyoSigner");
-  }
   _account;
   constructor(account) {
     this._account = account;
@@ -1207,7 +1104,16 @@ var MemoryXyoSigner = class {
   }
   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);
+    const transaction = await buildTransaction(
+      chain,
+      elevatedPayloads,
+      additionalPayloads,
+      this._account,
+      nbf,
+      exp,
+      fromAddress,
+      fees
+    );
     return transaction[0];
   }
   signTransaction(_tx) {
@@ -1217,38 +1123,24 @@ var MemoryXyoSigner = class {
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
 var JsonRpcXyoViewer = class {
-  static {
-    __name(this, "JsonRpcXyoViewer");
-  }
   transport;
   constructor(transport) {
     this.transport = transport;
   }
   async accountBalance(address) {
-    return await this.transport.sendRequest("xyoViewer_accountBalance", [
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_accountBalance", [address]);
   }
   async accountHistory(address) {
-    return await this.transport.sendRequest("xyoViewer_accountBalance", [
-      address
-    ]);
+    return await this.transport.sendRequest("xyoViewer_accountBalance", [address]);
   }
   async blockByHash(hash) {
-    return await this.transport.sendRequest("xyoViewer_blockByHash", [
-      hash
-    ]);
+    return await this.transport.sendRequest("xyoViewer_blockByHash", [hash]);
   }
   async blockByNumber(blockNumber) {
-    return await this.transport.sendRequest("xyoViewer_blockByNumber", [
-      blockNumber
-    ]);
+    return await this.transport.sendRequest("xyoViewer_blockByNumber", [blockNumber]);
   }
   async blocksByHash(hash, limit) {
-    return await this.transport.sendRequest("xyoViewer_blocksByHash", [
-      hash,
-      limit
-    ]);
+    return await this.transport.sendRequest("xyoViewer_blocksByHash", [hash, limit]);
   }
   async chainId() {
     return await this.transport.sendRequest("xyoViewer_chainId");
@@ -1263,34 +1155,23 @@ var JsonRpcXyoViewer = class {
     return await this.transport.sendRequest("xyoViewer_currentBlockNumber");
   }
   async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
-    return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [
-      blockHash,
-      transactionIndex
-    ]);
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [blockHash, transactionIndex]);
   }
   async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
-    return await this.transport.sendRequest("xyoViewer_transactionByBlockNumberAndIndex", [
-      blockNumber,
-      transactionIndex
-    ]);
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockNumberAndIndex", [blockNumber, transactionIndex]);
   }
   async transactionByHash(transactionHash) {
-    return await this.transport.sendRequest("xyoViewer_transactionByHash", [
-      transactionHash
-    ]);
+    return await this.transport.sendRequest("xyoViewer_transactionByHash", [transactionHash]);
   }
 };
 
-// src/provider/provider/XyoConnection.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import { isAnyPayload } from "@xyo-network/payload-model";
+// src/provider/connection/XyoConnection.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { isAnyPayload as isAnyPayload4 } from "@xyo-network/payload-model";
 import { defaultTransactionFees, isDataLakeProvider } from "@xyo-network/xl1-protocol";
 import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
 var XyoConnection = class {
-  static {
-    __name(this, "XyoConnection");
-  }
   _network;
   _runner;
   _signer;
@@ -1309,6 +1190,7 @@ var XyoConnection = class {
   get runner() {
     return this._runner;
   }
+  /** @deprecated use signer from gateway instead */
   get signer() {
     return this._signer;
   }
@@ -1328,10 +1210,17 @@ var XyoConnection = class {
       fees
     }))[0];
   }
-  async submitTransaction(elevatedPayloads, additionalPayloads, { chain, exp, fees, from, nbf } = {}) {
-    const viewer = assertEx3(this.viewer, () => "No viewer available");
-    const signer = assertEx3(this.signer, () => "No signer available");
-    const runner = assertEx3(this.runner, () => "No runner available");
+  /** @deprecated use addPayloadsToChain from gateway instead */
+  async submitTransaction(elevatedPayloads, additionalPayloads, {
+    chain,
+    exp,
+    fees,
+    from,
+    nbf
+  } = {}) {
+    const viewer = assertEx4(this.viewer, () => "No viewer available");
+    const signer = assertEx4(this.signer, () => "No signer available");
+    const runner = assertEx4(this.runner, () => "No runner available");
     const storage = this.storage;
     const chainResolved = chain ?? await viewer.chainId();
     if (chainResolved === void 0) throw new Error("Failed to determine chain");
@@ -1340,59 +1229,190 @@ var XyoConnection = class {
     const feesResolved = fees ?? defaultTransactionFees;
     const fromResolved = from ?? await signer.address();
     if (fromResolved === void 0) throw new Error("Failed to determine from address");
-    const signedTransaction = assertEx3(await signer.createSignedTransaction(chainResolved, elevatedPayloads, additionalPayloads, nbfResolved, expResolved, feesResolved, fromResolved), () => "Failed to create transaction");
+    const signedTransaction = assertEx4(await signer.createSignedTransaction(
+      chainResolved,
+      elevatedPayloads,
+      additionalPayloads,
+      nbfResolved,
+      expResolved,
+      feesResolved,
+      fromResolved
+    ), () => "Failed to create transaction");
     const hydratedTransaction = [
-      await PayloadBuilder3.addStorageMeta(signedTransaction),
-      await PayloadBuilder3.addStorageMeta(elevatedPayloads)
+      await PayloadBuilder4.addStorageMeta(signedTransaction),
+      await PayloadBuilder4.addStorageMeta(elevatedPayloads)
     ];
     if (isDataLakeProvider(storage)) {
       const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction);
-      await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload));
+      await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload4));
     }
-    assertEx3(await runner.broadcastTransaction(hydratedTransaction), () => "Failed to broadcast transaction");
+    assertEx4(await runner.broadcastTransaction(hydratedTransaction), () => "Failed to broadcast transaction");
     return hydratedTransaction;
   }
 };
 
-// src/provider/provider/HttpRpcXyoConnection.ts
+// src/provider/connection/HttpRpcXyoConnection.ts
 var HttpRpcXyoConnection = class extends XyoConnection {
-  static {
-    __name(this, "HttpRpcXyoConnection");
-  }
   constructor(params) {
-    const { account, endpoint } = params;
-    const signer = isDefined2(account) ? new MemoryXyoSigner(account) : void 0;
-    const transport = new HttpRpcTransport(endpoint, {
-      ...XyoRunnerRpcSchemas,
-      ...XyoViewerRpcSchemas
-    });
+    const {
+      account,
+      endpoint,
+      storage: storageParam
+    } = params;
+    const signer = isDefined3(account) ? new MemoryXyoSigner(account) : void 0;
+    const transport = new HttpRpcTransport(endpoint, { ...XyoRunnerRpcSchemas, ...XyoViewerRpcSchemas });
     const runner = new JsonRpcXyoRunner(transport);
     const viewer = new JsonRpcXyoViewer(transport);
+    const storage = isDataLakeProvider2(storageParam) ? storageParam : isString(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
     super({
       signer,
       runner,
-      viewer
+      viewer,
+      storage
     });
   }
 };
 var RpcXyoConnection = class extends HttpRpcXyoConnection {
-  static {
-    __name(this, "RpcXyoConnection");
+};
+
+// src/provider/gateway/Abstract.ts
+import { assertEx as assertEx5 } from "@xylabs/assert";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
+var AbstractXyoGateway = class {
+  async addPayloadsToChain(onChain, offChain) {
+    const connection = await this.connection();
+    const viewer = assertEx5(connection.viewer, () => "No viewer available on connection");
+    const signer = await this.signer();
+    const chainId = await viewer.chainId();
+    const nbf = await viewer.currentBlockNumber();
+    const tx = await buildUnsignedTransaction(chainId, onChain, offChain, nbf, nbf + 1e3, await signer.address());
+    const hash = await this.addTransactionToChain(tx);
+    return [hash, tx];
+  }
+  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 PayloadBuilder5.addStorageMeta(signedTx[0]),
+        await PayloadBuilder5.addStorageMeta(signedTx[1])
+      ]
+    );
+  }
+  /** @deprecated use addPayloadsToChain instead */
+  async submitTransaction(elevatedPayloads, additionalPayloads) {
+    const connection = await this.connection();
+    assertEx5(connection.submitTransaction, () => "Active connection does not support transaction submission");
+    const tx = await connection.submitTransaction?.(elevatedPayloads, additionalPayloads);
+    return assertEx5(tx, () => "Transaction submission failed");
+  }
+};
+
+// src/provider/gateway/MemoryXyoGateway.ts
+var MemoryXyoGateway = class extends AbstractXyoGateway {
+  _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 {
+  _networkId;
+  constructor(networkId) {
+    this._networkId = networkId;
+  }
+  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);
+  }
+  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;
+    }
   }
 };
 export {
+  AbstractXyoDataLake,
   AbstractXyoGateway,
   AllRpcSchemas,
+  ArchivistXyoDataLake,
   CaveatTypesSchema,
   CaveatsSchema,
   ChainConnectionSchema,
   HttpRpcTransport,
   HttpRpcXyoConnection,
+  HttpXyoDataLake,
   InvokerPermissionSchema,
   JsonRpcErrorCodes,
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoViewer,
+  LegacyPostMessageRpcTransport,
   MemoryPermissionsStore,
   MemoryRpcTransport,
   MemoryXyoClient,