@xyo-network/xl1-protocol 1.13.5 → 1.13.7

package/dist/neutral/index.mjs

@@ -285,9 +285,165 @@ var XL1Amount = class _XL1Amount {
 
 // src/block/AllowedBlockPayload.ts
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
-import { isHashMeta as isHashMeta3, isSchema } from "@xyo-network/payload-model";
+import { isHashMeta as isHashMeta3 } from "@xyo-network/payload-model";
 import { isSchemaPayload, SchemaSchema } from "@xyo-network/schema-payload-plugin";
+import z13 from "zod";
+
+// src/model/BlockNumber/BlockNumber.ts
+import z3 from "zod";
+
+// src/model/zod/zodAsFactory.ts
+import { assertError } from "@xylabs/hex";
+function zodAsFactory(zod, name) {
+  function asFunc(value, assert) {
+    const result = zod.safeParse(value);
+    if (result.success) {
+      return result.data;
+    }
+    let assertConfig;
+    switch (typeof assert) {
+      case "string": {
+        assertConfig = `[${name}][${value}] ${assert}`;
+        break;
+      }
+      case "object": {
+        assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`;
+        break;
+      }
+      case "boolean": {
+        assertConfig = `[${name}][${value}] ${result.error.message}`;
+        break;
+      }
+      case "function": {
+        assertConfig = assert(value, result.error.message);
+        break;
+      }
+      default: {
+        assertConfig = true;
+      }
+    }
+    return assertError(value, assertConfig, result.error.message);
+  }
+  return asFunc;
+}
+
+// src/model/zod/zodIsFactory.ts
+function zodIsFactory(zod) {
+  return (value) => zod.safeParse(value).success;
+}
+
+// src/model/zod/zodToFactory.ts
+function zodToFactory(zod, name) {
+  return zodAsFactory(zod, name);
+}
+
+// src/model/BlockNumber/Numberish.ts
+import z2 from "zod";
+var NumberishZod = z2.union([z2.number(), z2.string(), z2.bigint()]).transform((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number(v) : v).pipe(z2.number());
+
+// src/model/BlockNumber/BlockNumber.ts
+var BlockNumberZod = z3.number().transform((v) => v);
+var NumberishBlockNumberZod = NumberishZod.transform((v) => v);
+var asBlockNumber = zodAsFactory(BlockNumberZod, "asBlockNumber");
+var toBlockNumber = zodToFactory(NumberishBlockNumberZod, "toBlockNumber");
+var BLOCK_NUMBER_ZERO = asBlockNumber(0);
+
+// src/model/BlockNumber/EthBlockNumber.ts
 import z4 from "zod";
+var EthBlockNumberZod = z4.number().transform((v) => v);
+var NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var asEthBlockNumber = zodAsFactory(EthBlockNumberZod, "asEthBlockNumber");
+var toEthBlockNumber = zodToFactory(NumberishEthBlockNumberZod, "toEthBlockNumber");
+var ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0);
+
+// src/model/BlockNumber/XL1BlockNumber.ts
+import z5 from "zod";
+var XL1BlockNumberZod = z5.number().transform((v) => v);
+var NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var asXL1BlockNumber = zodAsFactory(XL1BlockNumberZod, "asXL1BlockNumber");
+var toXL1BlockNumber = zodToFactory(NumberishXL1BlockNumberZod, "toXL1BlockNumber");
+var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
+
+// src/model/BlockRange/BlockRange.ts
+import { assertError as assertError2 } from "@xylabs/hex";
+import { isDefined } from "@xylabs/typeof";
+import z6 from "zod";
+var BlockRangeZod = z6.tuple([BlockNumberZod, BlockNumberZod]);
+var NumberishBlockRangeZod = z6.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
+var asBlockRange = zodAsFactory(BlockRangeZod, "BlockRange");
+var toBlockRange = zodToFactory(NumberishBlockRangeZod, "BlockRange");
+var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
+function fromBlockNumberKey(key, assert) {
+  const [start, end] = key.split("|").map((v) => asBlockNumber(Number(v)));
+  const result = isDefined(start) && isDefined(end) ? [start, end] : void 0;
+  return assertError2(result, assert, `Invalid BlockRangeKey: ${key}`);
+}
+
+// src/model/BlockRange/EthBlockRange.ts
+import { assertError as assertError3 } from "@xylabs/hex";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
+import z7 from "zod";
+var EthBlockRangeZod = z7.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var NumberishEthBlockRangeZod = z7.tuple([NumberishEthBlockNumberZod, NumberishEthBlockNumberZod]);
+var asEthBlockRange = zodAsFactory(EthBlockRangeZod, "EthBlockRange");
+var toEthBlockRange = zodToFactory(NumberishEthBlockRangeZod, "EthBlockRange");
+var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
+function fromEthBlockNumberKey(key, assert) {
+  const [start, end] = key.split("|").map((v) => asEthBlockNumber(Number(v)));
+  const result = isDefined2(start) && isDefined2(end) ? [start, end] : void 0;
+  return assertError3(result, assert, `Invalid EthBlockRangeKey: ${key}`);
+}
+
+// src/model/BlockRange/Range.ts
+import z8 from "zod";
+var RangeZod = z8.tuple([z8.number(), z8.number()]);
+var isRange = zodIsFactory(RangeZod);
+var asRange = zodAsFactory(RangeZod, "Range");
+var toRange = zodToFactory(RangeZod, "Range");
+
+// src/model/BlockRange/XL1BlockRange.ts
+import { assertError as assertError4 } from "@xylabs/hex";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+import z9 from "zod";
+var XL1BlockRangeZod = z9.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var NumberishXL1BlockRangeZod = z9.tuple([NumberishXL1BlockNumberZod, NumberishXL1BlockNumberZod]);
+var asXL1BlockRange = zodAsFactory(XL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockRange = zodToFactory(NumberishXL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
+function fromXL1BlockNumberKey(key, assert) {
+  const [start, end] = key.split("|").map((v) => asXL1BlockNumber(Number(v)));
+  const result = isDefined3(start) && isDefined3(end) ? [start, end] : void 0;
+  return assertError4(result, assert, `Invalid XL1BlockRangeKey: ${key}`);
+}
+
+// src/model/StepIdentity.ts
+import { isUndefined } from "@xylabs/typeof";
+import * as z10 from "zod";
+var StepIdentityZod = z10.object({
+  block: z10.number().int().nonnegative(),
+  step: z10.number().int().nonnegative()
+});
+function tryParseInt(value) {
+  if (value === "") return void 0;
+  const num = Number(value);
+  return Number.isInteger(num) ? num : void 0;
+}
+var asStepIdentity = (stepIdentityString) => {
+  try {
+    const [blockNumberString, stepString] = stepIdentityString.split("|");
+    if (isUndefined(blockNumberString) || isUndefined(stepString)) {
+      return void 0;
+    }
+    const step = tryParseInt(stepString);
+    const block = toXL1BlockNumber(blockNumberString);
+    if (isUndefined(block) || isUndefined(step)) {
+      return void 0;
+    }
+    return { block, step };
+  } catch {
+    return void 0;
+  }
+};
 
 // src/payload/elevatable/Bridge/BridgeDestinationObservation.ts
 import { HexZod as HexZod2 } from "@xylabs/hex";
@@ -296,8 +452,8 @@ import { isPayloadOfZodType } from "@xyo-network/payload-model";
 
 // src/payload/elevatable/Bridge/BridgeDetails.ts
 import { HexZod } from "@xylabs/hex";
-import z2 from "zod";
-var BridgeDetailsDestinationFieldsZod = z2.object({
+import z11 from "zod";
+var BridgeDetailsDestinationFieldsZod = z11.object({
   /**
    * Destination network
    */
@@ -315,7 +471,7 @@ var BridgeDetailsDestinationFieldsZod = z2.object({
    */
   destToken: HexZod.describe("The token being bridged to")
 });
-var BridgeDetailsSourceFieldsZod = z2.object({
+var BridgeDetailsSourceFieldsZod = z11.object({
   /**
    * Source network
    */
@@ -354,13 +510,13 @@ var asBridgeDestinationObservation = AsObjectFactory.create(isBridgeDestinationO
 // src/payload/elevatable/Bridge/BridgeIntent.ts
 import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/object";
 import { isPayloadOfZodType as isPayloadOfZodType2 } from "@xyo-network/payload-model";
-import z3 from "zod";
+import z12 from "zod";
 var BridgeIntentSchema = "network.xyo.chain.bridge.intent";
 var BridgeIntentFieldsZod = BridgeDetailsFieldsZod.extend({
   /**
    * Unique identifier for replay protection
    */
-  nonce: z3.string().describe("Unique identifier for replay protection")
+  nonce: z12.string().describe("Unique identifier for replay protection")
 });
 var isBridgeIntent = isPayloadOfZodType2(
   BridgeIntentFieldsZod,
@@ -447,11 +603,18 @@ var TransferSchema = "network.xyo.transfer";
 var isTransfer = isPayloadOfSchemaType5(TransferSchema);
 var asTransfer = AsObjectFactory8.create(isTransfer);
 
+// src/payload/StepIdentityPayload.ts
+import { AsObjectFactory as AsObjectFactory9 } from "@xylabs/object";
+import { isPayloadOfZodType as isPayloadOfZodType4 } from "@xyo-network/payload-model";
+var StepIdentitySchema = "network.xyo.chain.step.identity";
+var isStepIdentityPayload = isPayloadOfZodType4(StepIdentityZod, StepIdentitySchema);
+var asStepIdentityPayload = AsObjectFactory9.create(isStepIdentityPayload);
+
 // src/transaction/AnyHydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory11 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory12 } from "@xylabs/object";
 
 // src/isHydratedBoundWitness.ts
-import { AsObjectFactory as AsObjectFactory9 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory10 } from "@xylabs/object";
 import { isBoundWitness } from "@xyo-network/boundwitness-model";
 import { isAnyPayload as isAnyPayload2, isStorageMeta as isStorageMeta2 } from "@xyo-network/payload-model";
 var isHydratedBoundWitness = (value) => {
@@ -460,10 +623,10 @@ var isHydratedBoundWitness = (value) => {
 var isHydratedBoundWitnessWithStorageMeta = (value) => {
   return isHydratedBoundWitness(value) && isStorageMeta2(value[0]) && !value[1].some((item) => !isStorageMeta2(item));
 };
-var asHydratedBoundWitness = AsObjectFactory9.create(
+var asHydratedBoundWitness = AsObjectFactory10.create(
   isHydratedBoundWitness
 );
-var asHydratedBoundWitnessWithStorageMeta = AsObjectFactory9.create(
+var asHydratedBoundWitnessWithStorageMeta = AsObjectFactory10.create(
   isHydratedBoundWitnessWithStorageMeta
 );
 
@@ -471,24 +634,24 @@ var asHydratedBoundWitnessWithStorageMeta = AsObjectFactory9.create(
 import {
   isAddress
 } from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory10 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory11 } from "@xylabs/object";
 import { isBoundWitness as isBoundWitness2 } from "@xyo-network/boundwitness-model";
 var isTransactionBoundWitness = (value) => {
   const typedObj = value;
   return isBoundWitness2(value) && isAddress(typedObj.chain) && typedObj.fees !== void 0 && typedObj.exp !== void 0 && typedObj.nbf !== void 0;
 };
-var asTransactionBoundWitness = AsObjectFactory10.create(isTransactionBoundWitness);
+var asTransactionBoundWitness = AsObjectFactory11.create(isTransactionBoundWitness);
 
 // src/transaction/AnyHydratedTransaction.ts
 var isAnyHydratedTransaction = (value) => {
   return isHydratedBoundWitness(value) && isTransactionBoundWitness(value[0]);
 };
-var asAnyHydratedTransaction = AsObjectFactory11.create(
+var asAnyHydratedTransaction = AsObjectFactory12.create(
   isAnyHydratedTransaction
 );
 
 // src/transaction/HydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory12 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory13 } from "@xylabs/object";
 import { isSigned } from "@xyo-network/boundwitness-model";
 import {
   isStorageMeta as isStorageMeta3
@@ -496,67 +659,67 @@ import {
 var isHydratedTransaction = (value) => {
   return isHydratedBoundWitness(value) && isTransactionBoundWitness(value[0]) && isSigned(value[0]) && isStorageMeta3(value[0]);
 };
-var asHydratedTransaction = AsObjectFactory12.create(
+var asHydratedTransaction = AsObjectFactory13.create(
   // eslint-disable-next-line sonarjs/deprecation
   isHydratedTransaction
 );
 
 // src/transaction/HydratedTransactionWithHashMeta.ts
-import { AsObjectFactory as AsObjectFactory13 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory14 } from "@xylabs/object";
 import {
   isStorageMeta as isStorageMeta4
 } from "@xyo-network/payload-model";
 var isHydratedTransactionWithHashMeta = (value) => {
   return isAnyHydratedTransaction(value) && isStorageMeta4(value[0]) && !value[1].some((v) => !isStorageMeta4(v));
 };
-var asHydratedTransactionWithHashMeta = AsObjectFactory13.create(
+var asHydratedTransactionWithHashMeta = AsObjectFactory14.create(
   isHydratedTransactionWithHashMeta
 );
 
 // src/transaction/HydratedTransactionWithStorageMeta.ts
-import { AsObjectFactory as AsObjectFactory14 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory15 } from "@xylabs/object";
 import {
   isStorageMeta as isStorageMeta5
 } from "@xyo-network/payload-model";
 var isHydratedTransactionWithStorageMeta = (value) => {
   return isAnyHydratedTransaction(value) && isStorageMeta5(value[0]) && !value[1].some((v) => !isStorageMeta5(v));
 };
-var asHydratedTransactionWithStorageMeta = AsObjectFactory14.create(
+var asHydratedTransactionWithStorageMeta = AsObjectFactory15.create(
   isHydratedTransactionWithStorageMeta
 );
 
 // src/transaction/SignedHydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory15 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory16 } from "@xylabs/object";
 import { isSigned as isSigned2 } from "@xyo-network/boundwitness-model";
 var isSignedHydratedTransaction = (value) => {
   return isAnyHydratedTransaction(value) && isSigned2(value[0]);
 };
-var asSignedHydratedTransaction = AsObjectFactory15.create(
+var asSignedHydratedTransaction = AsObjectFactory16.create(
   isSignedHydratedTransaction
 );
 
 // src/transaction/SignedHydratedTransactionWithHashMeta.ts
-import { AsObjectFactory as AsObjectFactory16 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory17 } from "@xylabs/object";
 import { isStorageMeta as isStorageMeta6 } from "@xyo-network/payload-model";
 var isSignedHydratedTransactionWithHashMeta = (value) => {
   return isSignedHydratedTransaction(value) && isStorageMeta6(value[0]) && !value[1].some((v) => !isStorageMeta6(v));
 };
-var asSignedHydratedTransactionWithHashMeta = AsObjectFactory16.create(
+var asSignedHydratedTransactionWithHashMeta = AsObjectFactory17.create(
   isSignedHydratedTransactionWithHashMeta
 );
 
 // src/transaction/SignedHydratedTransactionWithStorageMeta.ts
-import { AsObjectFactory as AsObjectFactory17 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory18 } from "@xylabs/object";
 import { isStorageMeta as isStorageMeta7 } from "@xyo-network/payload-model";
 var isSignedHydratedTransactionWithStorageMeta = (value) => {
   return isSignedHydratedTransaction(value) && isStorageMeta7(value[0]) && !value[1].some((v) => !isStorageMeta7(v));
 };
-var asSignedHydratedTransactionWithStorageMeta = AsObjectFactory17.create(
+var asSignedHydratedTransactionWithStorageMeta = AsObjectFactory18.create(
   isSignedHydratedTransactionWithStorageMeta
 );
 
 // src/transaction/TransactionBoundWitnessDeprecated.ts
-import { AsObjectFactory as AsObjectFactory18 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory19 } from "@xylabs/object";
 import { isSigned as isSigned3 } from "@xyo-network/boundwitness-model";
 import { isHashMeta, isStorageMeta as isStorageMeta8 } from "@xyo-network/payload-model";
 var isSignedTransactionBoundWitness = (value) => {
@@ -566,12 +729,12 @@ var isTransactionBoundWitnessWithStorageMeta = (value) => isTransactionBoundWitn
 var isTransactionBoundWitnessWithHashMeta = (value) => isTransactionBoundWitness(value) && isHashMeta(value);
 var isSignedTransactionBoundWitnessWithStorageMeta = (value) => isSignedTransactionBoundWitness(value) && isStorageMeta8(value);
 var isSignedTransactionBoundWitnessWithHashMeta = (value) => isSignedTransactionBoundWitness(value) && isHashMeta(value);
-var asTransactionBoundWitnessWithStorageMeta = AsObjectFactory18.create(isTransactionBoundWitnessWithStorageMeta);
-var asTransactionBoundWitnessWithHashMeta = AsObjectFactory18.create(isTransactionBoundWitnessWithHashMeta);
+var asTransactionBoundWitnessWithStorageMeta = AsObjectFactory19.create(isTransactionBoundWitnessWithStorageMeta);
+var asTransactionBoundWitnessWithHashMeta = AsObjectFactory19.create(isTransactionBoundWitnessWithHashMeta);
 
 // src/transaction/TransactionFeesFields.ts
 import { isHex } from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory19 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory20 } from "@xylabs/object";
 import { isObject } from "@xylabs/typeof";
 var isTransactionFeesBigInt = (value) => {
   if (!isObject(value)) {
@@ -585,7 +748,7 @@ var isTransactionFeesBigInt = (value) => {
   } = value;
   return isAttoXL1(base) && isAttoXL1(gasLimit) && isAttoXL1(gasPrice) && isAttoXL1(priority);
 };
-var asTransactionFeesBigInt = AsObjectFactory19.create(
+var asTransactionFeesBigInt = AsObjectFactory20.create(
   isTransactionFeesBigInt
 );
 var isTransactionFeesHex = (value) => {
@@ -600,29 +763,29 @@ var isTransactionFeesHex = (value) => {
   } = value;
   return isHex(base) && isHex(gasLimit) && isHex(gasPrice) && isHex(priority);
 };
-var asTransactionFeesHex = AsObjectFactory19.create(
+var asTransactionFeesHex = AsObjectFactory20.create(
   isTransactionFeesHex
 );
 
 // src/transaction/UnsignedHydratedTransaction.ts
-import { AsObjectFactory as AsObjectFactory20 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory21 } from "@xylabs/object";
 import { isUnsigned } from "@xyo-network/boundwitness-model";
 var isUnsignedHydratedTransaction = (value) => {
   return isAnyHydratedTransaction(value) && isUnsigned(value[0]);
 };
-var asUnsignedHydratedTransaction = AsObjectFactory20.create(
+var asUnsignedHydratedTransaction = AsObjectFactory21.create(
   isUnsignedHydratedTransaction
 );
 
 // src/transaction/UnsignedHydratedTransactionWithHashMeta.ts
-import { AsObjectFactory as AsObjectFactory21 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory22 } from "@xylabs/object";
 import {
   isHashMeta as isHashMeta2
 } from "@xyo-network/payload-model";
 var isUnsignedHydratedTransactionWithHashMeta = (value) => {
   return isSignedHydratedTransaction(value) && isHashMeta2(value[0]) && !value[1].some((v) => !isHashMeta2(v));
 };
-var asUnsignedHydratedTransactionWithHashMeta = AsObjectFactory21.create(
+var asUnsignedHydratedTransactionWithHashMeta = AsObjectFactory22.create(
   isUnsignedHydratedTransactionWithHashMeta
 );
 
@@ -639,20 +802,18 @@ var AllowedBlockPayloadSchemas = [
   TimeSchema,
   TransferSchema
 ];
-var isAllowedBlockPayloadSchema = (value) => {
-  return isSchema(value) && AllowedBlockPayloadSchemas.includes(value);
-};
+var AllowedBlockPayloadSchemaZod = z13.enum(AllowedBlockPayloadSchemas);
+var isAllowedBlockPayloadSchema = zodIsFactory(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
   return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isTimePayload(value) || isTransactionBoundWitness(value);
 };
 var isAllowedBlockPayloadWithHashMeta = (value) => {
   return isAllowedBlockPayload(value) && isHashMeta3(value);
 };
-var AllowedBlockPayloadZod = z4.object({ schema: z4.enum(AllowedBlockPayloadSchemas) });
 
 // src/block/BlockBoundWitness.ts
 import { isHex as isHex2 } from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory22 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory23 } from "@xylabs/object";
 import { isBoundWitness as isBoundWitness3, isSigned as isSigned4 } from "@xyo-network/boundwitness-model";
 import { isHashMeta as isHashMeta4, isStorageMeta as isStorageMeta9 } from "@xyo-network/payload-model";
 var isBlockBoundWitness = (value) => {
@@ -674,19 +835,19 @@ var isBlockBoundWitnessWithHashMeta = (value) => {
 var isSignedBlockBoundWitnessWithHashMeta = (value) => {
   return isBlockBoundWitnessWithHashMeta(value) && isSigned4(value);
 };
-var asBlockBoundWitness = AsObjectFactory22.create(isBlockBoundWitness);
-var asSignedBlockBoundWitness = AsObjectFactory22.create(isSignedBlockBoundWitness);
-var asBlockBoundWitnessWithStorageMeta = AsObjectFactory22.create(isBlockBoundWitnessWithStorageMeta);
-var asSignedBlockBoundWitnessWithStorageMeta = AsObjectFactory22.create(isSignedBlockBoundWitnessWithStorageMeta);
-var asBlockBoundWitnessWithHashMeta = AsObjectFactory22.create(isBlockBoundWitnessWithHashMeta);
-var asSignedBlockBoundWitnessWithHashMeta = AsObjectFactory22.create(isSignedBlockBoundWitnessWithHashMeta);
+var asBlockBoundWitness = AsObjectFactory23.create(isBlockBoundWitness);
+var asSignedBlockBoundWitness = AsObjectFactory23.create(isSignedBlockBoundWitness);
+var asBlockBoundWitnessWithStorageMeta = AsObjectFactory23.create(isBlockBoundWitnessWithStorageMeta);
+var asSignedBlockBoundWitnessWithStorageMeta = AsObjectFactory23.create(isSignedBlockBoundWitnessWithStorageMeta);
+var asBlockBoundWitnessWithHashMeta = AsObjectFactory23.create(isBlockBoundWitnessWithHashMeta);
+var asSignedBlockBoundWitnessWithHashMeta = AsObjectFactory23.create(isSignedBlockBoundWitnessWithHashMeta);
 
 // src/block/HydratedBlock.ts
-import { AsObjectFactory as AsObjectFactory23 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory24 } from "@xylabs/object";
 var isHydratedBlock = (value) => {
   return isHydratedBoundWitness(value) && isBlockBoundWitnessWithStorageMeta(value[0]);
 };
-var asHydratedBlock = AsObjectFactory23.create(
+var asHydratedBlock = AsObjectFactory24.create(
   isHydratedBlock
 );
 
@@ -725,137 +886,6 @@ var ELEVATE_OPCODE = "elevate";
 
 // src/constants/StepSizes.ts
 import { AsTypeFactory } from "@xylabs/object";
-
-// src/model/BlockNumber/BlockNumber.ts
-import z6 from "zod";
-
-// src/model/zod/zodAsFactory.ts
-import { assertError } from "@xylabs/hex";
-function zodAsFactory(zod) {
-  function asFunc(value, assert) {
-    const result = zod.safeParse(value);
-    if (result.success) {
-      return result.data;
-    }
-    return assertError(value, assert, result.error.message);
-  }
-  return asFunc;
-}
-
-// src/model/zod/zodIsFactory.ts
-function zodIsFactory(zod) {
-  return (value) => zod.safeParse(value).success;
-}
-
-// src/model/zod/zodToFactory.ts
-function zodToFactory(zod) {
-  return zodAsFactory(zod);
-}
-
-// src/model/BlockNumber/Numberish.ts
-import z5 from "zod";
-var NumberishZod = z5.union([z5.number(), z5.string(), z5.bigint()]).transform((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number(v) : v).pipe(z5.number());
-
-// src/model/BlockNumber/BlockNumber.ts
-var BlockNumberZod = z6.number().transform((v) => v);
-var NumberishBlockNumberZod = NumberishZod.transform((v) => v);
-var asBlockNumber = zodAsFactory(BlockNumberZod);
-var toBlockNumber = zodToFactory(NumberishBlockNumberZod);
-var BLOCK_NUMBER_ZERO = asBlockNumber(0);
-
-// src/model/BlockNumber/EthBlockNumber.ts
-import z7 from "zod";
-var EthBlockNumberZod = z7.number().transform((v) => v);
-var NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
-var asEthBlockNumber = zodAsFactory(EthBlockNumberZod);
-var toEthBlockNumber = zodToFactory(NumberishEthBlockNumberZod);
-var ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0);
-
-// src/model/BlockNumber/XL1BlockNumber.ts
-import z8 from "zod";
-var XL1BlockNumberZod = z8.number().transform((v) => v);
-var NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
-var asXL1BlockNumber = zodAsFactory(XL1BlockNumberZod);
-var toXL1BlockNumber = zodToFactory(NumberishXL1BlockNumberZod);
-var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
-
-// src/model/BlockRange/BlockRange.ts
-import { assertError as assertError2 } from "@xylabs/hex";
-import { isDefined } from "@xylabs/typeof";
-import z9 from "zod";
-var BlockRangeZod = z9.tuple([BlockNumberZod, BlockNumberZod]);
-var NumberishBlockRangeZod = z9.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
-var asBlockRange = zodAsFactory(BlockRangeZod);
-var toBlockRange = zodToFactory(NumberishBlockRangeZod);
-var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
-function fromBlockNumberKey(key, assert) {
-  const [start, end] = key.split("|").map((v) => asBlockNumber(Number(v)));
-  const result = isDefined(start) && isDefined(end) ? [start, end] : void 0;
-  return assertError2(result, assert, `Invalid BlockRangeKey: ${key}`);
-}
-
-// src/model/BlockRange/EthBlockRange.ts
-import { assertError as assertError3 } from "@xylabs/hex";
-import { isDefined as isDefined2 } from "@xylabs/typeof";
-import z10 from "zod";
-var EthBlockRangeZod = z10.tuple([EthBlockNumberZod, EthBlockNumberZod]);
-var NumberishEthBlockRangeZod = z10.tuple([NumberishEthBlockNumberZod, NumberishEthBlockNumberZod]);
-var asEthBlockRange = zodAsFactory(EthBlockRangeZod);
-var toEthBlockRange = zodToFactory(NumberishEthBlockRangeZod);
-var toEthBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
-function fromEthBlockNumberKey(key, assert) {
-  const [start, end] = key.split("|").map((v) => asEthBlockNumber(Number(v)));
-  const result = isDefined2(start) && isDefined2(end) ? [start, end] : void 0;
-  return assertError3(result, assert, `Invalid EthBlockRangeKey: ${key}`);
-}
-
-// src/model/BlockRange/Range.ts
-import z11 from "zod";
-var RangeZod = z11.tuple([z11.number(), z11.number()]);
-var isRange = zodIsFactory(RangeZod);
-var asRange = zodAsFactory(RangeZod);
-var toRange = zodToFactory(RangeZod);
-
-// src/model/BlockRange/XL1BlockRange.ts
-import { assertError as assertError4 } from "@xylabs/hex";
-import { isDefined as isDefined3 } from "@xylabs/typeof";
-import z12 from "zod";
-var XL1BlockRangeZod = z12.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
-var NumberishXL1BlockRangeZod = z12.tuple([NumberishXL1BlockNumberZod, NumberishXL1BlockNumberZod]);
-var asXL1BlockRange = zodAsFactory(XL1BlockRangeZod);
-var toXL1BlockRange = zodToFactory(NumberishXL1BlockRangeZod);
-var toXL1BlockNumberKey = (range) => `${range[0]}|${range[1]}`;
-function fromXL1BlockNumberKey(key, assert) {
-  const [start, end] = key.split("|").map((v) => asXL1BlockNumber(Number(v)));
-  const result = isDefined3(start) && isDefined3(end) ? [start, end] : void 0;
-  return assertError4(result, assert, `Invalid XL1BlockRangeKey: ${key}`);
-}
-
-// src/model/StepIdentity.ts
-import { isUndefined } from "@xylabs/typeof";
-function tryParseInt(value) {
-  if (value === "") return void 0;
-  const num = Number(value);
-  return Number.isInteger(num) ? num : void 0;
-}
-var asStepIdentity = (stepIdentityString) => {
-  try {
-    const [blockNumberString, stepString] = stepIdentityString.split("|");
-    if (isUndefined(blockNumberString) || isUndefined(stepString)) {
-      return void 0;
-    }
-    const step = tryParseInt(stepString);
-    const block = toXL1BlockNumber(blockNumberString);
-    if (isUndefined(block) || isUndefined(step)) {
-      return void 0;
-    }
-    return { block, step };
-  } catch {
-    return void 0;
-  }
-};
-
-// src/constants/StepSizes.ts
 var StepSizes = [
   asXL1BlockNumber(7, true),
   asXL1BlockNumber(31, true),
@@ -920,16 +950,16 @@ var XL1_PROTOCOL_VERSION_STRING = `${XL1_PROTOCOL_VERSION_MAJOR}.${XL1_PROTOCOL_
 var XL1_PROTOCOL_VERSION = XL1_PROTOCOL_VERSION_MAJOR * 1e6 + XL1_PROTOCOL_VERSION_MINOR * 1e3 + XL1_PROTOCOL_VERSION_PATCH;
 
 // src/fields/BlockNumber.ts
-import { AsObjectFactory as AsObjectFactory24 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory25 } from "@xylabs/object";
 import {
   isPayloadOfSchemaType as isPayloadOfSchemaType6,
   isPayloadOfSchemaTypeWithSources
 } from "@xyo-network/payload-model";
 var BlockNumberSchema = "network.xyo.chain.block.number";
 var isBlockNumberPayload = isPayloadOfSchemaType6(BlockNumberSchema);
-var asBlockNumberPayload = AsObjectFactory24.create(isBlockNumberPayload);
+var asBlockNumberPayload = AsObjectFactory25.create(isBlockNumberPayload);
 var isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchema);
-var asBlockNumberPayloadWithSources = AsObjectFactory24.create(isBlockNumberPayloadWithSources);
+var asBlockNumberPayloadWithSources = AsObjectFactory25.create(isBlockNumberPayloadWithSources);
 
 // src/network/Status.ts
 import { isPayloadOfSchemaType as isPayloadOfSchemaType7 } from "@xyo-network/payload-model";
@@ -989,8 +1019,8 @@ var isHydratedTransactionValidationError = (error) => {
   return error.name === HydratedTransactionValidationError.constructor.name;
 };
 export {
+  AllowedBlockPayloadSchemaZod,
   AllowedBlockPayloadSchemas,
-  AllowedBlockPayloadZod,
   AttoXL1,
   AttoXL1ConvertFactor,
   AttoXL1MaxValue,
@@ -1038,6 +1068,8 @@ export {
   RangeZod,
   ShiftedBigInt,
   StepCompleteSchema,
+  StepIdentitySchema,
+  StepIdentityZod,
   StepRewardFractions,
   StepSizes,
   TimeSchema,
@@ -1101,6 +1133,7 @@ export {
   asSignedHydratedTransactionWithStorageMeta,
   asStepComplete,
   asStepIdentity,
+  asStepIdentityPayload,
   asTimePayload,
   asTimePayloadWithStorageMeta,
   asTransactionBoundWitness,
@@ -1164,6 +1197,7 @@ export {
   isSignedTransactionBoundWitnessWithHashMeta,
   isSignedTransactionBoundWitnessWithStorageMeta,
   isStepComplete,
+  isStepIdentityPayload,
   isTimePayload,
   isTransactionBoundWitness,
   isTransactionBoundWitnessWithHashMeta,