@xyo-network/xl1-rpc 1.12.0 → 1.12.2

package/dist/node/index-node.mjs

@@ -1,85 +1,103 @@
+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 = (runner) => {
-  return { xyoRunner_broadcastTransaction: (params) => runner.broadcastTransaction(...params ?? []) };
-};
+var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
+  return {
+    xyoRunner_broadcastTransaction: /* @__PURE__ */ __name((params) => runner.broadcastTransaction(...params ?? []), "xyoRunner_broadcastTransaction")
+  };
+}, "rpcMethodHandlersFromRunner");
 
 // src/engine/rpcMethodHandlersFromSigner.ts
-var rpcMethodHandlersFromSigner = (signer) => {
+var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
   return {
-    xyoSigner_address: (params) => signer.address(...params ?? []),
-    xyoSigner_createSignedTransaction: (params) => signer.createSignedTransaction(...params ?? []),
-    xyoSigner_signTransaction: (params) => signer.signTransaction(...params ?? [])
+    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")
   };
-};
+}, "rpcMethodHandlersFromSigner");
 
 // src/engine/rpcMethodHandlersFromViewer.ts
-var rpcMethodHandlersFromViewer = (viewer) => {
+var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
   return {
-    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 ?? [])
+    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")
   };
-};
+}, "rpcMethodHandlersFromViewer");
 
 // src/engine/rpcMethodHandlersFromProvider.ts
-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) };
+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)
+  };
   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
 var jsonrpc = "2.0";
 
 // src/types/schema/XyoProviderRpcSchemas.ts
-import { z as z13 } from "zod";
+import * as z13 from "zod";
 
 // src/types/schema/common/Address.ts
