@xyo-network/xl1-protocol 1.13.11 → 1.13.13

package/dist/neutral/block/AllowedBlockPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AllowedBlockPayload.d.ts","sourceRoot":"","sources":["../../../src/block/AllowedBlockPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAEvE,OAAO,CAAC,MAAM,KAAK,CAAA;AAGnB,OAAO,KAAK,EACV,4BAA4B,EAAE,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EACxI,MAAM,qBAAqB,CAAA;AAM5B,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AAEjG,MAAM,MAAM,mBAAmB,GAC3B,QAAQ,GACN,4BAA4B,GAC5B,YAAY,GACZ,uBAAuB,GACvB,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,uBAAuB,CAAA;AAE7B,eAAO,MAAM,0BAA0B,0UAWnB,CAAA;AAEpB,eAAO,MAAM,4BAA4B;;;;;;;;;;;EAAqC,CAAA;AAC9E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,eAAO,MAAM,2BAA2B,mWAAwE,CAAA;AAEhH,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,mBAU/D,CAAA;AAED,eAAO,MAAM,iCAAiC,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAAe,CAAC,mBAAmB,CAE9G,CAAA"}
+{"version":3,"file":"AllowedBlockPayload.d.ts","sourceRoot":"","sources":["../../../src/block/AllowedBlockPayload.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAEvE,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EACV,4BAA4B,EAAE,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EACxI,MAAM,qBAAqB,CAAA;AAM5B,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AAEjG,MAAM,MAAM,mBAAmB,GAC3B,QAAQ,GACN,4BAA4B,GAC5B,YAAY,GACZ,uBAAuB,GACvB,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,uBAAuB,CAAA;AAE7B,eAAO,MAAM,0BAA0B,0UAWnB,CAAA;AAEpB,eAAO,MAAM,4BAA4B;;;;;;;;;;;EAAqC,CAAA;AAC9E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,eAAO,MAAM,2BAA2B,mWAAwE,CAAA;AAEhH,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,mBAU/D,CAAA;AAED,eAAO,MAAM,iCAAiC,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAAe,CAAC,mBAAmB,CAE9G,CAAA"}

package/dist/neutral/index.mjs

@@ -284,169 +284,12 @@ var XL1Amount = class _XL1Amount {
 };
 
 // src/block/AllowedBlockPayload.ts
+import { zodIsFactory as zodIsFactory2 } from "@xylabs/zod";
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { isHashMeta as isHashMeta3 } from "@xyo-network/payload-model";
 import { isSchemaPayload, SchemaSchema } from "@xyo-network/schema-payload-plugin";
 import z15 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;
-    }
-    if (assert !== void 0) {
-      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: XL1BlockNumberZod.describe("The block number at which the step occurs"),
-  step: z10.number().int().nonnegative().describe("The index of the step into the StepSize array")
-});
-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";
 import { AsObjectFactory } from "@xylabs/object";
@@ -454,8 +297,8 @@ import { isPayloadOfZodType } from "@xyo-network/payload-model";
 
 // src/payload/elevatable/Bridge/BridgeDetails.ts
 import { HexZod } from "@xylabs/hex";
