@xyo-network/xl1-protocol 1.13.1 → 1.13.3

package/dist/neutral/index.mjs

@@ -727,55 +727,109 @@ var ELEVATE_OPCODE = "elevate";
 import { AsTypeFactory } from "@xylabs/object";
 
 // src/model/BlockNumber/BlockNumber.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import {
-  isArray,
-  isNumber
-} from "@xylabs/typeof";
-function asBlockNumber(value) {
-  assertEx2(isNumber(value), () => "Not a valid BlockNumber");
-  return value;
-}
-function asBlockRange(value) {
-  if (isArray(value) && value.length === 2 && isNumber(value[0]) && isNumber(value[1])) {
-    return value;
+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);
   }
-  throw new Error("Not a valid BlockNumberRange");
+  return asFunc;
 }
-var BLOCK_NUMBER_ZERO = asBlockNumber(0);
-var toBlockNumberKey = (range) => `${range[0]}|${range[1]}`;
-var fromBlockNumberKey = (key) => {
-  const [start, end] = key.split("|").map((v) => asBlockNumber(Number(v)));
-  return [start, end];
-};
 
-// src/model/BlockNumber/EthBlockNumber.ts
-function asEthBlockNumber(value) {
-  return asBlockNumber(value);
+// src/model/zod/zodIsFactory.ts
+function zodIsFactory(zod) {
+  return (value) => zod.safeParse(value).success;
 }
-function asEthBlockRange(value) {
-  return asBlockRange(value);
+
+// 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);
-var toEthBlockRangeKey = (range) => `${range[0]}|${range[1]}`;
-var fromEthBlockNumberKey = (key) => {
-  const [start, end] = key.split("|").map((v) => asEthBlockNumber(Number(v)));
-  return [start, end];
-};
 
 // src/model/BlockNumber/XL1BlockNumber.ts
-function asXL1BlockNumber(value) {
-  return asBlockNumber(value);
+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}`);
 }
-function asXL1BlockRange(value) {
-  return asBlockRange(value);
+
+// 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([BlockNumberZod, BlockNumberZod]);
+var NumberishEthBlockRangeZod = z10.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
+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}`);
 }
-var XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0);
-var toXL1BlockRangeKey = (range) => `${range[0]}|${range[1]}`;
-var fromXL1BlockNumberKey = (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([BlockNumberZod, BlockNumberZod]);
+var NumberishXL1BlockRangeZod = z12.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod]);
+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)));
-  return [start, end];
-};
+  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";
@@ -791,11 +845,10 @@ var asStepIdentity = (stepIdentityString) => {
       return void 0;
     }
     const step = tryParseInt(stepString);
-    const blockNumber = tryParseInt(blockNumberString);
-    if (isUndefined(blockNumber) || isUndefined(step)) {
+    const block = toXL1BlockNumber(blockNumberString);
+    if (isUndefined(block) || isUndefined(step)) {
       return void 0;
     }
-    const block = asXL1BlockNumber(blockNumber);
     return { block, step };
   } catch {
     return void 0;
@@ -804,15 +857,15 @@ var asStepIdentity = (stepIdentityString) => {
 
 // src/constants/StepSizes.ts
 var StepSizes = [
-  asXL1BlockNumber(7),
-  asXL1BlockNumber(31),
-  asXL1BlockNumber(211),
-  asXL1BlockNumber(2311),
-  asXL1BlockNumber(30031),
-  asXL1BlockNumber(510511),
-  asXL1BlockNumber(9699691),
-  asXL1BlockNumber(223092871),
-  asXL1BlockNumber(6469693231)
+  asXL1BlockNumber(7, true),
+  asXL1BlockNumber(31, true),
+  asXL1BlockNumber(211, true),
+  asXL1BlockNumber(2311, true),
+  asXL1BlockNumber(30031, true),
+  asXL1BlockNumber(510511, true),
+  asXL1BlockNumber(9699691, true),
+  asXL1BlockNumber(223092871, true),
+  asXL1BlockNumber(6469693231, true)
 ];
 function isValidStep(step) {
   if (typeof step === "number" && Number.isInteger(step)) {
@@ -943,6 +996,8 @@ export {
   AttoXL1MaxValue,
   BLOCK_NUMBER_ZERO,
   BlockNumberSchema,
+  BlockNumberZod,
+  BlockRangeZod,
   BoundWitnessValidationError,
   BridgeDestinationObservationFieldsZod,
   BridgeDestinationObservationSchema,
@@ -956,6 +1011,8 @@ export {
   ChainStakeIntentSchema,
   ELEVATE_OPCODE,
   ETH_BLOCK_NUMBER_ZERO,
+  EthBlockNumberZod,
+  EthBlockRangeZod,
   FemtoXL1,
   FemtoXL1MaxValue,
   HashSchema,
@@ -969,8 +1026,16 @@ export {
   NanoXL1,
   NanoXL1MaxValue,
   NetworkStatusSchema,
+  NumberishBlockNumberZod,
+  NumberishBlockRangeZod,
+  NumberishEthBlockNumberZod,
+  NumberishEthBlockRangeZod,
+  NumberishXL1BlockNumberZod,
+  NumberishXL1BlockRangeZod,
+  NumberishZod,
   PicoXL1,
   PicoXL1MaxValue,
+  RangeZod,
   ShiftedBigInt,
   StepCompleteSchema,
   StepRewardFractions,
@@ -981,6 +1046,8 @@ export {
   ValidationError,
   XL1,
   XL1Amount,
+  XL1BlockNumberZod,
+  XL1BlockRangeZod,
   XL1MaxValue,
   XL1Places,
   XL1_BLOCK_NUMBER_ZERO,
@@ -1025,6 +1092,7 @@ export {
   asMilliXL1,
   asNanoXL1,
   asPicoXL1,
+  asRange,
   asSignedBlockBoundWitness,
   asSignedBlockBoundWitnessWithHashMeta,
   asSignedBlockBoundWitnessWithStorageMeta,
@@ -1084,6 +1152,7 @@ export {
   isNanoXL1,
   isNetworkStatus,
   isPicoXL1,
+  isRange,
   isSafeEpoch,
   isSignedBlockBoundWitness,
   isSignedBlockBoundWitnessWithHashMeta,
@@ -1112,14 +1181,24 @@ export {
   splitOnDecimalToString,
   stepSize,
   toAttoXL1,
+  toBlockNumber,
   toBlockNumberKey,
-  toEthBlockRangeKey,
+  toBlockRange,
+  toEthBlockNumber,
+  toEthBlockNumberKey,
+  toEthBlockRange,
   toFemtoXL1,
   toMicroXL1,
   toMilliXL1,
   toNanoXL1,
   toPicoXL1,
+  toRange,
   toXL1,
-  toXL1BlockRangeKey
+  toXL1BlockNumber,
+  toXL1BlockNumberKey,
+  toXL1BlockRange,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
 };
 //# sourceMappingURL=index.mjs.map