-import { toAddress } from "@xylabs/hex";
-import { AddressRegEx } from "@xyo-network/payload-wrapper";
-import { z } from "zod";
-var CompiledAddressRegEx = new RegExp(AddressRegEx);
-var AddressZod = z.string().toLowerCase().regex(CompiledAddressRegEx).transform((v) => toAddress(v));
+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/AllowedBlockPayload.ts
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { SchemaSchema } from "@xyo-network/core-payload-plugins";
-import {
-  ChainStakeIntentSchema,
-  HashSchema,
-  TransferSchema
-} from "@xyo-network/xl1-protocol";
-import z2 from "zod";
+import { ChainStakeIntentSchema, HashSchema, TransferSchema } from "@xyo-network/xl1-protocol";
+import * as z2 from "zod";
 var AllowedBlockPayloadSchemas = [
   BoundWitnessSchema,
   ChainStakeIntentSchema,
@@ -87,34 +105,41 @@ var AllowedBlockPayloadSchemas = [
   SchemaSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadZod = z2.object({ schema: z2.enum(AllowedBlockPayloadSchemas) });
+var AllowedBlockPayloadZod = z2.object({
+  schema: z2.enum(AllowedBlockPayloadSchemas)
+});
 
 // src/types/schema/common/BlockBoundWitness.ts
 import { HexZod as HexZod2 } from "@xylabs/hex";
-import { z as z7 } from "zod";
+import * as z7 from "zod";
 
 // src/types/schema/common/BoundWitness.ts
 import { HashZod, HexZod } from "@xylabs/hex";
 import { BoundWitnessSchema as BoundWitnessSchema2 } from "@xyo-network/boundwitness-model";
-import { z as z5 } from "zod";
+import * as z5 from "zod";
 
 // src/types/schema/common/Payload.ts
 import { HashToJsonZod } from "@xylabs/hex";
-import { z as z4 } from "zod";
+import * as z4 from "zod";
 
 // src/types/schema/common/Sequence.ts
-import { toHex } from "@xylabs/hex";
+import { HexRegExMinMax, toHex } from "@xylabs/hex";
 import { SequenceConstants } from "@xyo-network/payload-model";
-import { HexRegExMinMax } from "@xyo-network/payload-wrapper";
-import { z as z3 } from "zod";
+import * as z3 from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
 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 = z3.string().regex(QualifiedSequenceRegex);
 var QualifiedSequenceFromStringZod = z3.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z3.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z3.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var SequenceToStringZod = z3.union([
+  LocalSequenceToStringZod,
+  QualifiedSequenceToStringZod
+]);
+var SequenceFromStringZod = z3.union([
+  LocalSequenceFromStringZod,
+  QualifiedSequenceFromStringZod
+]);
 
 // src/types/schema/common/Payload.ts
 var StorageMetaZod = z4.object({
@@ -123,13 +148,16 @@ var StorageMetaZod = z4.object({
   _sequence: SequenceToStringZod
 });
 var SchemaZod = z4.string();
-var PayloadZod = z4.object({ schema: SchemaZod }).catchall(z4.any());
+var PayloadZod = z4.object({
+  schema: SchemaZod
+}).catchall(z4.any());
 var PayloadWithStorageMetaZod = PayloadZod.extend(StorageMetaZod.shape);
 var AnyPayloadZod = PayloadZod.catchall(z4.json());
 var AnyPayloadWithStorageMetaZod = AnyPayloadZod.extend(StorageMetaZod.shape);
 function WithStorageMetaZod(valueZod) {
   return StorageMetaZod.extend(valueZod.shape);
 }
+__name(WithStorageMetaZod, "WithStorageMetaZod");
 
 // src/types/schema/common/BoundWitness.ts
 var BoundWitnessRequiredFieldsZod = z5.object({
@@ -141,24 +169,33 @@ var BoundWitnessRequiredFieldsZod = z5.object({
 var BoundWitnessMetaZod = z5.object({
   $destination: AddressZod.optional(),
   $sourceQuery: HashZod.optional(),
-  $signatures: z5.array(z5.union([HexZod, z5.null()]))
+  $signatures: z5.array(z5.union([
+    HexZod,
+    z5.null()
+  ]))
+});
+var BoundWitnessZod = PayloadZod.extend({
+  schema: z5.literal(BoundWitnessSchema2)
+}).extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape).refine((data) => data.$signatures.length === data.addresses.length, {
+  message: "$signatures length must equal addresses length"
 });
-var BoundWitnessZod = PayloadZod.extend({ schema: z5.literal(BoundWitnessSchema2) }).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(z5.any());
-var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), { message: "all $signatures must be null" });
+var UnsignedBoundWitnessZod = BoundWitnessZod.refine((data) => data.$signatures.includes(null), {
+  message: "all $signatures must be null"
+});
 var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z5.any());
 var UnsignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessZod.extend(BoundWitnessRequiredFieldsZod.shape).extend(BoundWitnessMetaZod.shape);
-var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), { message: "all $signatures must not be null" });
+var SignedBoundWitnessZod = BoundWitnessZod.refine((data) => !data.$signatures.includes(null), {
+  message: "all $signatures must not be null"
+});
 var SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod;
 var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z5.any());
 var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z5.any());
 
 // src/types/schema/common/Chain.ts
-import { toAddress as toAddress2 } from "@xylabs/hex";
-import { AddressRegEx as AddressRegEx2 } from "@xyo-network/payload-wrapper";
-import { z as z6 } from "zod";
-var CompiledAddressRegEx2 = new RegExp(AddressRegEx2);
-var ChainZod = z6.string().toLowerCase().regex(CompiledAddressRegEx2).transform((v) => toAddress2(v));
+import { AddressRegEx as AddressRegEx2, toAddress as toAddress2 } from "@xylabs/hex";
+import * as z6 from "zod";
+var ChainZod = z6.string().toLowerCase().regex(AddressRegEx2).transform((v) => toAddress2(v));
 
 // src/types/schema/common/BlockBoundWitness.ts
 var BlockNumberZod = z7.number().int().nonnegative();
@@ -169,14 +206,16 @@ var BlockBoundWitnessFieldsZod = z7.object({
   protocol: z7.number().optional(),
   step_hashes: z7.array(HexZod2).optional()
 });
