@xyo-network/xl1-rpc 1.11.0 → 1.12.1

package/dist/node/index-node.mjs

@@ -1,473 +1,657 @@
+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 z14 } from "zod";
+import { z as z13 } from "zod";
 
-// src/types/schema/common/AddressSchema.ts
-import { toAddress } from "@xylabs/hex";
-import { AddressRegEx } from "@xyo-network/payload-wrapper";
+// src/types/schema/common/Address.ts
+import { AddressRegEx, toAddress } from "@xylabs/hex";
 import { z } from "zod";
-var CompiledAddressRegEx = new RegExp(AddressRegEx);
-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 { HexRegEx } from "@xyo-network/payload-wrapper";
-import { z as z2 } from "zod";
-var CompiledHexRegEx = new RegExp(HexRegEx);
-var BigIntToStringSchema = z2.bigint().nonnegative().transform((x) => asHex(toHex(x)));
-var BigIntFromStringSchema = z2.string().regex(CompiledHexRegEx).transform((x) => hexToBigInt(asHex(toHex(x), true)));
-
-// src/types/schema/common/BlockBoundWitnessSchema.ts
-import { z as z9 } from "zod";
+var AddressZod = z.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
-// src/types/schema/common/BoundWitnessSchema.ts
+// src/types/schema/common/AllowedBlockPayload.ts
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import { z as z8 } from "zod";
-
-// src/types/schema/common/HashSchema.ts
-import { asHash } from "@xylabs/hex";
-import { HashRegEx } from "@xyo-network/payload-wrapper";
-import { z as z3 } from "zod";
-var HashToStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx));
-var HashFromStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx)).transform((v) => asHash(v, true));
-
-// src/types/schema/common/HexSchema.ts
-import { toHex as toHex2 } from "@xylabs/hex";
-import { HexRegEx as HexRegEx2 } from "@xyo-network/payload-wrapper";
-import { z as z4 } from "zod";
-var HexToStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2));
-var HexFromStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2)).transform((v) => toHex2(v));
+import { SchemaSchema } from "@xyo-network/core-payload-plugins";
+import { ChainStakeIntentSchema, HashSchema, TransferSchema } from "@xyo-network/xl1-protocol";
+import z2 from "zod";
+var AllowedBlockPayloadSchemas = [
+  BoundWitnessSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  SchemaSchema,
+  TransferSchema
+];
+var AllowedBlockPayloadZod = z2.object({
+  schema: z2.enum(AllowedBlockPayloadSchemas)
+});
 
-// src/types/schema/common/PayloadSchema.ts
+// src/types/schema/common/BlockBoundWitness.ts
+import { HexZod as HexZod2 } from "@xylabs/hex";
 import { z as z7 } from "zod";
 
-// src/types/schema/common/StorageMetaSchema.ts
-import { z as z6 } 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";
+
+// src/types/schema/common/Payload.ts
+import { HashToJsonZod } from "@xylabs/hex";
+import { z as z4 } from "zod";
 
-// src/types/schema/common/SequenceSchema.ts
-import { toHex as toHex3 } from "@xylabs/hex";
+// src/types/schema/common/Sequence.ts
+import { HexRegExMinMax, toHex } from "@xylabs/hex";
 import { SequenceConstants } from "@xyo-network/payload-model";
-import { HexRegExMinMax } from "@xyo-network/payload-wrapper";
-import { z as z5 } from "zod";
+import { z as z3 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringSchema = z5.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringSchema = z5.string().regex(LocalSequenceRegex).transform((v) => toHex3(v));
+var LocalSequenceToStringZod = z3.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z3.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var 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 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
+]);
 