-import z11 from "zod";
-var BridgeDetailsDestinationFieldsZod = z11.object({
+import z2 from "zod";
+var BridgeDetailsDestinationFieldsZod = z2.object({
   /**
    * Destination network
    */
@@ -473,7 +316,7 @@ var BridgeDetailsDestinationFieldsZod = z11.object({
    */
   destToken: HexZod.describe("The token being bridged to")
 });
-var BridgeDetailsSourceFieldsZod = z11.object({
+var BridgeDetailsSourceFieldsZod = z2.object({
   /**
    * Source network
    */
@@ -512,13 +355,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 z12 from "zod";
+import z3 from "zod";
 var BridgeIntentSchema = "network.xyo.chain.bridge.intent";
 var BridgeIntentFieldsZod = BridgeDetailsFieldsZod.extend({
   /**
    * Unique identifier for replay protection
    */
-  nonce: z12.string().describe("Unique identifier for replay protection")
+  nonce: z3.string().describe("Unique identifier for replay protection")
 });
 var isBridgeIntent = isPayloadOfZodType2(
   BridgeIntentFieldsZod,
@@ -589,46 +432,46 @@ var asStepComplete = AsObjectFactory6.create(isStepComplete);
 import { HashZod } from "@xylabs/hex";
 import { AsObjectFactory as AsObjectFactory8 } from "@xylabs/object";
 import { isPayloadOfSchemaType as isPayloadOfSchemaType5 } from "@xyo-network/payload-model";
-import z14 from "zod";
+import z5 from "zod";
 
 // src/payload/elevatable/TransferPayload.ts
 import {
   AddressZod,
   HexZod as HexZod4
 } from "@xylabs/hex";
-import { AsObjectFactory as AsObjectFactory7 } from "@xylabs/object";
+import { AsObjectFactory as AsObjectFactory7, JsonObjectZod } from "@xylabs/object";
 import { isPayloadOfSchemaType as isPayloadOfSchemaType4, PayloadZod } from "@xyo-network/payload-model";
-import z13 from "zod";
+import z4 from "zod";
 var TransferSchema = "network.xyo.transfer";
-var TransferFieldsZod = z13.object({
-  $opCodes: z13.array(z13.string()).optional(),
-  context: z13.record(z13.string(), z13.json()).optional(),
-  epoch: z13.number(),
+var TransferFieldsZod = z4.object({
+  $opCodes: z4.array(z4.string()).optional(),
+  context: JsonObjectZod.optional(),
+  epoch: z4.number(),
   from: AddressZod,
-  transfers: z13.record(AddressZod, HexZod4)
+  transfers: z4.record(AddressZod, HexZod4)
 });
-var PayloadZodOfSchema = (schema) => PayloadZod.extend({ schema: z13.literal(schema) });
+var PayloadZodOfSchema = (schema) => PayloadZod.extend({ schema: z4.literal(schema) });
 var TransferZod = PayloadZodOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
 var isTransfer = isPayloadOfSchemaType4(TransferSchema);
 var asTransfer = AsObjectFactory7.create(isTransfer);
 
 // src/payload/elevatable/Time.ts
 var TimeSchema = "network.xyo.time";
-var XL1TimeFieldsZod = z14.object({
+var XL1TimeFieldsZod = z5.object({
   // block number
-  xl1: z14.number().optional(),
+  xl1: z5.number().optional(),
   // block hash
   xl1Hash: HashZod.optional()
 });
-var EthereumTimeFieldsZod = z14.object({
+var EthereumTimeFieldsZod = z5.object({
   // block number
-  ethereum: z14.number().optional(),
+  ethereum: z5.number().optional(),
   // block hash
   ethereumHash: HashZod.optional()
 });
-var EpochTimeFieldsZod = z14.object({
+var EpochTimeFieldsZod = z5.object({
   // in milliseconds
-  epoch: z14.number()
+  epoch: z5.number()
 });
 var TimeFieldsZod = XL1TimeFieldsZod.extend(XL1TimeFieldsZod.shape).extend(EthereumTimeFieldsZod.shape).extend(EpochTimeFieldsZod.shape);
 var TimePayloadZod = PayloadZodOfSchema(TimeSchema).extend(TimeFieldsZod.shape);
@@ -644,6 +487,130 @@ var asTimePayloadWithStorageMeta = AsObjectFactory8.create(isTimePayload);
 // src/payload/StepIdentityPayload.ts
 import { AsObjectFactory as AsObjectFactory9 } from "@xylabs/object";
 import { isPayloadOfZodType as isPayloadOfZodType4 } from "@xyo-network/payload-model";
+
+// src/model/BlockNumber/BlockNumber.ts
+import { zodAsFactory, zodToFactory } from "@xylabs/zod";
+import z7 from "zod";
+
+// src/model/BlockNumber/Numberish.ts
+import z6 from "zod";
+var NumberishZod = z6.union([z6.number(), z6.string(), z6.bigint()]).transform((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number(v) : v).pipe(z6.number());
+
+// src/model/BlockNumber/BlockNumber.ts
+var BlockNumberZod = z7.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 { zodAsFactory as zodAsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/zod";
+import z8 from "zod";
+var EthBlockNumberZod = z8.number().transform((v) => v);
+var NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var asEthBlockNumber = zodAsFactory2(EthBlockNumberZod, "asEthBlockNumber");
+var toEthBlockNumber = zodToFactory2(NumberishEthBlockNumberZod, "toEthBlockNumber");
+var ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0);
+
+// src/model/BlockNumber/XL1BlockNumber.ts
+import { zodAsFactory as zodAsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/zod";
+import z9 from "zod";
+var XL1BlockNumberZod = z9.number().transform((v) => v);
+var NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform((v) => v);
+var asXL1BlockNumber = zodAsFactory3(XL1BlockNumberZod, "asXL1BlockNumber");
+var toXL1BlockNumber = zodToFactory3(NumberishXL1BlockNumberZod, "toXL1BlockNumber");
+var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
+
+// src/model/BlockRange/BlockRange.ts
+import { assertError } from "@xylabs/error";
+import { isDefined } from "@xylabs/typeof";
+import { zodAsFactory as zodAsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/zod";
+import z10 from "zod";
+var BlockRangeZod = z10.tuple([BlockNumberZod, BlockNumberZod]);
+var NumberishBlockRangeZod = z10.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
+var asBlockRange = zodAsFactory4(BlockRangeZod, "BlockRange");
+var toBlockRange = zodToFactory4(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 assertError(result, assert, `Invalid BlockRangeKey: ${key}`);
+}
+
+// src/model/BlockRange/EthBlockRange.ts
+import { assertError as assertError2 } from "@xylabs/error";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
+import { zodAsFactory as zodAsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/zod";
+import z11 from "zod";
+var EthBlockRangeZod = z11.tuple([EthBlockNumberZod, EthBlockNumberZod]);
+var NumberishEthBlockRangeZod = z11.tuple([NumberishEthBlockNumberZod, NumberishEthBlockNumberZod]);
+var asEthBlockRange = zodAsFactory5(EthBlockRangeZod, "EthBlockRange");
+var toEthBlockRange = zodToFactory5(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 assertError2(result, assert, `Invalid EthBlockRangeKey: ${key}`);
+}
+
+// src/model/BlockRange/Range.ts
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory,
+  zodToFactory as zodToFactory6
+} from "@xylabs/zod";
+import z12 from "zod";
+var RangeZod = z12.tuple([z12.number(), z12.number()]);
+var isRange = zodIsFactory(RangeZod);
+var asRange = zodAsFactory6(RangeZod, "Range");
+var toRange = zodToFactory6(RangeZod, "Range");
+
+// src/model/BlockRange/XL1BlockRange.ts
+import { assertError as assertError3 } from "@xylabs/error";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { zodAsFactory as zodAsFactory7, zodToFactory as zodToFactory7 } from "@xylabs/zod";
+import z13 from "zod";
+var XL1BlockRangeZod = z13.tuple([XL1BlockNumberZod, XL1BlockNumberZod]);
+var NumberishXL1BlockRangeZod = z13.tuple([NumberishXL1BlockNumberZod, NumberishXL1BlockNumberZod]);
+var asXL1BlockRange = zodAsFactory7(XL1BlockRangeZod, "XL1BlockRange");
+var toXL1BlockRange = zodToFactory7(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 assertError3(result, assert, `Invalid XL1BlockRangeKey: ${key}`);
+}
+
+// src/model/StepIdentity.ts
+import { isUndefined } from "@xylabs/typeof";
+import * as z14 from "zod";
+var StepIdentityZod = z14.object({
+  block: XL1BlockNumberZod.describe("The block number at which the step occurs"),
+  step: z14.number().int().nonnegative().describe("The index of the step into the StepSize array")
+});
+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/StepIdentityPayload.ts
 var StepIdentitySchema = "network.xyo.chain.step.identity";
 var isStepIdentityPayload = isPayloadOfZodType4(StepIdentityZod, StepIdentitySchema);
 var asStepIdentityPayload = AsObjectFactory9.create(isStepIdentityPayload);
@@ -841,7 +808,7 @@ var AllowedBlockPayloadSchemas = [
   TransferSchema
 ];
 var AllowedBlockPayloadSchemaZod = z15.enum(AllowedBlockPayloadSchemas);
-var isAllowedBlockPayloadSchema = zodIsFactory(AllowedBlockPayloadSchemaZod);
+var isAllowedBlockPayloadSchema = zodIsFactory2(AllowedBlockPayloadSchemaZod);
 var isAllowedBlockPayload = (value) => {
   return isTransfer(value) || isBridgeDestinationObservation(value) || isBridgeIntent(value) || isBridgeSourceObservation(value) || isChainStakeIntent(value) || isHashPayload(value) || isSchemaPayload(value) || isTimePayload(value) || isTransactionBoundWitness(value);
 };
@@ -1276,9 +1243,6 @@ export {
   toXL1,
   toXL1BlockNumber,
   toXL1BlockNumberKey,
-  toXL1BlockRange,
-  zodAsFactory,
-  zodIsFactory,
-  zodToFactory
+  toXL1BlockRange
 };
 //# sourceMappingURL=index.mjs.map