-var BlockBoundWitnessMetaZod = z7.object({ $epoch: z7.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);
 var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 var SignedBlockBoundWitnessWithStorageMetaZod = SignedBoundWitnessWithStorageMetaZod.merge(StorageMetaZod.partial()).merge(BlockBoundWitnessFieldsZod).merge(BlockBoundWitnessMetaZod);
 
 // src/types/schema/common/HydratedBlock.ts
-import { z as z8 } from "zod";
+import * as z8 from "zod";
 var HydratedBlockZod = z8.tuple([
   BlockBoundWitnessZod,
   z8.array(PayloadZod)
@@ -201,19 +240,15 @@ var SignedHydratedBlockWithStorageMetaZod = z8.tuple([
 // src/types/schema/common/HydratedTransaction.ts
 import { asAnyPayload } from "@xyo-network/payload-model";
 import { asSignedHydratedTransaction } from "@xyo-network/xl1-protocol";
-import { z as z11 } from "zod";
+import * as z11 from "zod";
 
 // src/types/schema/common/TransactionBoundWitness.ts
-import { z as z10 } from "zod";
+import * as z10 from "zod";
 
 // src/types/schema/common/TransactionFees.ts
-import {
-  BigIntToJsonZod,
-  HexZod as HexZod3,
-  JsonToBigIntZod
-} from "@xylabs/hex";
+import { BigIntToJsonZod, HexZod as HexZod3, JsonToBigIntZod } from "@xylabs/hex";
 import { asAttoXL1 } from "@xyo-network/xl1-protocol";
-import { z as z9 } from "zod";
+import * as z9 from "zod";
 var AttoZod = z9.bigint();
 var AttoFromStringZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
 var TransactionFeesHexZod = z9.object({
@@ -242,12 +277,26 @@ var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) =>
 }));
 
 // src/types/schema/common/TransactionBoundWitness.ts
-var BlockStartZod = z10.object({ nbf: BlockNumberZod });
-var BlockEndZod = z10.object({ exp: BlockNumberZod });
-var BlockDurationZod = z10.object({ nbf: BlockNumberZod, exp: BlockNumberZod });
-var BlockScriptsZod = z10.object({ script: z10.array(z10.string()).optional() });
-var WithTransactionFeesZod = z10.object({ fees: TransactionFeesHexZod });
-var TransactionBoundWitnessFields = z10.object({ chain: ChainZod, from: ChainZod });
+var BlockStartZod = z10.object({
+  nbf: BlockNumberZod
+});
+var BlockEndZod = z10.object({
+  exp: BlockNumberZod
+});
+var BlockDurationZod = z10.object({
+  nbf: BlockNumberZod,
+  exp: BlockNumberZod
+});
+var BlockScriptsZod = z10.object({
+  script: z10.array(z10.string()).optional()
+});
+var WithTransactionFeesZod = z10.object({
+  fees: TransactionFeesHexZod
+});
+var TransactionBoundWitnessFields = z10.object({
+  chain: ChainZod,
+  from: ChainZod
+});
 var TransactionBoundWitnessZod = UnsignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod);
 var SignedTransactionBoundWitnessZod = SignedBoundWitnessZod.merge(StorageMetaZod.partial()).merge(BlockDurationZod).merge(WithTransactionFeesZod).merge(TransactionBoundWitnessFields).merge(BlockScriptsZod.partial());
 
@@ -264,23 +313,17 @@ var SignedHydratedTransactionZod = z11.tuple([
   SignedTransactionBoundWitnessZod,
   z11.array(PayloadZod)
 ]);
-var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([
-  tx,
-  payloads
-]) => asSignedHydratedTransaction([
+var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
   tx,
   payloads.map((payload) => payload)
 ]));
-var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([
-  tx,
-  payloads
-]) => [
+var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => [
   asSignedHydratedTransaction(tx),
   payloads.map((p) => asAnyPayload(p))
 ]);
 
 // src/types/schema/common/Json.ts
-import { z as z12 } from "zod";
+import * as z12 from "zod";
 var JsonValueZod = z12.lazy(() => z12.union([
   z12.string(),
   z12.number(),
@@ -288,7 +331,6 @@ var JsonValueZod = z12.lazy(() => z12.union([
   z12.null(),
   z12.array(JsonValueZod),
   z12.record(z12.string(), JsonValueZod)
-  // object with string keys and JSON values
 ]));
 var JsonObjectZod = z12.record(z12.string(), JsonValueZod);
 
@@ -324,12 +366,16 @@ var XyoProviderRpcSchemas = {
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod as HashToJsonZod2, JsonToHashZod } from "@xylabs/hex";
-import { z as z14 } from "zod";
+import * as z14 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z14.tuple([SignedHydratedTransactionZod]),
-      from: z14.tuple([SignedHydratedTransactionZod])
+      to: z14.tuple([
+        SignedHydratedTransactionZod
+      ]),
+      from: z14.tuple([
+        SignedHydratedTransactionZod
+      ])
     },
     result: {
       to: HashToJsonZod2,
@@ -339,7 +385,7 @@ var XyoRunnerRpcSchemas = {
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { z as z15 } from "zod";
+import * as z15 from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
@@ -380,8 +426,12 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z15.tuple([UnsignedHydratedTransactionZod]),
-      from: z15.tuple([UnsignedHydratedTransactionZod])
+      to: z15.tuple([
+        UnsignedHydratedTransactionZod
+      ]),
+      from: z15.tuple([
+        UnsignedHydratedTransactionZod
+      ])
     },
     result: {
       to: SignedHydratedTransactionZod,
@@ -391,26 +441,38 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import {
-  BigIntToJsonZod as BigIntToJsonZod2,
-  HashToJsonZod as HashToJsonZod3,
-  HashZod as HashZod2,
-  JsonToBigIntZod as JsonToBigIntZod2,
-  JsonToHashZod as JsonToHashZod2
-} from "@xylabs/hex";
-import { z as z16 } from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod2, HashToJsonZod as HashToJsonZod3, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod2, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
+import * as z16 from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_accountBalance: {
     params: {
       to: z16.union([
-        z16.tuple([AddressZod]),
-        z16.tuple([AddressZod, z16.number()]),
-        z16.tuple([AddressZod, z16.number(), z16.boolean()])
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ]),
       from: z16.union([
-        z16.tuple([AddressZod]),
-        z16.tuple([AddressZod, z16.number()]),
-        z16.tuple([AddressZod, z16.number(), z16.boolean()])
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ])
     },
     result: {
@@ -421,25 +483,55 @@ var XyoViewerRpcSchemas = {
   xyoViewer_accountHistory: {
     params: {
       to: z16.union([
-        z16.tuple([AddressZod]),
-        z16.tuple([AddressZod, z16.number()]),
-        z16.tuple([AddressZod, z16.number(), z16.boolean()])
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ]),
       from: z16.union([
-        z16.tuple([AddressZod]),
-        z16.tuple([AddressZod, z16.number()]),
-        z16.tuple([AddressZod, z16.number(), z16.boolean()])
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ])
     },
     result: {
-      to: z16.array(z16.tuple([HashZod2, HashZod2, PayloadZod])),
-      from: z16.array(z16.tuple([HashZod2, HashZod2, PayloadZod]))
+      to: z16.array(z16.tuple([
+        HashZod2,
+        HashZod2,
+        PayloadZod
+      ])),
+      from: z16.array(z16.tuple([
+        HashZod2,
+        HashZod2,
+        PayloadZod
+      ]))
     }
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z16.tuple([HashToJsonZod3]),
-      from: z16.tuple([JsonToHashZod2])
+      to: z16.tuple([
+        HashToJsonZod3
+      ]),
+      from: z16.tuple([
+        JsonToHashZod2
+      ])
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -448,8 +540,12 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z16.tuple([z16.number()]),
-      from: z16.tuple([z16.number()])
+      to: z16.tuple([
+        z16.number()
+      ]),
+      from: z16.tuple([
+        z16.number()
+      ])
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -458,8 +554,14 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z16.tuple([HashZod2, z16.number().optional()]),
-      from: z16.tuple([HashZod2, z16.number().optional()])
+      to: z16.tuple([
+        HashZod2,
+        z16.number().optional()
+      ]),
+      from: z16.tuple([
+        HashZod2,
+        z16.number().optional()
+      ])
     },
     result: {
       to: z16.array(SignedHydratedBlockZod),
@@ -508,8 +610,14 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z16.tuple([HashZod2, z16.number()]),
-      from: z16.tuple([HashZod2, z16.number()])
+      to: z16.tuple([
+        HashZod2,
+        z16.number()
+      ]),
+      from: z16.tuple([
+        HashZod2,
+        z16.number()
+      ])
     },
     result: {
       to: SignedHydratedTransactionZod.nullable(),
@@ -518,8 +626,14 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z16.tuple([z16.number(), z16.number()]),
-      from: z16.tuple([z16.number(), z16.number()])
+      to: z16.tuple([
+        z16.number(),
+        z16.number()
+      ]),
+      from: z16.tuple([
+        z16.number(),
+        z16.number()
+      ])
     },
     result: {
       to: SignedHydratedTransactionZod.nullable(),
@@ -528,8 +642,12 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z16.tuple([HashZod2]),
-      from: z16.tuple([HashZod2])
+      to: z16.tuple([
+        HashZod2
+      ]),
+      from: z16.tuple([
+        HashZod2
+      ])
     },
     result: {
       to: SignedHydratedTransactionZod.nullable(),
@@ -547,41 +665,56 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import { z as z17 } from "zod";
-var createRequestSchema = (methodName, paramsSchema = z17.undefined()) => z17.object({
-  id: z17.union([z17.string(), z17.number()]),
+import * as z17 from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z17.undefined()) => z17.object({
+  id: z17.union([
+    z17.string(),
+    z17.number()
+  ]),
   jsonrpc: z17.literal(jsonrpc),
   method: z17.literal(methodName),
   params: paramsSchema
-});
+}), "createRequestSchema");
 
 // src/types/schema/createResponseSchema.ts
-import { z as z18 } from "zod";
-var createResponseSchema = (resultSchema = z18.undefined()) => z18.object({
-  id: z18.union([z18.string(), z18.number()]),
+import * as z18 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z18.undefined()) => z18.object({
+  id: z18.union([
+    z18.string(),
+    z18.number()
+  ]),
   jsonrpc: z18.literal(jsonrpc),
   result: resultSchema
-});
+}), "createResponseSchema");
 
 // src/types/schema/XyoGatewayRpcSchemas.ts
-import { z as z19 } from "zod";
+import * as z19 from "zod";
 var ChainConnectionZod = z19.object({
-  chainId: z19.union([z19.string(), z19.custom()]).optional(),
+  chainId: z19.union([
+    z19.string(),
+    z19.custom()
+  ]).optional(),
   name: z19.string(),
   url: z19.string()
 });
-var CaveatTypesZod = z19.enum(["chain", "expiration", "filteredResponse", "rateLimit"]);
+var CaveatTypesZod = z19.enum([
+  "chain",
+  "expiration",
+  "filteredResponse",
+  "rateLimit"
+]);
 var CaveatsZod = z19.object({
   type: CaveatTypesZod,
   value: z19.unknown()
-  // JsonValue is usually unknown, adjust if you have a stricter type
 });
 var PermissionZod = z19.object({
   capability: z19.string(),
   caveats: CaveatsZod.array().optional(),
   invoker: z19.string()
 });
-var InvokerPermissionZod = PermissionZod.extend({ date: z19.number().optional() });
+var InvokerPermissionZod = PermissionZod.extend({
+  date: z19.number().optional()
+});
 var XyoGatewayRpcSchemas = {
   /*
   xyoGateway_addConnection: {
@@ -647,12 +780,8 @@ var XyoGatewayRpcSchemas = {
   */
   xyoGateway_submitTransaction: {
     params: {
-      from: z19.array(
-        HydratedTransactionZod
-      ),
-      to: z19.array(
-        HydratedTransactionZod
-      )
+      from: z19.array(HydratedTransactionZod),
+      to: z19.array(HydratedTransactionZod)
     },
     result: {
       from: BlockBoundWitnessZod,
@@ -662,43 +791,44 @@ var XyoGatewayRpcSchemas = {
 };
 
 // src/engine/rpcEngineFromProvider.ts
-var rpcEngineFromProvider = (provider) => {
+var rpcEngineFromProvider = /* @__PURE__ */ __name((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;
   permissions;
   constructor(gateways, permissions) {
@@ -708,21 +838,29 @@ var MemoryXyoClient = class {
 };
 
 // src/provider/client/PermissionsStore/getPermissionsStoreFromTransport.ts
-var getPermissionsStoreFromTransport = (_transport) => {
+var getPermissionsStoreFromTransport = /* @__PURE__ */ __name((_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;
   }
@@ -748,6 +886,9 @@ 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) {
@@ -769,11 +910,11 @@ var HttpRpcTransport = class {
         body.params = schemas[method].params.to.parse(params);
       }
       const res = await new AxiosJson().post(url, body);
-      const json = res.data;
-      if (isUndefinedOrNull(json) || json.error) {
-        throw new Error(json.error.message);
+      const json2 = res.data;
+      if (isUndefinedOrNull(json2) || json2.error) {
+        throw new Error(json2.error.message);
       }
-      return schemas[method].result.from.parse(json.result);
+      return schemas[method].result.from.parse(json2.result);
     } catch (ex) {
       let message = isError(ex) ? ex.message : String(ex);
       if (isAxiosError(ex)) {
@@ -789,11 +930,14 @@ import { assertEx } from "@xylabs/assert";
 import { isObject, isString } from "@xylabs/typeof";
 import { v4 as v42 } from "uuid";
 var MemoryRpcTransport = class {
+  static {
+    __name(this, "MemoryRpcTransport");
+  }
   _rpcEngine;
   _schemas;
   requestSchemas = {};
   responseSchemas = {};
-  constructor(rpcEngine, schemas = AllRpcSchemas) {
+  constructor(rpcEngine, schemas) {
     this._rpcEngine = rpcEngine;
     this._schemas = schemas;
   }
@@ -823,37 +967,41 @@ var MemoryRpcTransport = class {
 };
 
 // src/transport/post-message/LegacyPostMessageRpcTransport.ts
-import {
-  isJsonRpcError,
-  isJsonRpcSuccess
-} from "@metamask/utils";
+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 = (data) => {
+var isRpcError = /* @__PURE__ */ __name((data) => {
   return data && typeof data === "object" && "error" in data && data.error;
-};
+}, "isRpcError");
 
 // 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) => {
+var hasMatchingId = /* @__PURE__ */ __name((eventData, targetId) => {
+  return eventData?.id === targetId ? {
+    legacyEventData: eventData
+  } : false;
+}, "hasMatchingId");
+var hasMatchingNestedId = /* @__PURE__ */ __name((eventData, targetId) => {
+  return eventData?.data?.id === targetId ? {
+    eventData: eventData.data
+  } : false;
+}, "hasMatchingNestedId");
+var resolvedEvent = /* @__PURE__ */ __name((event, targetId) => {
   return hasMatchingId(event.data, targetId) || hasMatchingNestedId(event.data, targetId);
-};
+}, "resolvedEvent");
 
 // src/transport/post-message/LegacyPostMessageRpcTransport.ts
-var isValidBaseRpcEvent = (data) => {
+var isValidBaseRpcEvent = /* @__PURE__ */ __name((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) => {
+}, "isValidBaseRpcEvent");
+var isRpcResponse = /* @__PURE__ */ __name((data, targetId) => {
   return isValidBaseRpcEvent(data) && (isDefined(targetId) ? data.id === targetId : true) && "result" in data && Array.isArray(data.result);
-};
+}, "isRpcResponse");
 var LegacyPostMessageRpcTransport = class {
+  static {
+    __name(this, "LegacyPostMessageRpcTransport");
+  }
   destination;
   schemas;
   sessionId;
@@ -875,7 +1023,7 @@ var LegacyPostMessageRpcTransport = 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 = (event) => {
+      const handler = /* @__PURE__ */ __name((event) => {
         if (event.origin !== globalThis.window.origin) return;
         if (!isRpcResponse(event.data, id2)) return;
         const data = resolvedEvent(event, id2);
@@ -900,39 +1048,37 @@ var LegacyPostMessageRpcTransport = class {
           }
           reject(new Error("Unexpected response format"));
         }
-      };
+      }, "handler");
       globalThis.addEventListener("message", handler);
-      globalThis.postMessage(
-        {
-          data: body,
-          destination: this.destination,
-          sessionId: this.sessionId
-        },
-        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) => {
+var buildSessionMessageRequest = /* @__PURE__ */ __name((data, destination) => {
   const request = {
     data,
     destination,
     sessionId: globalThis.xyo.walletExtensionId() ?? ""
   };
   return request;
-};
+}, "buildSessionMessageRequest");
 
 // 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";
+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) {
@@ -941,17 +1087,32 @@ var AbstractXyoDataLake = class {
       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 [
+        ...otherPayloads,
+        ...found,
+        ...notFound
+      ];
     }
     return results;
   }
   async trace(hash) {
-    const [result] = await this.get([hash]);
+    const [result] = await this.get([
+      hash
+    ]);
     if (isHashPayload(result)) {
       const [payload, route] = await this.trace(result.hash);
-      return [payload, [result, ...route]];
+      return [
+        payload,
+        [
+          result,
+          ...route
+        ]
+      ];
     }
-    return [result, []];
+    return [
+      result,
+      []
+    ];
   }
 };
 
@@ -959,6 +1120,9 @@ var AbstractXyoDataLake = class {
 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();
@@ -983,6 +1147,9 @@ 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;
@@ -990,9 +1157,23 @@ var HttpXyoDataLake = class extends AbstractXyoDataLake {
   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" } });
+    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;
@@ -1068,12 +1249,17 @@ var HttpXyoDataLake = class extends AbstractXyoDataLake {
 
 // 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
+    ]);
   }
 };
 
@@ -1082,6 +1268,9 @@ 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();
@@ -1090,7 +1279,9 @@ var MemoryXyoRunner = class {
   }
   async getArchivist() {
     if (!this._archivist) {
-      this._archivist = await MemoryArchivist.create({ account: "random" });
+      this._archivist = await MemoryArchivist.create({
+        account: "random"
+      });
     }
     return this._archivist;
   }
@@ -1103,6 +1294,9 @@ 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";
@@ -1119,22 +1313,27 @@ var NodeXyoRunner = class {
       payloads: flattened,
       root: txHash
     };
-    await pendingArchivist.insert([payloadBundle]);
+    await pendingArchivist.insert([
+      payloadBundle
+    ]);
     return txHash;
   }
-  getArchivist = async (identifier) => {
+  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`);
-  };
-  getPendingArchivist = async () => {
+  }, "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}`);
-  };
+  }, "getPendingArchivist");
 };
 
 // src/provider/signer/JsonRpcXyoSigner.ts
 var RpcXyoSigner = class {
+  static {
+    __name(this, "RpcXyoSigner");
+  }
   transport;
   constructor(transport) {
     this.transport = transport;
@@ -1155,16 +1354,24 @@ var RpcXyoSigner = class {
     return ret;
   }
   async signTransaction(tx) {
-    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [tx]);
+    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [
+      tx
+    ]);
     return ret;
   }
 };
 var JsonRpcXyoSigner = class extends RpcXyoSigner {
+  static {
+    __name(this, "JsonRpcXyoSigner");
+  }
 };
 
 // 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;
@@ -1174,44 +1381,52 @@ 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];
   }
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this._account);
-    return [txBW, tx[1]];
+    return [
+      txBW,
+      tx[1]
+    ];
   }
 };
 
 // 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_accountHistory", [address]);
+    return await this.transport.sendRequest("xyoViewer_accountHistory", [
+      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");
@@ -1226,13 +1441,21 @@ 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
+    ]);
   }
 };
 
@@ -1243,6 +1466,9 @@ 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;
@@ -1282,13 +1508,7 @@ var XyoConnection = class {
     }))[0];
   }
   /** @deprecated use addPayloadsToChain from gateway instead */
