@xyo-network/xl1-protocol 4.4.1 → 4.4.3

package/dist/neutral/protocol-model.mjs

@@ -1,12 +1,12 @@
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
-import { zodIsFactory as zodIsFactory4 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory5 } from "@ariestools/sdk";
 import {
   BoundWitnessSchema,
   isHashMeta,
   isSchemaPayload,
   SchemaSchema
 } from "@xyo-network/sdk";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/modules/protocol-model/payload/application/Exchange/ExchangeOutcome.ts
 import { AsObjectFactory, HashZod } from "@ariestools/sdk";
@@ -666,8 +666,9 @@ var TimeFieldsZod = z23.extend(
   EpochTimeFieldsZod.shape
 );
 var TimePayloadZod = z23.extend(PayloadZodOfSchema(TimeSchema), TimeFieldsZod.shape);
+var MAX_SAFE_EPOCH = 9999999999999;
 var isSafeEpoch = (value) => {
-  return typeof value === "number" && value < 2 * Date.now();
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_SAFE_EPOCH;
 };
 var isTimePayload = (value) => {
   return isPayloadOfSchemaType4(TimeSchema)(value) && isSafeEpoch(value.epoch);
@@ -754,6 +755,30 @@ var StepIdentitySchema = asSchema16("network.xyo.chain.step.identity", true);
 var isStepIdentityPayload = isPayloadOfZodType12(StepIdentityZod, StepIdentitySchema);
 var asStepIdentityPayload = AsObjectFactory16.create(isStepIdentityPayload);
 
+// src/modules/protocol-model/payload/StepWitness.ts
+import { AsObjectFactory as AsObjectFactory17, HashZod as HashZod5 } from "@ariestools/sdk";
+import {
+  asSchema as asSchema17,
+  isPayloadOfZodType as isPayloadOfZodType13,
+  XyoAddressZod as XyoAddressZod5
+} from "@xyo-network/sdk";
+import { z as z25 } from "zod/mini";
+var StepWitnessSchema = asSchema17("network.xyo.chain.validation.step.witness", true);
+var StepWitnessFieldsZod = z25.object({
+  /** Hash of the block in which the step hash was observed */
+  blockHash: HashZod5,
+  /** Block number of the block in which the step hash was observed */
+  blockNumber: XL1BlockNumberZod,
+  /** The observed step hash — the entry at the step level's index in the block's step_hashes */
+  stepHash: HashZod5,
+  /** Block-interval size of the observed step level — must be one of StepSizes */
+  stepSize: z25.literal(StepSizes),
+  /** Address of the observer */
+  witness: XyoAddressZod5
+});
+var isStepWitness = isPayloadOfZodType13(StepWitnessFieldsZod, StepWitnessSchema);
+var asStepWitness = AsObjectFactory17.create(isStepWitness);
+
 // src/modules/protocol-model/transaction/TransactionGasCosts.ts
 var TransactionGasCosts = {
   /**
@@ -773,29 +798,32 @@ var TransactionGasCosts = {
 
 // src/modules/protocol-model/TransferPayload.ts
 import {
-  AsObjectFactory as AsObjectFactory17,
+  AsObjectFactory as AsObjectFactory18,
   HexZod as HexZod6,
-  JsonObjectZod
+  JsonObjectZod,
+  zodIsFactory as zodIsFactory4
 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema17,
+  asSchema as asSchema18,
   isPayloadOfSchemaType as isPayloadOfSchemaType5,
   PayloadZodOfSchema as PayloadZodOfSchema2,
-  XyoAddressZod as XyoAddressZod5
+  XyoAddressZod as XyoAddressZod6
 } from "@xyo-network/sdk";
-import { z as z25 } from "zod/mini";
-var TransferSchema = asSchema17("network.xyo.transfer", true);
-var TransferFieldsZod = z25.object({
+import { z as z26 } from "zod/mini";
+var TransferSchema = asSchema18("network.xyo.transfer", true);
+var TransferFieldsZod = z26.object({
   // Removed as only transaction have opCodes
   // $opCodes: z.array(z.string()).optional(),
-  context: z25.optional(JsonObjectZod),
-  epoch: z25.number(),
-  from: XyoAddressZod5,
-  transfers: z25.record(XyoAddressZod5, HexZod6)
+  context: z26.optional(JsonObjectZod),
+  epoch: z26.number(),
+  from: XyoAddressZod6,
+  transfers: z26.record(XyoAddressZod6, HexZod6)
 });
-var TransferZod = z25.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
+var TransferZod = z26.extend(PayloadZodOfSchema2(TransferSchema), TransferFieldsZod.shape);
 var isTransfer = isPayloadOfSchemaType5(TransferSchema);
-var asTransfer = AsObjectFactory17.create(isTransfer);
+var isTransferPayload = zodIsFactory4(TransferZod);
+var asTransfer = AsObjectFactory18.create(isTransfer);
+var asTransferPayload = AsObjectFactory18.create(isTransferPayload);
 
 // src/modules/protocol-model/block/AllowedBlockPayload.ts
 var AllowedBlockPayloadSchemas = [
@@ -810,10 +838,10 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var AllowedBlockPayloadSchemaZod = z26.enum(AllowedBlockPayloadSchemas);
-var isAllowedBlockPayloadSchema = zodIsFactory4(AllowedBlockPayloadSchemaZod);
+var AllowedBlockPayloadSchemaZod = z27.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory5(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
-  return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isTimePayload(value) || isTransactionBoundWitness(value);
+  return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isStepComplete(value) || isTimePayload(value) || isTransactionBoundWitness(value);
 };
 var isAllowedBlockPayloadWithHashMeta = (value) => {
   return isAllowedBlockPayload(value) && isHashMeta(value);
@@ -821,9 +849,9 @@ var isAllowedBlockPayloadWithHashMeta = (value) => {
 
 // src/modules/protocol-model/block/BlockBoundWitness.ts
 import {
-  HashZod as HashZod5,
+  HashZod as HashZod6,
   zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory5,
+  zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory7
 } from "@ariestools/sdk";
 import {
@@ -831,36 +859,36 @@ import {
   WithHashMetaZod as WithHashMetaZod2,
   WithStorageMetaZod as WithStorageMetaZod2
 } from "@xyo-network/sdk";
-import { z as z27 } from "zod/mini";
-var BlockBoundWitnessFieldsZod = z27.object({
+import { z as z28 } from "zod/mini";
+var BlockBoundWitnessFieldsZod = z28.object({
   block: XL1BlockNumberZod,
   chain: ChainZod,
-  previous: z27.nullable(HashZod5),
-  protocol: z27.optional(z27.number()),
-  step_hashes: z27.optional(z27.array(HashZod5))
+  previous: z28.nullable(HashZod6),
+  protocol: z28.optional(z28.number()),
+  step_hashes: z28.optional(z28.array(HashZod6))
 });
-var BlockBoundWitnessMetaZod = z27.object({ $epoch: z27.number() });
-var BlockBoundWitnessZod = z27.object({
+var BlockBoundWitnessMetaZod = z28.object({ $epoch: z28.number() });
+var BlockBoundWitnessZod = z28.object({
   ...BoundWitnessZod2.shape,
   ...BlockBoundWitnessFieldsZod.shape,
   ...BlockBoundWitnessMetaZod.shape
 });
-var isBlockBoundWitness = zodIsFactory5(BlockBoundWitnessZod);
+var isBlockBoundWitness = zodIsFactory6(BlockBoundWitnessZod);
 var asBlockBoundWitness = zodAsFactory7(BlockBoundWitnessZod, "asBlockBoundWitness");
 var toBlockBoundWitness = zodToFactory7(BlockBoundWitnessZod, "toBlockBoundWitness");
 var BlockBoundWitnessWithHashMetaZod = WithHashMetaZod2(BlockBoundWitnessZod);
-var isBlockBoundWitnessWithHashMeta = zodIsFactory5(WithHashMetaZod2(BlockBoundWitnessZod));
+var isBlockBoundWitnessWithHashMeta = zodIsFactory6(WithHashMetaZod2(BlockBoundWitnessZod));
 var asBlockBoundWitnessWithHashMeta = zodAsFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithHashMeta");
 var toBlockBoundWitnessWithHashMeta = zodToFactory7(WithHashMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithHashMeta");
 var BlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(BlockBoundWitnessZod);
-var isBlockBoundWitnessWithStorageMeta = zodIsFactory5(WithStorageMetaZod2(BlockBoundWitnessZod));
+var isBlockBoundWitnessWithStorageMeta = zodIsFactory6(WithStorageMetaZod2(BlockBoundWitnessZod));
 var asBlockBoundWitnessWithStorageMeta = zodAsFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "asBlockBoundWitnessWithStorageMeta");
 var toBlockBoundWitnessWithStorageMeta = zodToFactory7(WithStorageMetaZod2(BlockBoundWitnessZod), "toBlockBoundWitnessWithStorageMeta");
 
 // src/modules/protocol-model/block/HydratedBlock.ts
 import {
   zodAsFactory as zodAsFactory11,
-  zodIsFactory as zodIsFactory9,
+  zodIsFactory as zodIsFactory10,
   zodToFactory as zodToFactory11
 } from "@ariestools/sdk";
 import {
@@ -869,38 +897,38 @@ import {
   WithHashMetaZod as WithHashMetaZod4,
   WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk";
-import { z as z31 } from "zod/mini";
+import { z as z32 } from "zod/mini";
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory8,
-  zodIsFactory as zodIsFactory6,
+  zodIsFactory as zodIsFactory7,
   zodToFactory as zodToFactory8
 } from "@ariestools/sdk";
 import { SignedBoundWitnessZod as SignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z28 } from "zod/mini";
-var SignedBlockBoundWitnessZod = z28.safeExtend(
-  z28.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z29 } from "zod/mini";
+var SignedBlockBoundWitnessZod = z29.safeExtend(
+  z29.safeExtend(SignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isSignedBlockBoundWitness = zodIsFactory6(SignedBlockBoundWitnessZod);
+var isSignedBlockBoundWitness = zodIsFactory7(SignedBlockBoundWitnessZod);
 var asSignedBlockBoundWitness = zodAsFactory8(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
 var toSignedBlockBoundWitness = zodToFactory8(SignedBlockBoundWitnessZod, "toSignedBlockBoundWitness");
 
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithHashMeta.ts
 import {
   zodAsFactory as zodAsFactory9,
-  zodIsFactory as zodIsFactory7,
+  zodIsFactory as zodIsFactory8,
   zodToFactory as zodToFactory9
 } from "@ariestools/sdk";
 import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk";
-import { z as z29 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory7(SignedBlockBoundWitnessWithHashMetaZod);
+var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory8(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory9(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
-var SignedBlockBoundWitnessWithHashMetaishZod = z29.pipe(
+var SignedBlockBoundWitnessWithHashMetaishZod = z30.pipe(
   SignedBlockBoundWitnessZod,
-  z29.transform(async (data) => {
+  z30.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithHashMeta(data)) {
       return data;
     }
@@ -915,20 +943,20 @@ var toSignedBlockBoundWitnessWithHashMeta = zodToFactory9(SignedBlockBoundWitnes
 // src/modules/protocol-model/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts
 import {
   zodAsFactory as zodAsFactory10,
-  zodIsFactory as zodIsFactory8,
+  zodIsFactory as zodIsFactory9,
   zodToFactory as zodToFactory10
 } from "@ariestools/sdk";
 import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod3 } from "@xyo-network/sdk";
-import { z as z30 } from "zod/mini";
+import { z as z31 } from "zod/mini";
 var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod3(SignedBlockBoundWitnessZod);
-var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory8(SignedBlockBoundWitnessWithStorageMetaZod);
+var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory9(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory10(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
-var SignedBlockBoundWitnessWithStorageMetaishZod = z30.pipe(
+var SignedBlockBoundWitnessWithStorageMetaishZod = z31.pipe(
   SignedBlockBoundWitnessZod,
-  z30.transform(async (data) => {
+  z31.transform(async (data) => {
     if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
       return data;
     }
@@ -944,101 +972,101 @@ var toSignedBlockBoundWitnessWithStorageMeta = zodToFactory10(
 );
 
 // src/modules/protocol-model/block/HydratedBlock.ts
-var HydratedBlockZod = z31.tuple([
+var HydratedBlockZod = z32.tuple([
   BlockBoundWitnessZod,
-  z31.array(PayloadZodLoose)
+  z32.array(PayloadZodLoose)
 ]);
-var isHydratedBlock = zodIsFactory9(HydratedBlockZod);
+var isHydratedBlock = zodIsFactory10(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory11(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory11(HydratedBlockZod, "toHydratedBlock");
-var HydratedBlockWithHashMetaZod = z31.tuple([
+var HydratedBlockWithHashMetaZod = z32.tuple([
   WithHashMetaZod4(BlockBoundWitnessZod),
-  z31.array(z31.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z32.array(z32.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithHashMeta = zodIsFactory9(HydratedBlockWithHashMetaZod);
+var isHydratedBlockWithHashMeta = zodIsFactory10(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory11(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory11(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
-var HydratedBlockWithStorageMetaZod = z31.tuple([
+var HydratedBlockWithStorageMetaZod = z32.tuple([
   WithStorageMetaZod4(BlockBoundWitnessZod),
-  z31.array(z31.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z32.array(z32.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isHydratedBlockWithStorageMeta = zodIsFactory9(HydratedBlockWithStorageMetaZod);
+var isHydratedBlockWithStorageMeta = zodIsFactory10(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory11(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory11(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
-var SignedHydratedBlockZod = z31.tuple([
+var SignedHydratedBlockZod = z32.tuple([
   SignedBlockBoundWitnessZod,
-  z31.array(z31.looseObject(PayloadZod.shape))
+  z32.array(z32.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlock = zodIsFactory9(SignedHydratedBlockZod);
+var isSignedHydratedBlock = zodIsFactory10(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory11(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory11(SignedHydratedBlockZod, "toSignedHydratedBlock");
-var SignedHydratedBlockToJsonZod = z31.tuple([
+var SignedHydratedBlockToJsonZod = z32.tuple([
   SignedBlockBoundWitnessZod,
-  z31.array(z31.looseObject(PayloadZod.shape))
+  z32.array(z32.looseObject(PayloadZod.shape))
 ]);
-var isSignedHydratedBlockToJson = zodIsFactory9(SignedHydratedBlockToJsonZod);
+var isSignedHydratedBlockToJson = zodIsFactory10(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory11(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory11(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
-var SignedHydratedBlockWithHashMetaZod = z31.tuple([
+var SignedHydratedBlockWithHashMetaZod = z32.tuple([
   WithHashMetaZod4(SignedBlockBoundWitnessZod),
-  z31.array(z31.looseObject(WithHashMetaZod4(PayloadZod).shape))
+  z32.array(z32.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var SignedHydratedBlockWithHashMetaishZod = z31.tuple([
-  z31.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
-  z31.array(z31.looseObject(WithHashMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithHashMetaishZod = z32.tuple([
+  z32.union([WithHashMetaZod4(SignedBlockBoundWitnessZod)]),
+  z32.array(z32.looseObject(WithHashMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithHashMeta = zodIsFactory9(SignedHydratedBlockWithHashMetaZod);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory10(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory11(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory11(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
-var SignedHydratedBlockWithStorageMetaZod = z31.tuple([
+var SignedHydratedBlockWithStorageMetaZod = z32.tuple([
   WithStorageMetaZod4(SignedBlockBoundWitnessZod),
-  z31.array(z31.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+  z32.array(z32.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
-var isSignedHydratedBlockWithStorageMeta = zodIsFactory9(SignedHydratedBlockWithStorageMetaZod);
+var isSignedHydratedBlockWithStorageMeta = zodIsFactory10(SignedHydratedBlockWithStorageMetaZod);
 var asSignedHydratedBlockWithStorageMeta = zodAsFactory11(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
 var toSignedHydratedBlockWithStorageMeta = zodToFactory11(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
-var SignedHydratedBlockWithStorageMetaishZod = z31.tuple([
-  z31.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
-  z31.array(z31.looseObject(WithStorageMetaZod4(PayloadZod).shape))
+var SignedHydratedBlockWithStorageMetaishZod = z32.tuple([
+  z32.union([WithStorageMetaZod4(SignedBlockBoundWitnessZod)]),
+  z32.array(z32.looseObject(WithStorageMetaZod4(PayloadZod).shape))
 ]);
 
 // src/modules/protocol-model/block/unsigned/UnsignedBlockBoundWitness.ts
 import {
   zodAsFactory as zodAsFactory12,
-  zodIsFactory as zodIsFactory10,
+  zodIsFactory as zodIsFactory11,
   zodToFactory as zodToFactory12
 } from "@ariestools/sdk";
 import { UnsignedBoundWitnessZod as UnsignedBoundWitnessZod2 } from "@xyo-network/sdk";
-import { z as z32 } from "zod/mini";
-var UnsignedBlockBoundWitnessZod = z32.safeExtend(
-  z32.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
+import { z as z33 } from "zod/mini";
+var UnsignedBlockBoundWitnessZod = z33.safeExtend(
+  z33.safeExtend(UnsignedBoundWitnessZod2, BlockBoundWitnessFieldsZod.shape),
   BlockBoundWitnessMetaZod.shape
 );
-var isUnsignedBlockBoundWitness = zodIsFactory10(UnsignedBlockBoundWitnessZod);
+var isUnsignedBlockBoundWitness = zodIsFactory11(UnsignedBlockBoundWitnessZod);
 var asUnsignedBlockBoundWitness = zodAsFactory12(UnsignedBlockBoundWitnessZod, "asUnsignedBlockBoundWitness");
 var toUnsignedBlockBoundWitness = zodToFactory12(UnsignedBlockBoundWitnessZod, "toUnsignedBlockBoundWitness");
 
 // src/modules/protocol-model/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory18 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory19 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema18,
+  asSchema as asSchema19,
   isPayloadOfSchemaType as isPayloadOfSchemaType6,
   isPayloadOfSchemaTypeWithSources
 } from "@xyo-network/sdk";
-var BlockNumberSchema = asSchema18("network.xyo.chain.block.number", true);
+var BlockNumberSchema = asSchema19("network.xyo.chain.block.number", true);
 var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory18.create(isBlockNumberPayload);
+var asBlockNumberPayload = AsObjectFactory19.create(isBlockNumberPayload);
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory18.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = AsObjectFactory19.create(isBlockNumberPayloadWithSources);
 
 // src/modules/protocol-model/model/AccountBalance.ts
-import { zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
+import { zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
 import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk";
-import { z as z38 } from "zod/mini";
+import { z as z39 } from "zod/mini";
 
 // src/modules/protocol-model/model/ChainQualification.ts
-import { HashZod as HashZod6, zodIsFactory as zodIsFactory12 } from "@ariestools/sdk";
-import { z as z37 } from "zod";
+import { HashZod as HashZod7, zodIsFactory as zodIsFactory13 } from "@ariestools/sdk";
+import { z as z38 } from "zod";
 
 // src/modules/protocol-model/model/BlockRange/BlockRange.ts
 import {
@@ -1047,9 +1075,9 @@ import {
   zodAsFactory as zodAsFactory13,
   zodToFactory as zodToFactory13
 } from "@ariestools/sdk";
-import { z as z33 } from "zod";
-var BlockRangeZod = z33.tuple([BlockNumberZod, BlockNumberZod]);
-var BlockRangeishZod = z33.tuple([BlockNumberishZod, BlockNumberishZod]);
+import { z as z34 } from "zod";
+var BlockRangeZod = z34.tuple([BlockNumberZod, BlockNumberZod]);
+var BlockRangeishZod = z34.tuple([BlockNumberishZod, BlockNumberishZod]);
 var asBlockRange = zodAsFactory13(BlockRangeZod, "BlockRange");
 var toBlockRange = zodToFactory13(BlockRangeishZod, "BlockRange");
 var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1066,9 +1094,9 @@ import {
   zodAsFactory as zodAsFactory14,
   zodToFactory as zodToFactory14
 } from "@ariestools/sdk";
-import { z as z34 } from "zod";
-var EthBlockRangeZod = z34.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var EthBlockRangeishZod = z34.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
+import { z as z35 } from "zod";
+var EthBlockRangeZod = z35.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var EthBlockRangeishZod = z35.tuple([EthBlockNumberishZod, EthBlockNumberishZod]);
 var asEthBlockRange = zodAsFactory14(EthBlockRangeZod, "EthBlockRange");
 var toEthBlockRange = zodToFactory14(EthBlockRangeishZod, "EthBlockRange");
 var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1081,12 +1109,12 @@ function fromEthBlockNumberKey(key, assert) {
 // src/modules/protocol-model/model/BlockRange/Range.ts
 import {
   zodAsFactory as zodAsFactory15,
-  zodIsFactory as zodIsFactory11,
+  zodIsFactory as zodIsFactory12,
   zodToFactory as zodToFactory15
 } from "@ariestools/sdk";
-import { z as z35 } from "zod";
-var RangeZod = z35.tuple([z35.number(), z35.number()]);
-var isRange = zodIsFactory11(RangeZod);
+import { z as z36 } from "zod";
+var RangeZod = z36.tuple([z36.number(), z36.number()]);
+var isRange = zodIsFactory12(RangeZod);
 var asRange = zodAsFactory15(RangeZod, "Range");
 var toRange = zodToFactory15(RangeZod, "Range");
 
@@ -1097,9 +1125,9 @@ import {
   zodAsFactory as zodAsFactory16,
   zodToFactory as zodToFactory16
 } from "@ariestools/sdk";
-import { z as z36 } from "zod";
-var XL1BlockRangeZod = z36.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var XL1BlockRangeishZod = z36.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
+import { z as z37 } from "zod";
+var XL1BlockRangeZod = z37.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var XL1BlockRangeishZod = z37.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod]);
 var asXL1BlockRange = zodAsFactory16(XL1BlockRangeZod, "XL1BlockRange");
 var toXL1BlockRange = zodToFactory16(XL1BlockRangeishZod, "XL1BlockRange");
 var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
@@ -1110,33 +1138,33 @@ function fromXL1BlockNumberKey(key, assert) {
 }
 
 // src/modules/protocol-model/model/ChainQualification.ts
-var ChainQualificationZod = z37.object({ head: HashZod6, range: XL1BlockRangeZod });
-var isChainQualification = zodIsFactory12(ChainQualificationZod);
-var ChainQualifiedRangeConfigZod = z37.object({ range: XL1BlockRangeZod });
-var isChainQualifiedRangeConfig = zodIsFactory12(ChainQualifiedRangeConfigZod);
-var ChainQualifiedHeadConfigZod = z37.object({ head: HashZod6 });
-var isChainQualifiedHeadConfig = zodIsFactory12(ChainQualifiedHeadConfigZod);
-var ChainQualifiedConfigZod = z37.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z37.object({})]);
-var isChainQualifiedConfig = zodIsFactory12(ChainQualifiedConfigZod);
+var ChainQualificationZod = z38.object({ head: HashZod7, range: XL1BlockRangeZod });
+var isChainQualification = zodIsFactory13(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z38.object({ range: XL1BlockRangeZod });
+var isChainQualifiedRangeConfig = zodIsFactory13(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z38.object({ head: HashZod7 });
+var isChainQualifiedHeadConfig = zodIsFactory13(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z38.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z38.object({})]);
+var isChainQualifiedConfig = zodIsFactory13(ChainQualifiedConfigZod);
 var ExtendChainQualifiedConfigZod = ((zodType) => {
-  return z37.union([
+  return z38.union([
     ChainQualifiedRangeConfigZod.extend(zodType),
     ChainQualifiedHeadConfigZod.extend(zodType),
     zodType
   ]);
 });
 var ChainQualifiedZod = (zodType) => {
-  return z37.tuple([zodType, ChainQualificationZod]);
+  return z38.tuple([zodType, ChainQualificationZod]);
 };
 
 // src/modules/protocol-model/model/AccountBalance.ts
-var AccountBalanceHistoryItemZod = z38.tuple([
+var AccountBalanceHistoryItemZod = z39.tuple([
   WithHashMetaZod5(BlockBoundWitnessZod),
-  z38.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
+  z39.nullable(WithHashMetaZod5(TransactionBoundWitnessZod)),
   WithHashMetaZod5(TransferZod)
 ]);
 var AccountBalanceConfigZod = ChainQualifiedConfigZod;
-var isAccountBalanceConfig = zodIsFactory13(AccountBalanceConfigZod);
+var isAccountBalanceConfig = zodIsFactory14(AccountBalanceConfigZod);
 var AccountBalanceViewerMoniker = "AccountBalanceViewer";
 
 // src/modules/protocol-model/model/addresses.ts
@@ -1151,51 +1179,51 @@ var XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS = "0x319e667cED10452A117472811130444dE
 var XL1_ETH_MAIN_GOVERNANCE_ADDRESS = "0x7595710956d6B14b4f2F51a8dF41379eEeC9074E";
 
 // src/modules/protocol-model/model/ArrayBuffer.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function base64Encode(u8) {
   return u8.toBase64();
 }
 function base64Decode(b64) {
   return Uint8Array.fromBase64(b64);
 }
-var ArrayBufferToJsonZod = z39.instanceof(ArrayBuffer).transform((x) => {
+var ArrayBufferToJsonZod = z40.instanceof(ArrayBuffer).transform((x) => {
   const u8 = new Uint8Array(x);
   return base64Encode(u8);
 });
-var JsonToArrayBufferZod = z39.string().transform((x) => {
+var JsonToArrayBufferZod = z40.string().transform((x) => {
   const u8 = base64Decode(x);
   return u8.buffer;
 });
 
 // src/modules/protocol-model/model/BlockRate.ts
-import { zodAsFactory as zodAsFactory17, zodIsFactory as zodIsFactory14 } from "@ariestools/sdk";
-import { z as z40 } from "zod";
-var TimeDurationsZod = z40.object({
-  millis: z40.number().nonnegative(),
-  seconds: z40.number().nonnegative(),
-  minutes: z40.number().nonnegative(),
-  hours: z40.number().nonnegative(),
-  days: z40.number().nonnegative(),
-  weeks: z40.number().nonnegative()
+import { zodAsFactory as zodAsFactory17, zodIsFactory as zodIsFactory15 } from "@ariestools/sdk";
+import { z as z41 } from "zod";
+var TimeDurationsZod = z41.object({
+  millis: z41.number().nonnegative(),
+  seconds: z41.number().nonnegative(),
+  minutes: z41.number().nonnegative(),
+  hours: z41.number().nonnegative(),
+  days: z41.number().nonnegative(),
+  weeks: z41.number().nonnegative()
 });
-var isTimeDurations = zodIsFactory14(TimeDurationsZod);
+var isTimeDurations = zodIsFactory15(TimeDurationsZod);
 var asTimeDurations = zodAsFactory17(TimeDurationsZod, "asTimeDurations");
 var toTimeDurations = zodAsFactory17(TimeDurationsZod, "toTimeDurations");
-var BlockRateZod = z40.object({
+var BlockRateZod = z41.object({
   range: XL1BlockRangeZod.describe("the block range the rate was calculated over"),
-  rate: z40.number().nonnegative().describe("rate of blocks per specified time unit"),
+  rate: z41.number().nonnegative().describe("rate of blocks per specified time unit"),
   timeUnit: TimeDurationsZod.keyof().describe("the unit of time for the rate and timePerBlock"),
-  span: z40.int().nonnegative().describe("number of blocks the rate was calculated over"),
-  timeDifference: z40.number().nonnegative().describe("time difference from start and end block"),
-  timePerBlock: z40.number().nonnegative().describe("average time per block for the given range")
+  span: z41.int().nonnegative().describe("number of blocks the rate was calculated over"),
+  timeDifference: z41.number().nonnegative().describe("time difference from start and end block"),
+  timePerBlock: z41.number().nonnegative().describe("average time per block for the given range")
 });
-var isBlockRate = zodIsFactory14(BlockRateZod);
+var isBlockRate = zodIsFactory15(BlockRateZod);
 var asBlockRate = zodAsFactory17(BlockRateZod, "asBlockRate");
 var toBlockRate = zodAsFactory17(BlockRateZod, "toBlockRate");
-var CountZod = z40.int().nonnegative().describe("A non-negative integer count");
-var StepIndexZod = z40.int().min(0).max(StepSizes.length).describe("A non-negative integer step index");
-var timeUnitSchema = z40.number().positive();
-var TimeConfigZod = z40.object({
+var CountZod = z41.int().nonnegative().describe("A non-negative integer count");
+var StepIndexZod = z41.int().min(0).max(StepSizes.length - 1).describe("A non-negative integer step index");
+var timeUnitSchema = z41.number().positive();
+var TimeConfigZod = z41.object({
   minutes: timeUnitSchema.optional(),
   hours: timeUnitSchema.optional(),
   days: timeUnitSchema.optional(),
@@ -1203,33 +1231,33 @@ var TimeConfigZod = z40.object({
   months: timeUnitSchema.optional(),
   years: timeUnitSchema.optional()
 }).describe("Time configuration with optional time units");
-var isTimeConfig = zodIsFactory14(TimeConfigZod);
+var isTimeConfig = zodIsFactory15(TimeConfigZod);
 var asTimeConfig = zodAsFactory17(TimeConfigZod, "asTimeConfig");
 var toTimeConfig = zodAsFactory17(TimeConfigZod, "toTimeConfig");
-var SingleTimeConfigZod = z40.union([
-  z40.object({ minutes: timeUnitSchema }),
-  z40.object({ hours: timeUnitSchema }),
-  z40.object({ days: timeUnitSchema }),
-  z40.object({ weeks: timeUnitSchema }),
-  z40.object({ months: timeUnitSchema }),
-  z40.object({ years: timeUnitSchema })
+var SingleTimeConfigZod = z41.union([
+  z41.object({ minutes: timeUnitSchema }),
+  z41.object({ hours: timeUnitSchema }),
+  z41.object({ days: timeUnitSchema }),
+  z41.object({ weeks: timeUnitSchema }),
+  z41.object({ months: timeUnitSchema }),
+  z41.object({ years: timeUnitSchema })
 ]).describe("Time configuration with exactly one time unit");
-var isSingleTimeConfig = zodIsFactory14(SingleTimeConfigZod);
+var isSingleTimeConfig = zodIsFactory15(SingleTimeConfigZod);
 var asSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "asSingleTimeConfig");
 var toSingleTimeConfig = zodAsFactory17(SingleTimeConfigZod, "toSingleTimeConfig");
 
 // src/modules/protocol-model/model/Context/BaseContext.zod.ts
-import { z as z41 } from "zod";
-var CachesZod = z41.record(
-  z41.string(),
-  z41.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
+import { z as z42 } from "zod";
+var CachesZod = z42.record(
+  z42.string(),
+  z42.custom((val) => val != null && typeof val === "object" && ("get" in val || "set" in val))
 );
-var SingletonsZod = z41.record(z41.union([z41.string(), z41.symbol()]), z41.unknown());
-var LoggerZod = z41.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
-var MeterProviderZod = z41.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
-var TracerProviderZod = z41.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
-var TimeBudgetLimitZod = z41.number();
-var BaseContextZod = z41.object({
+var SingletonsZod = z42.record(z42.union([z42.string(), z42.symbol()]), z42.unknown());
+var LoggerZod = z42.custom((val) => val != null && typeof val === "object" && "info" in val && "error" in val);
+var MeterProviderZod = z42.custom((val) => val != null && typeof val === "object" && "getMeter" in val);
+var TracerProviderZod = z42.custom((val) => val != null && typeof val === "object" && "getTracer" in val);
+var TimeBudgetLimitZod = z42.number();
+var BaseContextZod = z42.object({
   caches: CachesZod.optional(),
   logger: LoggerZod.optional(),
   meterProvider: MeterProviderZod.optional(),
@@ -1239,24 +1267,24 @@ var BaseContextZod = z41.object({
 });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
-import z42 from "zod";
+import z43 from "zod";
 
 // src/modules/protocol-model/model/Context/CachingContext.zod.ts
 var CachingContextZod = BaseContextZod.extend({ caches: CachesZod });
 
 // src/modules/protocol-model/model/Context/BlockContext.zod.ts
 var BlockContextReadZod = CachingContextZod.extend(
-  { chainMap: z42.custom((val) => val != null && typeof val === "object" && "get" in val) }
+  { chainMap: z43.custom((val) => val != null && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z42.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
+  { chainMap: z43.custom((val) => val != null && typeof val === "object" && ("get" in val && "insert" in val)) }
 );
 var BlockContextZod = BlockContextWriteZod;
 
 // src/modules/protocol-model/model/Context/HeadContext.zod.ts
 import { WithHashMetaZod as WithHashMetaZod6 } from "@xyo-network/sdk";
-import z43 from "zod";
-var HeadContextBaseZod = z43.object(
+import z44 from "zod";
+var HeadContextBaseZod = z44.object(
   { head: WithHashMetaZod6(BlockBoundWitnessZod) }
 );
 var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
@@ -1292,7 +1320,7 @@ var defaultTransactionFees = {
 // src/modules/protocol-model/model/HydratedTransaction.ts
 import {
   zodAsFactory as zodAsFactory18,
-  zodIsFactory as zodIsFactory15,
+  zodIsFactory as zodIsFactory16,
   zodToFactory as zodToFactory17
 } from "@ariestools/sdk";
 import {
@@ -1301,47 +1329,47 @@ import {
   WithHashMetaZod as WithHashMetaZod7,
   WithStorageMetaZod as WithStorageMetaZod5
 } from "@xyo-network/sdk";
-import { z as z44 } from "zod/mini";
-var HydratedTransactionZod = z44.tuple([
+import { z as z45 } from "zod/mini";
+var HydratedTransactionZod = z45.tuple([
   TransactionBoundWitnessZod,
-  z44.array(PayloadZodLoose2)
+  z45.array(PayloadZodLoose2)
 ]);
-var isHydratedTransaction = zodIsFactory15(HydratedTransactionZod);
+var isHydratedTransaction = zodIsFactory16(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory18(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory17(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z44.tuple([
+var HydratedTransactionWithHashMetaZod = z45.tuple([
   WithHashMetaZod7(TransactionBoundWitnessZod),
-  z44.array(z44.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z45.array(z45.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithHashMeta = zodIsFactory15(HydratedTransactionWithHashMetaZod);
+var isHydratedTransactionWithHashMeta = zodIsFactory16(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory18(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory17(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z44.tuple([
+var HydratedTransactionWithStorageMetaZod = z45.tuple([
   WithStorageMetaZod5(TransactionBoundWitnessZod),
-  z44.array(z44.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z45.array(z45.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isHydratedTransactionWithStorageMeta = zodIsFactory15(HydratedTransactionWithStorageMetaZod);
+var isHydratedTransactionWithStorageMeta = zodIsFactory16(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory18(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory17(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z44.tuple([
+var UnsignedHydratedTransactionZod = z45.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z44.array(PayloadZodLoose2)
+  z45.array(PayloadZodLoose2)
 ]);
-var isUnsignedHydratedTransaction = zodIsFactory15(UnsignedHydratedTransactionZod);
+var isUnsignedHydratedTransaction = zodIsFactory16(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory18(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory17(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z44.tuple([
+var UnsignedHydratedTransactionWithHashMetaZod = z45.tuple([
   WithHashMetaZod7(UnsignedTransactionBoundWitnessZod),
-  z44.array(z44.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z45.array(z45.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory15(UnsignedHydratedTransactionWithHashMetaZod);
+var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory16(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory18(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory17(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z44.tuple([
+var UnsignedHydratedTransactionWithStorageMetaZod = z45.tuple([
   WithStorageMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z44.array(z44.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z45.array(z45.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory15(UnsignedHydratedTransactionWithStorageMetaZod);
+var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory16(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory18(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "asUnsignedHydratedTransactionWithStorageMeta"
@@ -1350,25 +1378,25 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory17(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z44.tuple([
+var SignedHydratedTransactionZod = z45.tuple([
   SignedTransactionBoundWitnessZod,
-  z44.array(PayloadZodLoose2)
+  z45.array(PayloadZodLoose2)
 ]);
-var isSignedHydratedTransaction = zodIsFactory15(SignedHydratedTransactionZod);
+var isSignedHydratedTransaction = zodIsFactory16(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory18(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory17(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z44.tuple([
+var SignedHydratedTransactionWithHashMetaZod = z45.tuple([
   WithHashMetaZod7(SignedTransactionBoundWitnessZod),
-  z44.array(z44.looseObject(WithHashMetaZod7(PayloadZod2).shape))
+  z45.array(z45.looseObject(WithHashMetaZod7(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithHashMeta = zodIsFactory15(SignedHydratedTransactionWithHashMetaZod);
+var isSignedHydratedTransactionWithHashMeta = zodIsFactory16(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory18(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory17(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z44.tuple([
+var SignedHydratedTransactionWithStorageMetaZod = z45.tuple([
   WithStorageMetaZod5(SignedTransactionBoundWitnessZod),
-  z44.array(z44.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
+  z45.array(z45.looseObject(WithStorageMetaZod5(PayloadZod2).shape))
 ]);
-var isSignedHydratedTransactionWithStorageMeta = zodIsFactory15(SignedHydratedTransactionWithStorageMetaZod);
+var isSignedHydratedTransactionWithStorageMeta = zodIsFactory16(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory18(
   SignedHydratedTransactionWithStorageMetaZod,
   "asSignedHydratedTransactionWithStorageMeta"
@@ -1382,22 +1410,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory17(
 var ELEVATE_OPCODE = "elevate";
 
 // src/modules/protocol-model/model/Permission.ts
-import { z as z45 } from "zod";
-var CaveatTypesZod = z45.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z45.object({
+import { z as z46 } from "zod";
+var CaveatTypesZod = z46.enum(["chain", "dataLakeAccess", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z46.object({
   type: CaveatTypesZod,
-  value: z45.json()
+  value: z46.json()
 });
-var PermissionZod = z45.object({
-  parentCapability: z45.string(),
+var PermissionZod = z46.object({
+  parentCapability: z46.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z45.string()
+  invoker: z46.string()
 });
-var InvokerPermissionZod = PermissionZod.safeExtend({ date: z45.number().optional() });
-var PermissionRequestZod = z45.record(z45.string(), z45.record(z45.string(), z45.any()));
-var RequestedPermissionZod = z45.object({
-  parentCapability: z45.string(),
-  date: z45.number().optional()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z46.number().optional() });
+var PermissionRequestZod = z46.record(z46.string(), z46.record(z46.string(), z46.any()));
+var RequestedPermissionZod = z46.object({
+  parentCapability: z46.string(),
+  date: z46.number().optional()
 });
 
 // src/modules/protocol-model/model/rewards.ts
@@ -1411,54 +1439,54 @@ var XL1_REWARDS_MIN_BLOCK_REWARD = asAttoXL1(toFixedPoint(10n, XL1_REWARDS_PLACE
 var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARDS_PLACES));
 
 // src/modules/protocol-model/model/RewardsRangeOptions.ts
-import { XyoAddressZod as XyoAddressZod6 } from "@xyo-network/sdk";
-import { z as z46 } from "zod";
-var RewardsRangeOptionsZod = z46.object({
-  positions: z46.array(z46.number()).optional(),
+import { XyoAddressZod as XyoAddressZod7 } from "@xyo-network/sdk";
+import { z as z47 } from "zod";
+var RewardsRangeOptionsZod = z47.object({
+  positions: z47.array(z47.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z46.array(StepIdentityZod).optional(),
-  stakers: z46.array(XyoAddressZod6).optional()
+  steps: z47.array(StepIdentityZod).optional(),
+  stakers: z47.array(XyoAddressZod7).optional()
 });
 
 // src/modules/protocol-model/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@ariestools/sdk";
 import { SequenceConstants } from "@xyo-network/sdk";
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z47.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z47.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z48.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z48.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z47.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z47.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z47.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z47.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var QualifiedSequenceToStringZod = z48.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z48.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z48.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z48.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/modules/protocol-model/model/Stake.ts
 import { HexZod as HexZod7 } from "@ariestools/sdk";
-import { XyoAddressZod as XyoAddressZod7 } from "@xyo-network/sdk";
-import { z as z48 } from "zod";
-var StakeZod = z48.object({
+import { XyoAddressZod as XyoAddressZod8 } from "@xyo-network/sdk";
+import { z as z49 } from "zod";
+var StakeZod = z49.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z48.number(),
+  addBlock: z49.number(),
   // the unique id for the stake item
-  id: z48.number(),
+  id: z49.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z48.number(),
+  removeBlock: z49.number(),
   // the address that is being staked
-  staked: XyoAddressZod7,
+  staked: XyoAddressZod8,
   // the address that owns the stake
-  staker: XyoAddressZod7,
+  staker: XyoAddressZod8,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z48.number()
+  withdrawBlock: z49.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
   amount: BigIntToJsonZod2.parse(val.amount),
   id: val.id,
   removeBlock: val.removeBlock,
-  staked: XyoAddressZod7.parse(val.staked),
-  staker: XyoAddressZod7.parse(val.staker),
+  staked: XyoAddressZod8.parse(val.staked),
+  staker: XyoAddressZod8.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
 var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
@@ -1474,54 +1502,54 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod7 }).transform((val) => ({
 // src/modules/protocol-model/model/SyncStepSummary.ts
 import {
   zodAsFactory as zodAsFactory19,
-  zodIsFactory as zodIsFactory16,
+  zodIsFactory as zodIsFactory17,
   zodToFactory as zodToFactory18
 } from "@ariestools/sdk";
-import { z as z49 } from "zod";
-var SyncStepSummaryMetadataZod = z49.object({
+import { z as z50 } from "zod";
+var SyncStepSummaryMetadataZod = z50.object({
   block: XL1BlockNumberZod,
-  blockCount: z49.int().nonnegative(),
-  bytes: z49.int().nonnegative(),
-  createdAt: z49.string(),
+  blockCount: z50.int().nonnegative(),
+  bytes: z50.int().nonnegative(),
+  createdAt: z50.string(),
   endBlock: XL1BlockNumberZod,
-  relativePath: z49.string(),
+  relativePath: z50.string(),
   startBlock: XL1BlockNumberZod,
-  step: z49.int().nonnegative(),
+  step: z50.int().nonnegative(),
   stepSize: XL1BlockNumberZod,
-  updatedAt: z49.string()
+  updatedAt: z50.string()
 });
-var isSyncStepSummaryMetadata = zodIsFactory16(SyncStepSummaryMetadataZod);
+var isSyncStepSummaryMetadata = zodIsFactory17(SyncStepSummaryMetadataZod);
 var asSyncStepSummaryMetadata = zodAsFactory19(SyncStepSummaryMetadataZod, "asSyncStepSummaryMetadata");
 var toSyncStepSummaryMetadata = zodToFactory18(SyncStepSummaryMetadataZod, "toSyncStepSummaryMetadata");
-var SyncStepSummaryStatusZod = z49.object({
-  currentBlock: z49.optional(XL1BlockNumberZod),
-  isIndexing: z49.boolean(),
-  nextBoundaries: z49.record(z49.string(), XL1BlockNumberZod),
-  summaries: z49.array(SyncStepSummaryMetadataZod),
-  summaryCount: z49.int().nonnegative()
+var SyncStepSummaryStatusZod = z50.object({
+  currentBlock: z50.optional(XL1BlockNumberZod),
+  isIndexing: z50.boolean(),
+  nextBoundaries: z50.record(z50.string(), XL1BlockNumberZod),
+  summaries: z50.array(SyncStepSummaryMetadataZod),
+  summaryCount: z50.int().nonnegative()
 });
-var isSyncStepSummaryStatus = zodIsFactory16(SyncStepSummaryStatusZod);
+var isSyncStepSummaryStatus = zodIsFactory17(SyncStepSummaryStatusZod);
 var asSyncStepSummaryStatus = zodAsFactory19(SyncStepSummaryStatusZod, "asSyncStepSummaryStatus");
 var toSyncStepSummaryStatus = zodToFactory18(SyncStepSummaryStatusZod, "toSyncStepSummaryStatus");
-var SyncStepSummaryZod = z49.array(SignedHydratedBlockWithHashMetaZod);
-var isSyncStepSummary = zodIsFactory16(SyncStepSummaryZod);
+var SyncStepSummaryZod = z50.array(SignedHydratedBlockWithHashMetaZod);
+var isSyncStepSummary = zodIsFactory17(SyncStepSummaryZod);
 var asSyncStepSummary = zodAsFactory19(SyncStepSummaryZod, "asSyncStepSummary");
 var toSyncStepSummary = zodToFactory18(SyncStepSummaryZod, "toSyncStepSummary");
 
 // src/modules/protocol-model/model/TimeDomain.ts
-import { z as z50 } from "zod";
-var TimeDomainZod = z50.union([
-  z50.literal("xl1"),
-  z50.literal("epoch"),
-  z50.literal("ethereum")
+import { z as z51 } from "zod";
+var TimeDomainZod = z51.union([
+  z51.literal("xl1"),
+  z51.literal("epoch"),
+  z51.literal("ethereum")
 ]);
 
 // src/modules/protocol-model/model/TransferPair.ts
-import { XyoAddressZod as XyoAddressZod8 } from "@xyo-network/sdk";
-import { z as z51 } from "zod";
-var TransferPairZod = z51.tuple([
-  XyoAddressZod8,
-  XyoAddressZod8
+import { XyoAddressZod as XyoAddressZod9 } from "@xyo-network/sdk";
+import { z as z52 } from "zod";
+var TransferPairZod = z52.tuple([
+  XyoAddressZod9,
+  XyoAddressZod9
 ]);
 
 // src/modules/protocol-model/model/version.ts
@@ -1540,57 +1568,57 @@ var asProviderMoniker = (value) => {
 var DefaultProviderMoniker = "Provider";
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory19 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory20 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema19,
+  asSchema as asSchema20,
   isPayloadOfSchemaType as isPayloadOfSchemaType7,
   PayloadZodOfSchema as PayloadZodOfSchema3
 } from "@xyo-network/sdk";
-import { z as z53 } from "zod/mini";
+import { z as z54 } from "zod/mini";
 
 // src/modules/protocol-model/rejection/RejectionError.ts
-import { HashZod as HashZod7 } from "@ariestools/sdk";
-import { z as z52 } from "zod";
-var RejectionErrorZod = z52.object({
-  hash: HashZod7,
-  message: z52.string().optional(),
-  name: z52.string()
+import { HashZod as HashZod8 } from "@ariestools/sdk";
+import { z as z53 } from "zod";
+var RejectionErrorZod = z53.object({
+  hash: HashZod8,
+  message: z53.string().optional(),
+  name: z53.string()
 }).loose();
 
 // src/modules/protocol-model/rejection/BlockRejectionPayload.ts
-var BlockRejectionSchema = asSchema19("network.xyo.block.rejection", true);
-var BlockRejectionFieldsZod = z53.object({
+var BlockRejectionSchema = asSchema20("network.xyo.block.rejection", true);
+var BlockRejectionFieldsZod = z54.object({
   block: HydratedBlockZod,
-  errors: z53.array(RejectionErrorZod),
-  rejector: z53.string()
+  errors: z54.array(RejectionErrorZod),
+  rejector: z54.string()
 });
-var BlockRejectionZod = z53.extend(
+var BlockRejectionZod = z54.extend(
   PayloadZodOfSchema3(BlockRejectionSchema),
   BlockRejectionFieldsZod.shape
 );
 var isBlockRejection = isPayloadOfSchemaType7(BlockRejectionSchema);
-var asBlockRejection = AsObjectFactory19.create(isBlockRejection);
+var asBlockRejection = AsObjectFactory20.create(isBlockRejection);
 
 // src/modules/protocol-model/rejection/TransactionRejectionPayload.ts
-import { AsObjectFactory as AsObjectFactory20 } from "@ariestools/sdk";
+import { AsObjectFactory as AsObjectFactory21 } from "@ariestools/sdk";
 import {
-  asSchema as asSchema20,
+  asSchema as asSchema21,
   isPayloadOfSchemaType as isPayloadOfSchemaType8,
   PayloadZodOfSchema as PayloadZodOfSchema4
 } from "@xyo-network/sdk";
-import { z as z54 } from "zod/mini";
-var TransactionRejectionSchema = asSchema20("network.xyo.transaction.rejection", true);
-var TransactionRejectionFieldsZod = z54.object({
-  errors: z54.array(RejectionErrorZod),
-  rejector: z54.string(),
+import { z as z55 } from "zod/mini";
+var TransactionRejectionSchema = asSchema21("network.xyo.transaction.rejection", true);
+var TransactionRejectionFieldsZod = z55.object({
+  errors: z55.array(RejectionErrorZod),
+  rejector: z55.string(),
   transaction: HydratedTransactionZod
 });
-var TransactionRejectionZod = z54.extend(
+var TransactionRejectionZod = z55.extend(
   PayloadZodOfSchema4(TransactionRejectionSchema),
   TransactionRejectionFieldsZod.shape
 );
 var isTransactionRejection = isPayloadOfSchemaType8(TransactionRejectionSchema);
-var asTransactionRejection = AsObjectFactory20.create(isTransactionRejection);
+var asTransactionRejection = AsObjectFactory21.create(isTransactionRejection);
 export {
   AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
@@ -1685,6 +1713,7 @@ export {
   LocalSequenceFromStringZod,
   LocalSequenceToStringZod,
   LoggerZod,
+  MAX_SAFE_EPOCH,
   MeterProviderZod,
   MicroXL1,
   MicroXL1MaxValue,
@@ -1736,6 +1765,8 @@ export {
   StepIndexZod,
   StepRewardFractions,
   StepSizes,
+  StepWitnessFieldsZod,
+  StepWitnessSchema,
   SyncStepSummaryMetadataZod,
   SyncStepSummaryStatusZod,
   SyncStepSummaryZod,
@@ -1865,6 +1896,7 @@ export {
   asStepComplete,
   asStepIdentity,
   asStepIdentityPayload,
+  asStepWitness,
   asSyncStepSummary,
   asSyncStepSummaryMetadata,
   asSyncStepSummaryStatus,
@@ -1882,6 +1914,7 @@ export {
   asTransactionFeesHex,
   asTransactionRejection,
   asTransfer,
+  asTransferPayload,
   asUnsignedBlockBoundWitness,
   asUnsignedHydratedTransaction,
   asUnsignedHydratedTransactionWithHashMeta,
@@ -1957,6 +1990,7 @@ export {
   isSingleTimeConfig,
   isStepComplete,
   isStepIdentityPayload,
+  isStepWitness,
   isSyncStepSummary,
   isSyncStepSummaryMetadata,
   isSyncStepSummaryStatus,
@@ -1973,6 +2007,7 @@ export {
   isTransactionFeesHex,
   isTransactionRejection,
   isTransfer,
+  isTransferPayload,
   isUnsignedBlockBoundWitness,
   isUnsignedHydratedTransaction,
   isUnsignedHydratedTransactionWithHashMeta,