@xyo-network/xl1-rpc 1.10.2 → 1.12.0

package/dist/neutral/index.mjs

@@ -89,7 +89,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
@@ -110,412 +110,478 @@ var JsonRpcErrorCodes = {
 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
+// 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 AddressToStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx);
-var AddressFromStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx).transform((v) => toAddress(v));
+var AddressZod = z.string().toLowerCase().regex(CompiledAddressRegEx).transform((v) => toAddress(v));
 
-// src/types/schema/common/BigIntSchema.ts
+// src/types/schema/common/AllowedBlockPayload.ts
+import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
+import { SchemaSchema } from "@xyo-network/core-payload-plugins";
 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";
+  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/BoundWitnessSchema.ts
-import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import { z as z8 } from "zod";
+// src/types/schema/common/BlockBoundWitness.ts
+import { HexZod as HexZod2 } from "@xylabs/hex";
+import { z as z7 } 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/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/HexSchema.ts
-import { toHex as toHex2 } from "@xylabs/hex";
-import { HexRegEx as HexRegEx2 } from "@xyo-network/payload-wrapper";
+// src/types/schema/common/Payload.ts
+import { HashToJsonZod } from "@xylabs/hex";
 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));
-
-// src/types/schema/common/PayloadSchema.ts
-import { z as z7 } from "zod";
-
-// src/types/schema/common/StorageMetaSchema.ts
-import { z as z6 } from "zod";
 
-// src/types/schema/common/SequenceSchema.ts
-import { toHex as toHex3 } from "@xylabs/hex";
+// src/types/schema/common/Sequence.ts
+import { 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);
+}
 
-// 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 BoundWitnessMetaSchema = z8.object({
-  $destination: AddressToStringSchema.optional(),
-  $sourceQuery: HashToStringSchema.optional()
+var BoundWitnessMetaZod = z5.object({
+  $destination: AddressZod.optional(),
+  $sourceQuery: HashZod.optional(),
+  $signatures: z5.array(z5.union([HexZod, z5.null()]))
 });
-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 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 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/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/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));
+
+// 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 BlockBoundWitnessSchema = UnsignedBoundWitnessSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
-var BlockBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
-var SignedBlockBoundWitnessSchema = SignedBoundWitnessSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
-var SignedBlockBoundWitnessWithStorageMetaSchema = SignedBoundWitnessWithStorageMetaSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
+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/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 TransactionFeesBigIntZod = z9.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod
 });
-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 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/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/HydratedTransactionSchema.ts
-var HydratedTransactionSchema = z12.tuple([
-  TransactionBoundWitnessSchema,
-  z12.array(PayloadSchema)
+// 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)
+  // object with string keys and JSON values
+]));
+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()
     }
   }
 };
@@ -529,41 +595,41 @@ 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 = (methodName, paramsSchema = z17.undefined()) => z17.object({
+  id: z17.union([z17.string(), z17.number()]),
+  jsonrpc: z17.literal(jsonrpc),
+  method: z17.literal(methodName),
   params: paramsSchema
 });
 
 // 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 = (resultSchema = z18.undefined()) => z18.object({
+  id: z18.union([z18.string(), z18.number()]),
+  jsonrpc: z18.literal(jsonrpc),
   result: resultSchema
 });
 
 // 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()