-  async submitTransaction(elevatedPayloads, additionalPayloads, {
-    chain,
-    exp,
-    fees,
-    from,
-    nbf
-  } = {}) {
+  async submitTransaction(elevatedPayloads, additionalPayloads, { chain, exp, fees, from, nbf } = {}) {
     const viewer = assertEx5(this.viewer, () => "No viewer available");
     const signer = assertEx5(this.signer, () => "No signer available");
     const runner = assertEx5(this.runner, () => "No runner available");
@@ -1300,15 +1520,7 @@ 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 = assertEx5(await signer.createSignedTransaction(
-      chainResolved,
-      elevatedPayloads,
-      additionalPayloads,
-      nbfResolved,
-      expResolved,
-      feesResolved,
-      fromResolved
-    ), () => "Failed to create transaction");
+    const signedTransaction = assertEx5(await signer.createSignedTransaction(chainResolved, elevatedPayloads, additionalPayloads, nbfResolved, expResolved, feesResolved, fromResolved), () => "Failed to create transaction");
     const hydratedTransaction = [
       await PayloadBuilder4.addStorageMeta(signedTransaction),
       await PayloadBuilder4.addStorageMeta(elevatedPayloads)
@@ -1324,14 +1536,16 @@ var XyoConnection = class {
 
 // src/provider/connection/HttpRpcXyoConnection.ts
 var HttpRpcXyoConnection = class extends XyoConnection {
+  static {
+    __name(this, "HttpRpcXyoConnection");
+  }
   constructor(params) {
-    const {
-      account,
-      endpoint,
-      storage: storageParam
-    } = params;
+    const { account, endpoint, storage: storageParam } = params;
     const signer = isDefined3(account) ? new MemoryXyoSigner(account) : void 0;
-    const transport = new HttpRpcTransport(endpoint, { ...XyoRunnerRpcSchemas, ...XyoViewerRpcSchemas });
+    const transport = new HttpRpcTransport(endpoint, {
+      ...XyoRunnerRpcSchemas,
+      ...XyoViewerRpcSchemas
+    });
     const runner = new JsonRpcXyoRunner(transport);
     const viewer = new JsonRpcXyoViewer(transport);
     const storage = isDataLakeProvider2(storageParam) ? storageParam : isString2(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
@@ -1344,6 +1558,9 @@ var HttpRpcXyoConnection = class extends XyoConnection {
   }
 };
 var RpcXyoConnection = class extends HttpRpcXyoConnection {
+  static {
+    __name(this, "RpcXyoConnection");
+  }
 };
 
 // src/provider/gateway/Abstract.ts
@@ -1351,6 +1568,9 @@ import { assertEx as assertEx6 } from "@xylabs/assert";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var AbstractXyoGateway = class {
+  static {
+    __name(this, "AbstractXyoGateway");
+  }
   async addPayloadsToChain(onChain, offChain) {
     const connection = await this.connection();
     const viewer = assertEx6(connection.viewer, () => "No viewer available on connection");
@@ -1359,19 +1579,20 @@ var AbstractXyoGateway = class {
     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];
+    return [
+      hash,
+      tx
+    ];
   }
   async addTransactionToChain(tx) {
     const connection = await this.connection();
     const signer = await this.signer();
     const runner = assertEx6(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])
-      ]
-    );
+    return await runner.broadcastTransaction([
+      await PayloadBuilder5.addStorageMeta(signedTx[0]),
+      await PayloadBuilder5.addStorageMeta(signedTx[1])
+    ]);
   }
   /** @deprecated use addPayloadsToChain instead */
   async submitTransaction(elevatedPayloads, additionalPayloads) {
@@ -1384,6 +1605,9 @@ var AbstractXyoGateway = class {
 
 // src/provider/gateway/MemoryXyoGateway.ts
 var MemoryXyoGateway = class extends AbstractXyoGateway {
+  static {
+    __name(this, "MemoryXyoGateway");
+  }
   _connection;
   _signer;
   constructor(signer, connection) {
@@ -1438,6 +1662,9 @@ var StatusNetworks = {
 
 // src/provider/network/MemoryXyoNetwork.ts
 var MemoryXyoNetwork = class {
+  static {
+    __name(this, "MemoryXyoNetwork");
+  }
   _networkId;
   constructor(networkId) {
     this._networkId = networkId;