-// src/types/schema/common/StorageMetaSchema.ts
-var StorageMetaSchema = z6.object({
-  _hash: HashToStringSchema,
-  _dataHash: HashToStringSchema,
-  _sequence: SequenceToStringSchema
+// src/types/schema/common/Payload.ts
+var StorageMetaZod = z4.object({
+  _hash: HashToJsonZod,
+  _dataHash: HashToJsonZod,
+  _sequence: SequenceToStringZod
 });
+var SchemaZod = z4.string();
+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/PayloadSchema.ts
-var PayloadSchema = z7.object({ schema: z7.string() }).passthrough();
-var PayloadWithStorageMetaSchema = PayloadSchema.extend(StorageMetaSchema.shape).passthrough();
-
-// src/types/schema/common/BoundWitnessSchema.ts
-var SchemaIdSchema = z8.string();
-var BoundWitnessRequiredFieldsSchema = z8.object({
-  addresses: z8.array(AddressToStringSchema),
-  payload_hashes: z8.array(HashToStringSchema),
-  payload_schemas: z8.array(SchemaIdSchema),
-  previous_hashes: z8.array(HashToStringSchema.nullable())
+// src/types/schema/common/BoundWitness.ts
+var BoundWitnessRequiredFieldsZod = z5.object({
+  addresses: z5.array(AddressZod),
+  payload_hashes: z5.array(HashZod),
+  payload_schemas: z5.array(SchemaZod),
+  previous_hashes: z5.array(HashZod.nullable())
+});
+var BoundWitnessMetaZod = z5.object({
+  $destination: AddressZod.optional(),
+  $sourceQuery: HashZod.optional(),
+  $signatures: z5.array(z5.union([
+    HexZod,
+    z5.null()
+  ]))
 });
-var BoundWitnessMetaSchema = z8.object({
-  $destination: AddressToStringSchema.optional(),
-  $sourceQuery: HashToStringSchema.optional()
+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 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 AnyBoundWitnessZod = BoundWitnessZod.catchall(z5.any());
+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 SignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod;
+var AnySignedBoundWitnessZod = UnsignedBoundWitnessZod.catchall(z5.any());
+var AnySignedBoundWitnessWithStorageMetaZod = UnsignedBoundWitnessWithStorageMetaZod.catchall(z5.any());
+
+// src/types/schema/common/Chain.ts
+import { AddressRegEx as AddressRegEx2, toAddress as toAddress2 } from "@xylabs/hex";
+import { z as z6 } from "zod";
+var ChainZod = z6.string().toLowerCase().regex(AddressRegEx2).transform((v) => toAddress2(v));
 
-// src/types/schema/common/BlockBoundWitnessSchema.ts
-var BlockNumberSchema = z9.number().int().nonnegative();
-var BlockBoundWitnessFieldsSchema = z9.object({
-  block: BlockNumberSchema,
-  chain: HexToStringSchema,
-  previous: HexToStringSchema.nullable(),
-  protocol: z9.number().optional(),
-  step_hashes: z9.array(HexToStringSchema).optional()
+// src/types/schema/common/BlockBoundWitness.ts
+var BlockNumberZod = z7.number().int().nonnegative();
+var BlockBoundWitnessFieldsZod = z7.object({
+  block: BlockNumberZod,
+  chain: ChainZod,
+  previous: HexZod2.nullable(),
+  protocol: z7.number().optional(),
+  step_hashes: z7.array(HexZod2).optional()
+});
+var BlockBoundWitnessMetaZod = z7.object({
+  $epoch: z7.number()
 });
-var BlockBoundWitnessSchema = UnsignedBoundWitnessSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
-var BlockBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
-var SignedBlockBoundWitnessSchema = SignedBoundWitnessSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
-var SignedBlockBoundWitnessWithStorageMetaSchema = SignedBoundWitnessWithStorageMetaSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
+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/HydratedBlockSchema.ts
-import { z as z10 } from "zod";
-var HydratedBlockSchema = z10.tuple([
-  BlockBoundWitnessSchema,
-  z10.array(PayloadSchema)
+// src/types/schema/common/HydratedBlock.ts
+import { z as z8 } from "zod";
+var HydratedBlockZod = z8.tuple([
+  BlockBoundWitnessZod,
+  z8.array(PayloadZod)
 ]);
-var HydratedBlockWithStorageMetaSchema = z10.tuple([
-  BlockBoundWitnessWithStorageMetaSchema,
-  z10.array(PayloadWithStorageMetaSchema)
+var HydratedBlockWithStorageMetaZod = z8.tuple([
+  BlockBoundWitnessWithStorageMetaZod,
+  z8.array(PayloadWithStorageMetaZod)
 ]);
-var SignedHydratedBlockSchema = z10.tuple([
-  SignedBlockBoundWitnessSchema,
-  z10.array(PayloadSchema)
+var SignedHydratedBlockZod = z8.tuple([
+  SignedBlockBoundWitnessZod,
+  z8.array(PayloadZod)
 ]);
-var SignedHydratedBlockWithStorageMetaSchema = z10.tuple([
-  SignedBlockBoundWitnessWithStorageMetaSchema,
-  z10.array(PayloadWithStorageMetaSchema)
+var SignedHydratedBlockToJsonZod = z8.tuple([
+  SignedBlockBoundWitnessZod,
+  z8.array(PayloadZod)
+]);
+var SignedHydratedBlockWithStorageMetaZod = z8.tuple([
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  z8.array(PayloadWithStorageMetaZod)
 ]);
 
-// src/types/schema/common/HydratedTransactionSchema.ts
-import { z as z12 } from "zod";
+// 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";
 
-// 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 TransactionFeesSchema = z11.object({
-  fees: z11.object({
-    base: HexToStringSchema,
-    gasLimit: HexToStringSchema,
-    gasPrice: HexToStringSchema,
-    priority: HexToStringSchema
-  })
+// src/types/schema/common/TransactionBoundWitness.ts
+import { z as z10 } from "zod";
+
+// src/types/schema/common/TransactionFees.ts
+import { BigIntToJsonZod, HexZod as HexZod3, JsonToBigIntZod } from "@xylabs/hex";
+import { asAttoXL1 } from "@xyo-network/xl1-protocol";
+import { z as z9 } from "zod";
+var AttoZod = z9.bigint();
+var AttoFromStringZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
+var TransactionFeesHexZod = z9.object({
+  base: HexZod3,
+  gasLimit: HexZod3,
+  gasPrice: HexZod3,
+  priority: HexZod3
 });
-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();
+var TransactionFeesBigIntZod = z9.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
+});
+var TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform((val) => ({
+  base: JsonToBigIntZod.parse(val.base),
+  gasLimit: JsonToBigIntZod.parse(val.gasLimit),
+  gasPrice: JsonToBigIntZod.parse(val.gasPrice),
+  priority: JsonToBigIntZod.parse(val.priority)
+}));
+var TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform((val) => ({
+  base: BigIntToJsonZod.parse(val.base),
+  gasLimit: BigIntToJsonZod.parse(val.gasLimit),
+  gasPrice: BigIntToJsonZod.parse(val.gasPrice),
+  priority: BigIntToJsonZod.parse(val.priority)
+}));
 
-// src/types/schema/common/HydratedTransactionSchema.ts
-var HydratedTransactionSchema = z12.tuple([
-  TransactionBoundWitnessSchema,
-  z12.array(PayloadSchema)
+// 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 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());
+
+// src/types/schema/common/HydratedTransaction.ts
+var HydratedTransactionZod = z11.tuple([
+  TransactionBoundWitnessZod,
+  z11.array(PayloadZod)
+]);
+var UnsignedHydratedTransactionZod = z11.tuple([
+  TransactionBoundWitnessZod,
+  z11.array(PayloadZod)
+]);
+var SignedHydratedTransactionZod = z11.tuple([
+  SignedTransactionBoundWitnessZod,
+  z11.array(PayloadZod)
 ]);
-var SignedHydratedTransactionSchema = z12.tuple([
-  SignedTransactionBoundWitnessSchema,
-  z12.array(PayloadSchema)
+var SignedHydratedTransactionToJsonZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => asSignedHydratedTransaction([
+  tx,
+  payloads.map((payload) => payload)
+]));
+var JsonToSignedHydratedTransactionZod = SignedHydratedTransactionZod.transform(([tx, payloads]) => [
+  asSignedHydratedTransaction(tx),
+  payloads.map((p) => asAnyPayload(p))
 ]);
 
-// src/types/schema/common/TransactionFees.ts
-import { z as z13 } from "zod";
-var TransactionFeesToStingSchema = z13.object({
-  base: BigIntToStringSchema,
-  gasLimit: BigIntToStringSchema,
-  gasPrice: BigIntToStringSchema,
-  priority: BigIntToStringSchema
-});
-var TransactionFeesFromStingSchema = z13.object({
-  base: BigIntFromStringSchema,
-  gasLimit: BigIntFromStringSchema,
-  gasPrice: BigIntFromStringSchema,
-  priority: BigIntFromStringSchema
-});
+// src/types/schema/common/Json.ts
+import { z as z12 } from "zod";
+var JsonValueZod = z12.lazy(() => z12.union([
+  z12.string(),
+  z12.number(),
+  z12.boolean(),
+  z12.null(),
+  z12.array(JsonValueZod),
+  z12.record(z12.string(), JsonValueZod)
+]));
+var JsonObjectZod = z12.record(z12.string(), JsonValueZod);
 
 // src/types/schema/XyoProviderRpcSchemas.ts
 var XyoProviderRpcSchemas = {
   xyoProvider_send: {
     params: {
-      to: z14.tuple([
-        AddressFromStringSchema,
-        z14.array(PayloadSchema),
-        z14.array(PayloadSchema),
-        z14.number().nonnegative(),
-        z14.number().nonnegative(),
-        TransactionFeesToStingSchema,
-        AddressFromStringSchema.optional()
+      to: z13.tuple([
+        AddressZod,
+        z13.array(PayloadZod),
+        z13.array(PayloadZod),
+        z13.number().nonnegative(),
+        z13.number().nonnegative(),
+        TransactionFeesBigIntToJsonZod,
+        AddressZod.optional()
       ]),
-      from: z14.tuple([
-        AddressToStringSchema,
-        z14.array(PayloadSchema),
-        z14.array(PayloadSchema),
-        z14.number().nonnegative(),
-        z14.number().nonnegative(),
-        TransactionFeesFromStingSchema,
-        AddressToStringSchema.optional()
+      from: z13.tuple([
+        AddressZod,
+        z13.array(PayloadZod),
+        z13.array(PayloadZod),
+        z13.number().nonnegative(),
+        z13.number().nonnegative(),
+        TransactionFeesJsonToBigIntZod,
+        AddressZod.optional()
       ])
     },
     result: {
-      to: SignedTransactionBoundWitnessSchema,
-      from: SignedTransactionBoundWitnessSchema
+      to: SignedTransactionBoundWitnessZod,
+      from: SignedTransactionBoundWitnessZod
     }
   }
 };
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
-import { z as z15 } from "zod";
+import { HashToJsonZod as HashToJsonZod2, JsonToHashZod } from "@xylabs/hex";
+import { z as z14 } from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z15.tuple([SignedHydratedTransactionSchema]),
-      from: z15.tuple([SignedHydratedTransactionSchema])
+      to: z14.tuple([
+        SignedHydratedTransactionZod
+      ]),
+      from: z14.tuple([
+        SignedHydratedTransactionZod
+      ])
     },
     result: {
-      to: HashToStringSchema,
-      from: HashFromStringSchema
+      to: HashToJsonZod2,
+      from: JsonToHashZod
     }
   }
 };
 
 // src/types/schema/XyoSignerRpcSchemas.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z16.array(z16.any()).length(0).optional(),
-      from: z16.array(z16.any()).length(0).optional()
+      to: z15.array(z15.any()).length(0).optional(),
+      from: z15.array(z15.any()).length(0).optional()
     },
     result: {
-      to: AddressToStringSchema,
-      from: AddressFromStringSchema
+      to: AddressZod,
+      from: AddressZod
     }
   },
+  // NOTE: method is deprecated which is why it uses deprecated types
   xyoSigner_createSignedTransaction: {
     params: {
-      to: z16.tuple([
-        AddressFromStringSchema,
-        z16.array(PayloadSchema),
-        z16.array(PayloadSchema),
-        z16.number().nonnegative(),
-        z16.number().nonnegative(),
-        TransactionFeesToStingSchema,
-        AddressFromStringSchema.optional()
+      to: z15.tuple([
+        ChainZod,
+        z15.array(AllowedBlockPayloadZod),
+        z15.array(PayloadZod),
+        z15.number().nonnegative(),
+        z15.number().nonnegative(),
+        TransactionFeesBigIntToJsonZod,
+        AddressZod.optional()
       ]),
-      from: z16.tuple([
-        AddressToStringSchema,
-        z16.array(PayloadSchema),
-        z16.array(PayloadSchema),
-        z16.number().nonnegative(),
-        z16.number().nonnegative(),
-        TransactionFeesFromStingSchema,
-        AddressToStringSchema.optional()
+      from: z15.tuple([
+        ChainZod,
+        z15.array(PayloadZod),
+        z15.array(PayloadZod),
+        z15.number().nonnegative(),
+        z15.number().nonnegative(),
+        TransactionFeesJsonToBigIntZod,
+        AddressZod.optional()
       ])
     },
     result: {
-      to: SignedTransactionBoundWitnessSchema,
-      from: SignedTransactionBoundWitnessSchema
+      to: SignedTransactionBoundWitnessZod,
+      from: SignedTransactionBoundWitnessZod.transform((data) => data)
     }
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z16.tuple([HydratedTransactionSchema]),
-      from: z16.tuple([HydratedTransactionSchema])
+      to: z15.tuple([
+        UnsignedHydratedTransactionZod
+      ]),
+      from: z15.tuple([
+        UnsignedHydratedTransactionZod
+      ])
     },
     result: {
-      to: SignedHydratedTransactionSchema,
-      from: SignedHydratedTransactionSchema
+      to: SignedHydratedTransactionZod,
+      from: SignedHydratedTransactionZod.transform((data) => data)
     }
   }
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { z as z17 } from "zod";
+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";
 var XyoViewerRpcSchemas = {
   xyoViewer_accountBalance: {
     params: {
-      to: z17.union([
-        z17.tuple([AddressToStringSchema]),
-        z17.tuple([AddressToStringSchema, z17.number()]),
-        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
+      to: z16.union([
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ]),
-      from: z17.union([
-        z17.tuple([AddressToStringSchema]),
-        z17.tuple([AddressToStringSchema, z17.number()]),
-        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
+      from: z16.union([
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ])
     },
     result: {
-      to: BigIntToStringSchema,
-      from: BigIntFromStringSchema
+      to: BigIntToJsonZod2,
+      from: JsonToBigIntZod2
     }
   },
   xyoViewer_accountHistory: {
     params: {
-      to: z17.union([
-        z17.tuple([AddressToStringSchema]),
-        z17.tuple([AddressToStringSchema, z17.number()]),
-        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
+      to: z16.union([
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ]),
-      from: z17.union([
-        z17.tuple([AddressToStringSchema]),
-        z17.tuple([AddressToStringSchema, z17.number()]),
-        z17.tuple([AddressToStringSchema, z17.number(), z17.boolean()])
+      from: z16.union([
+        z16.tuple([
+          AddressZod
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number()
+        ]),
+        z16.tuple([
+          AddressZod,
+          z16.number(),
+          z16.boolean()
+        ])
       ])
     },
     result: {
-      to: z17.array(z17.array(PayloadSchema)),
-      from: z17.array(z17.array(PayloadSchema))
+      to: z16.array(z16.tuple([
+        HashZod2,
+        HashZod2,
+        PayloadZod
+      ])),
+      from: z16.array(z16.tuple([
+        HashZod2,
+        HashZod2,
+        PayloadZod
+      ]))
     }
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z17.tuple([HashToStringSchema]),
-      from: z17.tuple([HashFromStringSchema])
+      to: z16.tuple([
+        HashToJsonZod3
+      ]),
+      from: z16.tuple([
+        JsonToHashZod2
+      ])
     },
     result: {
-      to: SignedHydratedBlockSchema,
-      from: SignedHydratedBlockSchema
+      to: SignedHydratedBlockZod,
+      from: SignedHydratedBlockZod
     }
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z17.tuple([z17.number()]),
-      from: z17.tuple([z17.number()])
+      to: z16.tuple([
+        z16.number()
+      ]),
+      from: z16.tuple([
+        z16.number()
+      ])
     },
     result: {
-      to: SignedHydratedBlockSchema,
-      from: SignedHydratedBlockSchema
+      to: SignedHydratedBlockZod,
+      from: SignedHydratedBlockZod
     }
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z17.tuple([HashToStringSchema, z17.number().optional()]),
-      from: z17.tuple([HashFromStringSchema, z17.number().optional()])
+      to: z16.tuple([
+        HashZod2,
+        z16.number().optional()
+      ]),
+      from: z16.tuple([
+        HashZod2,
+        z16.number().optional()
+      ])
     },
     result: {
-      to: z17.array(SignedHydratedBlockSchema),
-      from: z17.array(SignedHydratedBlockSchema)
+      to: z16.array(SignedHydratedBlockZod),
+      from: z16.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z16.array(z16.any()).length(0).optional(),
+      from: z16.array(z16.any()).length(0).optional()
     },
     result: {
-      to: AddressToStringSchema,
-      from: AddressFromStringSchema
+      to: AddressZod,
+      from: AddressZod
     }
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z16.array(z16.any()).length(0).optional(),
+      from: z16.array(z16.any()).length(0).optional()
     },
     result: {
-      to: SignedHydratedBlockSchema,
-      from: SignedHydratedBlockSchema
+      to: SignedHydratedBlockZod,
+      from: SignedHydratedBlockZod
     }
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z16.array(z16.any()).length(0).optional(),
+      from: z16.array(z16.any()).length(0).optional()
     },
     result: {
-      to: HashToStringSchema,
-      from: HashFromStringSchema
+      to: HashZod2,
+      from: HashZod2
     }
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z16.array(z16.any()).length(0).optional(),
+      from: z16.array(z16.any()).length(0).optional()
     },
     result: {
-      to: BlockNumberSchema,
-      from: BlockNumberSchema
+      to: BlockNumberZod,
+      from: BlockNumberZod
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z17.tuple([HashToStringSchema, z17.number()]),
-      from: z17.tuple([HashFromStringSchema, z17.number()])
+      to: z16.tuple([
+        HashZod2,
+        z16.number()
+      ]),
+      from: z16.tuple([
+        HashZod2,
+        z16.number()
+      ])
     },
     result: {
-      to: SignedHydratedTransactionSchema.nullable(),
-      from: SignedHydratedTransactionSchema.nullable()
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable()
     }
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z17.tuple([z17.number(), z17.number()]),
-      from: z17.tuple([z17.number(), z17.number()])
+      to: z16.tuple([
+        z16.number(),
+        z16.number()
+      ]),
+      from: z16.tuple([
+        z16.number(),
+        z16.number()
+      ])
     },
     result: {
-      to: SignedHydratedTransactionSchema.nullable(),
-      from: SignedHydratedTransactionSchema.nullable()
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable()
     }
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z17.tuple([HashToStringSchema]),
-      from: z17.tuple([HashFromStringSchema])
+      to: z16.tuple([
+        HashZod2
+      ]),
+      from: z16.tuple([
+        HashZod2
+      ])
     },
     result: {
-      to: SignedHydratedTransactionSchema.nullable(),
-      from: SignedHydratedTransactionSchema.nullable()
+      to: SignedHydratedTransactionZod.nullable(),
+      from: SignedHydratedTransactionZod.nullable()
     }
   }
 };
@@ -481,41 +665,56 @@ var AllRpcSchemas = {
 };
 
 // src/types/schema/createRequestSchema.ts
-import { z as z18 } from "zod";
-var createRequestSchema = (methodName, paramsSchema = z18.undefined()) => z18.object({
-  id: z18.union([z18.string(), z18.number()]),
-  jsonrpc: z18.literal(jsonrpc),
-  method: z18.literal(methodName),
+import { z 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 z19 } from "zod";
-var createResponseSchema = (resultSchema = z19.undefined()) => z19.object({
-  id: z19.union([z19.string(), z19.number()]),
-  jsonrpc: z19.literal(jsonrpc),
+import { z 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 z20 } from "zod";
-var ChainConnectionSchema = z20.object({
-  chainId: z20.union([z20.string(), z20.custom()]).optional(),
-  name: z20.string(),
-  url: z20.string()
+import { z as z19 } from "zod";
+var ChainConnectionZod = z19.object({
+  chainId: z19.union([
+    z19.string(),
+    z19.custom()
+  ]).optional(),
+  name: z19.string(),
+  url: z19.string()
 });
-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 CaveatTypesZod = z19.enum([
+  "chain",
+  "expiration",
+  "filteredResponse",
+  "rateLimit"
+]);
+var CaveatsZod = z19.object({
+  type: CaveatTypesZod,
+  value: z19.unknown()
+});
+var PermissionZod = z19.object({
+  capability: z19.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z19.string()
 });
-var PermissionSchema = z20.object({
-  capability: z20.string(),
-  caveats: CaveatsSchema.array().optional(),
-  invoker: z20.string()
+var InvokerPermissionZod = PermissionZod.extend({
+  date: z19.number().optional()
 });
-var InvokerPermissionSchema = PermissionSchema.extend({ date: z20.number().optional() });
 var XyoGatewayRpcSchemas = {
   /*
   xyoGateway_addConnection: {
@@ -581,58 +780,55 @@ var XyoGatewayRpcSchemas = {
   */
   xyoGateway_submitTransaction: {
     params: {
-      from: z20.array(
-        HydratedTransactionSchema
-      ),
-      to: z20.array(
-        HydratedTransactionSchema
-      )
+      from: z19.array(HydratedTransactionZod),
+      to: z19.array(HydratedTransactionZod)
     },
     result: {
-      from: BlockBoundWitnessSchema,
-      to: BlockBoundWitnessSchema
+      from: BlockBoundWitnessZod,
+      to: BlockBoundWitnessZod
     }
   }
 };
 
 // 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) {
@@ -642,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;
   }
@@ -673,7 +877,7 @@ var MemoryPermissionsStore = class {
 };
 
 // src/provider/connection/HttpRpcXyoConnection.ts
-import { isDefined as isDefined3, isString } from "@xylabs/typeof";
+import { isDefined as isDefined3, isString as isString2 } from "@xylabs/typeof";
 import { isDataLakeProvider as isDataLakeProvider2 } from "@xyo-network/xl1-protocol";
 
 // src/transport/HttpRpcTransport.ts
@@ -682,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) {
@@ -719,14 +926,18 @@ var HttpRpcTransport = class {
 };
 
 // src/transport/MemoryRpcTransport.ts
-import { isObject } from "@xylabs/typeof";
+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;
   }
@@ -734,7 +945,8 @@ var MemoryRpcTransport = class {
     const schema = this._schemas[method];
     let requestSchema = this.requestSchemas[method];
     if (!isObject(requestSchema)) {
-      requestSchema = createRequestSchema(method, schema.params.to);
+      const stringMethod = assertEx(isString(method) ? method : null, () => "Method must be a string");
+      requestSchema = createRequestSchema(stringMethod, schema.params.to);
       this.requestSchemas[method] = requestSchema;
     }
     const req = {
@@ -755,42 +967,46 @@ 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;
-  constructor(defaultDestination, schemas = XyoGatewayRpcSchemas, sessionId) {
-    this.schemas = schemas;
+  constructor(defaultDestination, sessionId) {
+    this.schemas = XyoGatewayRpcSchemas;
     this.destination = defaultDestination;
     this.sessionId = sessionId;
   }
@@ -807,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);
@@ -832,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) {
@@ -873,24 +1087,42 @@ 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,
+      []
+    ];
   }
 };
 
 // src/provider/datalake/ArchivistXyoDataLake.ts
-import { assertEx } from "@xylabs/assert";
+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();
@@ -898,7 +1130,7 @@ var ArchivistXyoDataLake = class extends AbstractXyoDataLake {
   }
   async add(items) {
     const payloads = items.filter(isAnyPayload2);
-    assertEx(payloads.length === items.length, () => "Some items are not payloads");
+    assertEx2(payloads.length === items.length, () => "Some items are not payloads");
     return await this._archivist.insert(payloads);
   }
   async get(hashes) {
@@ -907,7 +1139,7 @@ var ArchivistXyoDataLake = class extends AbstractXyoDataLake {
 };
 
 // src/provider/datalake/HttpXyoDataLake.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { AxiosJson as AxiosJson2 } from "@xylabs/axios";
 import { exists } from "@xylabs/exists";
 import { isArrayBuffer, isDefined as isDefined2 } from "@xylabs/typeof";
@@ -915,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;
@@ -922,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;
@@ -937,14 +1186,14 @@ var HttpXyoDataLake = class extends AbstractXyoDataLake {
         if (isAnyPayload3(result)) {
           results.push(result);
         } else if (isDefined2(result)) {
-          assertEx2(false, () => "Expected result to be a Payload");
+          assertEx3(false, () => "Expected result to be a Payload");
         }
       } else if (isArrayBuffer(item)) {
         const result = await this.addArrayBuffer(item);
         if (isAnyPayload3(result)) {
           results.push(result);
         } else if (isDefined2(result)) {
-          assertEx2(false, () => "Expected result to be a Payload");
+          assertEx3(false, () => "Expected result to be a Payload");
         }
       }
     }
@@ -1000,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
+    ]);
   }
 };
 
@@ -1014,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();
@@ -1022,19 +1279,24 @@ 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;
   }
 };
 
 // src/provider/runner/NodeXyoRunner.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
+import { assertEx as assertEx4 } from "@xylabs/assert";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 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";
@@ -1051,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 assertEx3(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
-  };
-  getPendingArchivist = async () => {
+    return assertEx4(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+  }, "getArchivist");
+  getPendingArchivist = /* @__PURE__ */ __name(async () => {
     if (this._pendingArchivist) return this._pendingArchivist;
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
-    return assertEx3(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${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;
@@ -1075,7 +1342,7 @@ var RpcXyoSigner = class {
     return await this.transport.sendRequest("xyoSigner_address");
   }
   async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
-    return await this.transport.sendRequest("xyoSigner_createSignedTransaction", [
+    const ret = await this.transport.sendRequest("xyoSigner_createSignedTransaction", [
       chain,
       elevatedPayloads,
       additionalPayloads,
@@ -1084,19 +1351,27 @@ var RpcXyoSigner = class {
       fees,
       from
     ]);
+    return ret;
   }
   async signTransaction(tx) {
-    return await this.transport.sendRequest("xyoSigner_signTransaction", [
+    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;
@@ -1106,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_accountBalance", [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");
@@ -1158,23 +1441,34 @@ 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/connection/XyoConnection.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx5 } 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;
@@ -1214,16 +1508,10 @@ var XyoConnection = class {
     }))[0];
   }
   /** @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");
+  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");
     const storage = this.storage;
     const chainResolved = chain ?? await viewer.chainId();
     if (chainResolved === void 0) throw new Error("Failed to determine chain");
@@ -1232,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 = assertEx4(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)
@@ -1249,24 +1529,26 @@ var XyoConnection = class {
       const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction);
       await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload4));
     }
-    assertEx4(await runner.broadcastTransaction(hydratedTransaction), () => "Failed to broadcast transaction");
+    assertEx5(await runner.broadcastTransaction(hydratedTransaction), () => "Failed to broadcast transaction");
     return hydratedTransaction;
   }
 };
 
 // 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 : isString(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
+    const storage = isDataLakeProvider2(storageParam) ? storageParam : isString2(storageParam) ? new HttpXyoDataLake(storageParam) : void 0;
     super({
       signer,
       runner,
@@ -1276,46 +1558,56 @@ var HttpRpcXyoConnection = class extends XyoConnection {
   }
 };
 var RpcXyoConnection = class extends HttpRpcXyoConnection {
+  static {
+    __name(this, "RpcXyoConnection");
+  }
 };
 
 // src/provider/gateway/Abstract.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+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 = assertEx5(connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx6(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];
+    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 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) {
     const connection = await this.connection();
-    assertEx5(connection.submitTransaction, () => "Active connection does not support transaction submission");
+    assertEx6(connection.submitTransaction, () => "Active connection does not support transaction submission");
     const tx = await connection.submitTransaction?.(elevatedPayloads, additionalPayloads);
-    return assertEx5(tx, () => "Transaction submission failed");
+    return assertEx6(tx, () => "Transaction submission failed");
   }
 };
 
 // src/provider/gateway/MemoryXyoGateway.ts
 var MemoryXyoGateway = class extends AbstractXyoGateway {
+  static {
+    __name(this, "MemoryXyoGateway");
+  }
   _connection;
   _signer;
   constructor(signer, connection) {
@@ -1370,6 +1662,9 @@ var StatusNetworks = {
 
 // src/provider/network/MemoryXyoNetwork.ts
 var MemoryXyoNetwork = class {
+  static {
+    __name(this, "MemoryXyoNetwork");
+  }
   _networkId;
   constructor(networkId) {
     this._networkId = networkId;
@@ -1402,20 +1697,45 @@ var MemoryXyoNetwork = class {
 export {
   AbstractXyoDataLake,
   AbstractXyoGateway,
+  AddressZod,
   AllRpcSchemas,
+  AllowedBlockPayloadZod,
+  AnyBoundWitnessZod,
+  AnyPayloadWithStorageMetaZod,
+  AnyPayloadZod,
+  AnySignedBoundWitnessWithStorageMetaZod,
+  AnySignedBoundWitnessZod,
+  AnyUnsignedBoundWitnessZod,
   ArchivistXyoDataLake,
-  CaveatTypesSchema,
-  CaveatsSchema,
-  ChainConnectionSchema,
+  AttoFromStringZod,
+  BlockBoundWitnessWithStorageMetaZod,
+  BlockBoundWitnessZod,
+  BlockDurationZod,
+  BlockEndZod,
+  BlockNumberZod,
+  BlockScriptsZod,
+  BlockStartZod,
+  BoundWitnessZod,
+  CaveatTypesZod,
+  CaveatsZod,
+  ChainConnectionZod,
+  ChainZod,
   HttpRpcTransport,
   HttpRpcXyoConnection,
   HttpXyoDataLake,
-  InvokerPermissionSchema,
+  HydratedBlockWithStorageMetaZod,
+  HydratedBlockZod,
+  HydratedTransactionZod,
+  InvokerPermissionZod,
+  JsonObjectZod,
   JsonRpcErrorCodes,
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoViewer,
+  JsonToSignedHydratedTransactionZod,
   LegacyPostMessageRpcTransport,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
   MemoryPermissionsStore,
   MemoryRpcTransport,
   MemoryXyoClient,
@@ -1424,10 +1744,38 @@ export {
   MemoryXyoRunner,
   MemoryXyoSigner,
   NodeXyoRunner,
-  PermissionSchema,
+  PayloadWithStorageMetaZod,
+  PayloadZod,
+  PermissionZod,
   PostMessageRpcTransport,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
   RpcXyoConnection,
   RpcXyoSigner,
+  SchemaZod,
+  SequenceFromStringZod,
+  SequenceToStringZod,
+  SignedBlockBoundWitnessWithStorageMetaZod,
+  SignedBlockBoundWitnessZod,
+  SignedBoundWitnessWithStorageMetaZod,
+  SignedBoundWitnessZod,
+  SignedHydratedBlockToJsonZod,
+  SignedHydratedBlockWithStorageMetaZod,
+  SignedHydratedBlockZod,
+  SignedHydratedTransactionToJsonZod,
+  SignedHydratedTransactionZod,
+  SignedTransactionBoundWitnessZod,
+  StorageMetaZod,
+  TransactionBoundWitnessZod,
+  TransactionFeesBigIntToJsonZod,
+  TransactionFeesBigIntZod,
+  TransactionFeesHexZod,
+  TransactionFeesJsonToBigIntZod,
+  UnsignedBoundWitnessWithStorageMetaZod,
+  UnsignedBoundWitnessZod,
+  UnsignedHydratedTransactionZod,
+  WithStorageMetaZod,
+  WithTransactionFeesZod,
   XyoConnection,
   XyoGatewayRpcSchemas,
   XyoProviderRpcSchemas,