+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 PermissionSchema = z20.object({
-  capability: z20.string(),
-  caveats: CaveatsSchema.array().optional(),
-  invoker: z20.string()
+var PermissionZod = z19.object({
+  capability: z19.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z19.string()
 });
-var InvokerPermissionSchema = PermissionSchema.extend({ date: z20.number().optional() });
+var InvokerPermissionZod = PermissionZod.extend({ date: z19.number().optional() });
 var XyoGatewayRpcSchemas = {
   /*
   xyoGateway_addConnection: {
@@ -629,16 +695,16 @@ var XyoGatewayRpcSchemas = {
   */
   xyoGateway_submitTransaction: {
     params: {
-      from: z20.array(
-        HydratedTransactionSchema
+      from: z19.array(
+        HydratedTransactionZod
       ),
-      to: z20.array(
-        HydratedTransactionSchema
+      to: z19.array(
+        HydratedTransactionZod
       )
     },
     result: {
-      from: BlockBoundWitnessSchema,
-      to: BlockBoundWitnessSchema
+      from: BlockBoundWitnessZod,
+      to: BlockBoundWitnessZod
     }
   }
 };
@@ -682,7 +748,8 @@ 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 {
   _rpcEngine;
@@ -697,7 +764,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 = {
@@ -752,8 +820,8 @@ var LegacyPostMessageRpcTransport = class {
   destination;
   schemas;
   sessionId;
-  constructor(defaultDestination, schemas = XyoGatewayRpcSchemas, sessionId) {
-    this.schemas = schemas;
+  constructor(defaultDestination, sessionId) {
+    this.schemas = XyoGatewayRpcSchemas;
     this.destination = defaultDestination;
     this.sessionId = sessionId;
   }
@@ -851,7 +919,7 @@ var AbstractXyoDataLake = class {
 };
 
 // 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 {
   _archivist;
@@ -861,7 +929,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) {
@@ -870,7 +938,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";
@@ -900,14 +968,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");
         }
       }
     }
@@ -992,7 +1060,7 @@ var MemoryXyoRunner = class {
 };
 
 // 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";
@@ -1019,12 +1087,12 @@ var NodeXyoRunner = class {
   }
   getArchivist = async (identifier) => {
     const archivist = await this.node.resolve(identifier);
-    return assertEx3(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+    return assertEx4(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`);
   };
   getPendingArchivist = async () => {
     if (this._pendingArchivist) return this._pendingArchivist;
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
-    return 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}`);
   };
 };
 
@@ -1038,7 +1106,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,
@@ -1047,16 +1115,18 @@ var RpcXyoSigner = class {
       fees,
       from
     ]);
+    return ret;
   }
-  signTransaction(_tx) {
-    throw new Error("Method not implemented.");
+  async signTransaction(tx) {
+    const ret = await this.transport.sendRequest("xyoSigner_signTransaction", [tx]);
+    return ret;
   }
 };
 var JsonRpcXyoSigner = class extends RpcXyoSigner {
 };
 
 // src/provider/signer/MemoryXyoSigner.ts
-import { buildTransaction } from "@xyo-network/xl1-protocol-sdk";
+import { buildTransaction, signTransaction } from "@xyo-network/xl1-protocol-sdk";
 var MemoryXyoSigner = class {
   _account;
   constructor(account) {
@@ -1079,8 +1149,9 @@ var MemoryXyoSigner = class {
     );
     return transaction[0];
   }
-  signTransaction(_tx) {
-    throw new Error("Method not implemented.");
+  async signTransaction(tx) {
+    const txBW = await signTransaction(tx[0], this._account);
+    return [txBW, tx[1]];
   }
 };
 
@@ -1094,7 +1165,7 @@ var JsonRpcXyoViewer = class {
     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]);
@@ -1129,7 +1200,7 @@ var JsonRpcXyoViewer = class {
 };
 
 // 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";
@@ -1181,9 +1252,9 @@ var XyoConnection = class {
     from,
     nbf
   } = {}) {
-    const viewer = assertEx4(this.viewer, () => "No viewer available");
-    const signer = assertEx4(this.signer, () => "No signer available");
-    const runner = assertEx4(this.runner, () => "No runner available");
+    const 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");
@@ -1192,7 +1263,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(
+    const signedTransaction = assertEx5(await signer.createSignedTransaction(
       chainResolved,
       elevatedPayloads,
       additionalPayloads,
@@ -1209,7 +1280,7 @@ 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;
   }
 };
@@ -1226,7 +1297,7 @@ var HttpRpcXyoConnection = class extends XyoConnection {
     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,
@@ -1239,13 +1310,13 @@ var RpcXyoConnection = class extends HttpRpcXyoConnection {
 };
 
 // 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 {
   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();
@@ -1256,7 +1327,7 @@ var AbstractXyoGateway = class {
   async addTransactionToChain(tx) {
     const connection = await this.connection();
     const signer = await this.signer();
-    const runner = assertEx5(connection.runner, () => "No runner available on connection");
+    const runner = assertEx6(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     return await runner.broadcastTransaction(
       [
@@ -1268,9 +1339,9 @@ var AbstractXyoGateway = class {
   /** @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");
   }
 };
 
@@ -1362,20 +1433,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,
@@ -1384,10 +1480,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,