@xyo-network/xl1-protocol 1.25.2 → 1.25.4

package/dist/neutral/index.mjs

@@ -827,9 +827,10 @@ import {
   zodToFactory as zodToFactory10
 } from "@xylabs/sdk-js";
 import {
+  PayloadZod,
   PayloadZodLoose,
-  WithHashMetaZod as WithHashMetaZod2,
-  WithStorageMetaZod as WithStorageMetaZod2
+  WithHashMetaZod as WithHashMetaZod3,
+  WithStorageMetaZod as WithStorageMetaZod3
 } from "@xyo-network/sdk-js";
 import { z as z16 } from "zod";
 
@@ -851,8 +852,8 @@ import {
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory8
 } from "@xylabs/sdk-js";
-import { HashMetaZod as HashMetaZod2, PayloadBuilder } from "@xyo-network/sdk-js";
-var SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.safeExtend(HashMetaZod2.shape);
+import { PayloadBuilder, WithHashMetaZod as WithHashMetaZod2 } from "@xyo-network/sdk-js";
+var SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod2(SignedBlockBoundWitnessZod);
 var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory6(SignedBlockBoundWitnessWithHashMetaZod);
 var asSignedBlockBoundWitnessWithHashMeta = zodAsFactory8(SignedBlockBoundWitnessWithHashMetaZod, "asSignedBlockBoundWitnessWithHashMeta");
 var SignedBlockBoundWitnessWithHashMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
@@ -872,8 +873,8 @@ import {
   zodIsFactory as zodIsFactory7,
   zodToFactory as zodToFactory9
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2, StorageMetaZod as StorageMetaZod2 } from "@xyo-network/sdk-js";
-var SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.safeExtend(StorageMetaZod2.shape);
+import { PayloadBuilder as PayloadBuilder2, WithStorageMetaZod as WithStorageMetaZod2 } from "@xyo-network/sdk-js";
+var SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod2(SignedBlockBoundWitnessZod);
 var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory7(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory9(
   SignedBlockBoundWitnessWithStorageMetaZod,
@@ -902,54 +903,54 @@ var isHydratedBlock = zodIsFactory8(HydratedBlockZod);
 var asHydratedBlock = zodAsFactory10(HydratedBlockZod, "asHydratedBlock");
 var toHydratedBlock = zodToFactory10(HydratedBlockZod, "toHydratedBlock");
 var HydratedBlockWithHashMetaZod = z16.tuple([
-  WithHashMetaZod2(BlockBoundWitnessZod),
-  z16.array(WithHashMetaZod2(PayloadZodLoose))
+  WithHashMetaZod3(BlockBoundWitnessZod),
+  z16.array(WithHashMetaZod3(PayloadZod).loose())
 ]);
 var isHydratedBlockWithHashMeta = zodIsFactory8(HydratedBlockWithHashMetaZod);
 var asHydratedBlockWithHashMeta = zodAsFactory10(HydratedBlockWithHashMetaZod, "asHydratedBlockWithHashMeta");
 var toHydratedBlockWithHashMeta = zodToFactory10(HydratedBlockWithHashMetaZod, "toHydratedBlockWithHashMeta");
 var HydratedBlockWithStorageMetaZod = z16.tuple([
-  WithStorageMetaZod2(BlockBoundWitnessZod),
-  z16.array(WithStorageMetaZod2(PayloadZodLoose))
+  WithStorageMetaZod3(BlockBoundWitnessZod),
+  z16.array(WithStorageMetaZod3(PayloadZod).loose())
 ]);
 var isHydratedBlockWithStorageMeta = zodIsFactory8(HydratedBlockWithStorageMetaZod);
 var asHydratedBlockWithStorageMeta = zodAsFactory10(HydratedBlockWithStorageMetaZod, "asHydratedBlockWithStorageMeta");
 var toHydratedBlockWithStorageMeta = zodToFactory10(HydratedBlockWithStorageMetaZod, "toHydratedBlockWithStorageMeta");
 var SignedHydratedBlockZod = z16.tuple([
   SignedBlockBoundWitnessZod,
-  z16.array(PayloadZodLoose)
+  z16.array(PayloadZod.loose())
 ]);
 var isSignedHydratedBlock = zodIsFactory8(SignedHydratedBlockZod);
 var asSignedHydratedBlock = zodAsFactory10(SignedHydratedBlockZod, "asSignedHydratedBlock");
 var toSignedHydratedBlock = zodToFactory10(SignedHydratedBlockZod, "toSignedHydratedBlock");
 var SignedHydratedBlockToJsonZod = z16.tuple([
   SignedBlockBoundWitnessZod,
-  z16.array(PayloadZodLoose)
+  z16.array(PayloadZod.loose())
 ]);
 var isSignedHydratedBlockToJson = zodIsFactory8(SignedHydratedBlockToJsonZod);
 var asSignedHydratedBlockToJson = zodAsFactory10(SignedHydratedBlockToJsonZod, "asSignedHydratedBlockToJson");
 var toSignedHydratedBlockToJson = zodToFactory10(SignedHydratedBlockToJsonZod, "toSignedHydratedBlockToJson");
 var SignedHydratedBlockWithHashMetaZod = z16.tuple([
-  WithHashMetaZod2(SignedBlockBoundWitnessZod),
-  z16.array(WithHashMetaZod2(PayloadZodLoose))
+  WithHashMetaZod3(SignedBlockBoundWitnessZod),
+  z16.array(WithHashMetaZod3(PayloadZod).loose())
 ]);
 var SignedHydratedBlockWithHashMetaishZod = z16.tuple([
-  z16.union([WithHashMetaZod2(SignedBlockBoundWitnessZod)]),
-  z16.array(WithHashMetaZod2(PayloadZodLoose))
+  z16.union([WithHashMetaZod3(SignedBlockBoundWitnessZod)]),
+  z16.array(WithHashMetaZod3(PayloadZod).loose())
 ]);
 var isSignedHydratedBlockWithHashMeta = zodIsFactory8(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory10(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 var toSignedHydratedBlockWithHashMeta = zodToFactory10(SignedHydratedBlockWithHashMetaZod, "toSignedHydratedBlockWithHashMeta");
 var SignedHydratedBlockWithStorageMetaZod = z16.tuple([
-  WithStorageMetaZod2(SignedBlockBoundWitnessZod),
-  z16.array(WithStorageMetaZod2(PayloadZodLoose))
+  WithStorageMetaZod3(SignedBlockBoundWitnessZod),
+  z16.array(WithStorageMetaZod3(PayloadZod).loose())
 ]);
 var isSignedHydratedBlockWithStorageMeta = zodIsFactory8(SignedHydratedBlockWithStorageMetaZod);
 var asSignedHydratedBlockWithStorageMeta = zodAsFactory10(SignedHydratedBlockWithStorageMetaZod, "asSignedHydratedBlockWithStorageMeta");
 var toSignedHydratedBlockWithStorageMeta = zodToFactory10(SignedHydratedBlockWithStorageMetaZod, "toSignedHydratedBlockWithStorageMeta");
 var SignedHydratedBlockWithStorageMetaishZod = z16.tuple([
-  z16.union([WithStorageMetaZod2(SignedBlockBoundWitnessZod)]),
-  z16.array(WithStorageMetaZod2(PayloadZodLoose))
+  z16.union([WithStorageMetaZod3(SignedBlockBoundWitnessZod)]),
+  z16.array(WithStorageMetaZod3(PayloadZod).loose())
 ]);
 
 // src/block/unsigned/UnsignedBlockBoundWitness.ts
@@ -979,7 +980,7 @@ var asBlockNumberPayloadWithSources = AsObjectFactory10.create(isBlockNumberPayl
 
 // src/model/AccountBalance.ts
 import { zodIsFactory as zodIsFactory12 } from "@xylabs/sdk-js";
-import { WithHashMetaZod as WithHashMetaZod3 } from "@xyo-network/sdk-js";
+import { WithHashMetaZod as WithHashMetaZod4 } from "@xyo-network/sdk-js";
 import { z as z22 } from "zod";
 
 // src/model/ChainQualification.ts
@@ -1077,9 +1078,9 @@ var ChainQualifiedZod = (zodType) => {
 
 // src/model/AccountBalance.ts
 var AccountBalanceHistoryItemZod = z22.tuple([
-  WithHashMetaZod3(BlockBoundWitnessZod),
-  WithHashMetaZod3(TransactionBoundWitnessZod).nullable(),
-  WithHashMetaZod3(TransferZod)
+  WithHashMetaZod4(BlockBoundWitnessZod),
+  WithHashMetaZod4(TransactionBoundWitnessZod).nullable(),
+  WithHashMetaZod4(TransferZod)
 ]);
 var AccountBalanceQualificationZod = ChainQualificationZod;
 var isAccountBalanceQualification = zodIsFactory12(AccountBalanceQualificationZod);
@@ -1208,39 +1209,28 @@ var CachingContextZod = BaseContextZod.extend({ caches: CachesZod });
 
 // src/model/Context/BlockContext.zod.ts
 var BlockContextReadZod = CachingContextZod.extend(
-  { chainMap: z26.custom((val) => val && typeof val === "object" && ("get" in val || "set" in val)) }
+  { chainMap: z26.custom((val) => val && typeof val === "object" && "get" in val) }
 );
 var BlockContextWriteZod = CachingContextZod.extend(
-  { chainMap: z26.custom((val) => val && typeof val === "object" && ("get" in val || "set" in val)) }
-);
-var BlockContextZod = z26.intersection(
-  BlockContextReadZod,
-  BlockContextWriteZod
+  { chainMap: z26.custom((val) => val && typeof val === "object" && ("get" in val && "insert" in val)) }
 );
-
-// src/model/Context/ChainContext.zod.ts
-import z28 from "zod";
+var BlockContextZod = BlockContextWriteZod;
 
 // src/model/Context/HeadContext.zod.ts
-import { WithHashMetaZod as WithHashMetaZod4 } from "@xyo-network/sdk-js";
+import { WithHashMetaZod as WithHashMetaZod5 } from "@xyo-network/sdk-js";
 import z27 from "zod";
 var HeadContextBaseZod = z27.object(
-  { head: WithHashMetaZod4(BlockBoundWitnessZod) }
+  { head: WithHashMetaZod5(BlockBoundWitnessZod) }
 );
-var HeadContextZod = z27.intersection(CachingContextZod, HeadContextBaseZod);
+var HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape);
 
 // src/model/Context/ChainContext.zod.ts
-var ChainContextReadZod = z28.intersection(
-  HeadContextBaseZod,
-  BlockContextReadZod
+var ChainContextReadZod = BlockContextReadZod.safeExtend(HeadContextBaseZod.shape);
+var ChainContextWriteZod = BlockContextWriteZod.safeExtend(
+  HeadContextBaseZod.shape
 );
-var ChainContextWriteZod = z28.intersection(
-  HeadContextBaseZod,
-  BlockContextWriteZod
-);
-var ChainContextZod = z28.intersection(
-  ChainContextReadZod,
-  ChainContextWriteZod
+var ChainContextZod = BlockContextZod.safeExtend(
+  HeadContextBaseZod.shape
 );
 
 // src/model/defaultRewardRatio.ts
@@ -1269,49 +1259,50 @@ import {
   zodToFactory as zodToFactory16
 } from "@xylabs/sdk-js";
 import {
+  PayloadZod as PayloadZod2,
   PayloadZodLoose as PayloadZodLoose2,
-  WithHashMetaZod as WithHashMetaZod5,
-  WithStorageMetaZod as WithStorageMetaZod3
+  WithHashMetaZod as WithHashMetaZod6,
+  WithStorageMetaZod as WithStorageMetaZod4
 } from "@xyo-network/sdk-js";
-import { z as z29 } from "zod";
-var HydratedTransactionZod = z29.tuple([
+import { z as z28 } from "zod";
+var HydratedTransactionZod = z28.tuple([
   TransactionBoundWitnessZod,
-  z29.array(PayloadZodLoose2)
+  z28.array(PayloadZodLoose2)
 ]);
 var isHydratedTransaction = zodIsFactory14(HydratedTransactionZod);
 var asHydratedTransaction = zodAsFactory17(HydratedTransactionZod, "asHydratedTransaction");
 var toHydratedTransaction = zodToFactory16(HydratedTransactionZod, "toHydratedTransaction");
-var HydratedTransactionWithHashMetaZod = z29.tuple([
-  WithHashMetaZod5(TransactionBoundWitnessZod),
-  z29.array(WithHashMetaZod5(PayloadZodLoose2))
+var HydratedTransactionWithHashMetaZod = z28.tuple([
+  WithHashMetaZod6(TransactionBoundWitnessZod),
+  z28.array(WithHashMetaZod6(PayloadZodLoose2))
 ]);
 var isHydratedTransactionWithHashMeta = zodIsFactory14(HydratedTransactionWithHashMetaZod);
 var asHydratedTransactionWithHashMeta = zodAsFactory17(HydratedTransactionWithHashMetaZod, "asHydratedTransactionWithHashMeta");
 var toHydratedTransactionWithHashMeta = zodToFactory16(HydratedTransactionWithHashMetaZod, "toHydratedTransactionWithHashMeta");
-var HydratedTransactionWithStorageMetaZod = z29.tuple([
-  WithStorageMetaZod3(TransactionBoundWitnessZod),
-  z29.array(WithStorageMetaZod3(PayloadZodLoose2))
+var HydratedTransactionWithStorageMetaZod = z28.tuple([
+  WithStorageMetaZod4(TransactionBoundWitnessZod),
+  z28.array(WithStorageMetaZod4(PayloadZodLoose2))
 ]);
 var isHydratedTransactionWithStorageMeta = zodIsFactory14(HydratedTransactionWithStorageMetaZod);
 var asHydratedTransactionWithStorageMeta = zodAsFactory17(HydratedTransactionWithStorageMetaZod, "asHydratedTransactionWithStorageMeta");
 var toHydratedTransactionWithStorageMeta = zodToFactory16(HydratedTransactionWithStorageMetaZod, "toHydratedTransactionWithStorageMeta");
-var UnsignedHydratedTransactionZod = z29.tuple([
+var UnsignedHydratedTransactionZod = z28.tuple([
   UnsignedTransactionBoundWitnessZod,
-  z29.array(PayloadZodLoose2)
+  z28.array(PayloadZodLoose2)
 ]);
 var isUnsignedHydratedTransaction = zodIsFactory14(UnsignedHydratedTransactionZod);
 var asUnsignedHydratedTransaction = zodAsFactory17(UnsignedHydratedTransactionZod, "asUnsignedHydratedTransaction");
 var toUnsignedHydratedTransaction = zodToFactory16(UnsignedHydratedTransactionZod, "toUnsignedHydratedTransaction");
-var UnsignedHydratedTransactionWithHashMetaZod = z29.tuple([
-  WithHashMetaZod5(UnsignedTransactionBoundWitnessZod),
-  z29.array(WithHashMetaZod5(PayloadZodLoose2))
+var UnsignedHydratedTransactionWithHashMetaZod = z28.tuple([
+  WithHashMetaZod6(UnsignedTransactionBoundWitnessZod),
+  z28.array(WithHashMetaZod6(PayloadZodLoose2))
 ]);
 var isUnsignedHydratedTransactionWithHashMeta = zodIsFactory14(UnsignedHydratedTransactionWithHashMetaZod);
 var asUnsignedHydratedTransactionWithHashMeta = zodAsFactory17(UnsignedHydratedTransactionWithHashMetaZod, "asUnsignedHydratedTransactionWithHashMeta");
 var toUnsignedHydratedTransactionWithHashMeta = zodToFactory16(UnsignedHydratedTransactionWithHashMetaZod, "toUnsignedHydratedTransactionWithHashMeta");
-var UnsignedHydratedTransactionWithStorageMetaZod = z29.tuple([
-  WithStorageMetaZod3(UnsignedTransactionBoundWitnessZod),
-  z29.array(WithStorageMetaZod3(PayloadZodLoose2))
+var UnsignedHydratedTransactionWithStorageMetaZod = z28.tuple([
+  WithStorageMetaZod4(UnsignedTransactionBoundWitnessZod),
+  z28.array(WithStorageMetaZod4(PayloadZodLoose2))
 ]);
 var isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory14(UnsignedHydratedTransactionWithStorageMetaZod);
 var asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory17(
@@ -1322,23 +1313,23 @@ var toUnsignedHydratedTransactionWithStorageMeta = zodToFactory16(
   UnsignedHydratedTransactionWithStorageMetaZod,
   "toUnsignedHydratedTransactionWithStorageMeta"
 );
-var SignedHydratedTransactionZod = z29.tuple([
+var SignedHydratedTransactionZod = z28.tuple([
   SignedTransactionBoundWitnessZod,
-  z29.array(PayloadZodLoose2)
+  z28.array(PayloadZodLoose2)
 ]);
 var isSignedHydratedTransaction = zodIsFactory14(SignedHydratedTransactionZod);
 var asSignedHydratedTransaction = zodAsFactory17(SignedHydratedTransactionZod, "asSignedHydratedTransaction");
 var toSignedHydratedTransaction = zodToFactory16(SignedHydratedTransactionZod, "toSignedHydratedTransaction");
-var SignedHydratedTransactionWithHashMetaZod = z29.tuple([
-  WithHashMetaZod5(SignedTransactionBoundWitnessZod),
-  z29.array(WithHashMetaZod5(PayloadZodLoose2))
+var SignedHydratedTransactionWithHashMetaZod = z28.tuple([
+  WithHashMetaZod6(SignedTransactionBoundWitnessZod),
+  z28.array(WithHashMetaZod6(PayloadZod2).loose())
 ]);
 var isSignedHydratedTransactionWithHashMeta = zodIsFactory14(SignedHydratedTransactionWithHashMetaZod);
 var asSignedHydratedTransactionWithHashMeta = zodAsFactory17(SignedHydratedTransactionWithHashMetaZod, "asSignedHydratedTransactionWithHashMeta");
 var toSignedHydratedTransactionWithHashMeta = zodToFactory16(SignedHydratedTransactionWithHashMetaZod, "toSignedHydratedTransactionWithHashMeta");
-var SignedHydratedTransactionWithStorageMetaZod = z29.tuple([
-  WithStorageMetaZod3(SignedTransactionBoundWitnessZod),
-  z29.array(WithStorageMetaZod3(PayloadZodLoose2))
+var SignedHydratedTransactionWithStorageMetaZod = z28.tuple([
+  WithStorageMetaZod4(SignedTransactionBoundWitnessZod),
+  z28.array(WithStorageMetaZod4(PayloadZod2).loose())
 ]);
 var isSignedHydratedTransactionWithStorageMeta = zodIsFactory14(SignedHydratedTransactionWithStorageMetaZod);
 var asSignedHydratedTransactionWithStorageMeta = zodAsFactory17(
@@ -1354,22 +1345,22 @@ var toSignedHydratedTransactionWithStorageMeta = zodToFactory16(
 var ELEVATE_OPCODE = "elevate";
 
 // src/model/Permission.ts
-import { z as z30 } from "zod";
-var CaveatTypesZod = z30.enum(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
-var CaveatsZod = z30.object({
+import { z as z29 } from "zod";
+var CaveatTypesZod = z29.enum(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
+var CaveatsZod = z29.object({
   type: CaveatTypesZod,
-  value: z30.json()
+  value: z29.json()
 });
-var PermissionZod = z30.object({
-  parentCapability: z30.string(),
+var PermissionZod = z29.object({
+  parentCapability: z29.string(),
   caveats: CaveatsZod.array().optional(),
-  invoker: z30.string()
+  invoker: z29.string()
 });
-var InvokerPermissionZod = PermissionZod.safeExtend({ date: z30.number().optional() });
-var PermissionRequestZod = z30.record(z30.string(), z30.record(z30.string(), z30.any()));
-var RequestedPermissionZod = z30.object({
-  parentCapability: z30.string(),
-  date: z30.number().optional()
+var InvokerPermissionZod = PermissionZod.safeExtend({ date: z29.number().optional() });
+var PermissionRequestZod = z29.record(z29.string(), z29.record(z29.string(), z29.any()));
+var RequestedPermissionZod = z29.object({
+  parentCapability: z29.string(),
+  date: z29.number().optional()
 });
 
 // src/model/rewards.ts
@@ -1384,44 +1375,44 @@ var XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20000000000n, XL1_REWARD
 
 // src/model/RewardsRangeOptions.ts
 import { AddressZod as AddressZod3 } from "@xylabs/sdk-js";
-import { z as z31 } from "zod";
-var RewardsRangeOptionsZod = z31.object({
-  positions: z31.array(z31.number()).optional(),
+import { z as z30 } from "zod";
+var RewardsRangeOptionsZod = z30.object({
+  positions: z30.array(z30.number()).optional(),
   range: BlockRangeZod.optional(),
-  steps: z31.array(StepIdentityZod).optional(),
-  stakers: z31.array(AddressZod3).optional()
+  steps: z30.array(StepIdentityZod).optional(),
+  stakers: z30.array(AddressZod3).optional()
 });
 
 // src/model/Sequence.ts
 import { HexRegExMinMax, toHex } from "@xylabs/sdk-js";
 import { SequenceConstants } from "@xyo-network/sdk-js";
-import { z as z32 } from "zod";
+import { z as z31 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z32.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringZod = z32.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
+var LocalSequenceToStringZod = z31.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringZod = z31.string().regex(LocalSequenceRegex).transform((v) => toHex(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z32.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringZod = z32.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
-var SequenceToStringZod = z32.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z32.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+var QualifiedSequenceToStringZod = z31.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringZod = z31.string().regex(QualifiedSequenceRegex).transform((v) => toHex(v));
+var SequenceToStringZod = z31.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z31.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
 
 // src/model/Stake.ts
 import { AddressZod as AddressZod4, HexZod as HexZod6 } from "@xylabs/sdk-js";
-import { z as z33 } from "zod";
-var StakeZod = z33.object({
+import { z as z32 } from "zod";
+var StakeZod = z32.object({
   amount: AttoZod,
   // the block number when the stake was added
-  addBlock: z33.number(),
+  addBlock: z32.number(),
   // the unique id for the stake item
-  id: z33.number(),
+  id: z32.number(),
   // the block number when the stake was removed (set to 0 if not removed)
-  removeBlock: z33.number(),
+  removeBlock: z32.number(),
   // the address that is being staked
   staked: AddressZod4,
   // the address that owns the stake
   staker: AddressZod4,
   // the block number when the stake was withdrawn (set to 0 if not withdrawn)
-  withdrawBlock: z33.number()
+  withdrawBlock: z32.number()
 });
 var StakeToJsonZod = StakeZod.transform((val) => ({
   addBlock: val.addBlock,
@@ -1443,17 +1434,17 @@ var JsonToStakeZod = StakeZod.extend({ amount: HexZod6 }).transform((val) => ({
 }));
 
 // src/model/TimeDomain.ts
-import { z as z34 } from "zod";
-var TimeDomainZod = z34.union([
-  z34.literal("xl1"),
-  z34.literal("epoch"),
-  z34.literal("ethereum")
+import { z as z33 } from "zod";
+var TimeDomainZod = z33.union([
+  z33.literal("xl1"),
+  z33.literal("epoch"),
+  z33.literal("ethereum")
 ]);
 
 // src/model/TransferPair.ts
 import { AddressZod as AddressZod5 } from "@xylabs/sdk-js";
-import { z as z35 } from "zod";
-var TransferPairZod = z35.tuple([
+import { z as z34 } from "zod";
+var TransferPairZod = z34.tuple([
   AddressZod5,
   AddressZod5
 ]);
@@ -1591,18 +1582,18 @@ var BlockViewerMoniker = "BlockViewer";
 
 // src/viewers/BlockInvalidation.ts
 import { zodIsFactory as zodIsFactory15 } from "@xylabs/sdk-js";
-import { z as z36 } from "zod";
+import { z as z35 } from "zod";
 var BlockInvalidationQualificationZod = ChainQualificationZod;
 var isBlockInvalidationQualification = zodIsFactory15(BlockInvalidationQualificationZod);
-var BlockInvalidationConfigFieldsZod = z36.object({
-  state: z36.boolean().optional(),
-  value: z36.boolean().optional()
+var BlockInvalidationConfigFieldsZod = z35.object({
+  state: z35.boolean().optional(),
+  value: z35.boolean().optional()
 });
-var BlockInvalidationConfigZod = z36.union([
+var BlockInvalidationConfigZod = z35.union([
   BlockInvalidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
   BlockInvalidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
   BlockInvalidationConfigFieldsZod,
-  z36.object({})
+  z35.object({})
 ]);
 var isBlockInvalidationConfig = zodIsFactory15(BlockInvalidationConfigZod);
 var BlockInvalidationViewerMoniker = "BlockInvalidationViewer";
@@ -1612,18 +1603,18 @@ var BlockRewardViewerMoniker = "BlockRewardViewer";
 
 // src/viewers/BlockValidation.ts
 import { zodIsFactory as zodIsFactory16 } from "@xylabs/sdk-js";
-import { z as z37 } from "zod";
+import { z as z36 } from "zod";
 var BlockValidationQualificationZod = ChainQualificationZod;
 var isBlockValidationQualification = zodIsFactory16(BlockValidationQualificationZod);
-var BlockValidationConfigFieldsZod = z37.object({
-  value: z37.boolean().optional(),
-  state: z37.boolean().optional()
+var BlockValidationConfigFieldsZod = z36.object({
+  value: z36.boolean().optional(),
+  state: z36.boolean().optional()
 });
-var BlockValidationConfigZod = z37.union([
+var BlockValidationConfigZod = z36.union([
   BlockValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
   BlockValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
   BlockValidationConfigFieldsZod,
-  z37.object({})
+  z36.object({})
 ]);
 var isBlockValidationConfig = zodIsFactory16(BlockValidationConfigZod);
 var BlockValidationViewerMoniker = "BlockValidationViewer";
@@ -1639,15 +1630,15 @@ var FinalizationViewerMoniker = "FinalizationViewer";
 
 // src/viewers/Mempool.ts
 import { HashZod as HashZod4 } from "@xylabs/sdk-js";
-import { z as z38 } from "zod";
-var PendingTransactionsOptionsZod = z38.object({
+import { z as z37 } from "zod";
+var PendingTransactionsOptionsZod = z37.object({
   cursor: HashZod4.optional(),
-  limit: z38.number().int().positive().optional(),
+  limit: z37.number().int().positive().optional(),
   window: XL1BlockRangeZod.optional()
 });
-var PendingBlocksOptionsZod = z38.object({
+var PendingBlocksOptionsZod = z37.object({
   cursor: HashZod4.optional(),
-  limit: z38.number().int().positive().optional(),
+  limit: z37.number().int().positive().optional(),
   window: XL1BlockRangeZod.optional()
 });
 var MempoolViewerMoniker = "MempoolViewer";
@@ -1698,36 +1689,36 @@ var TransactionViewerMoniker = "TransactionViewer";
 
 // src/viewers/TransactionInvalidation.ts
 import { zodIsFactory as zodIsFactory17 } from "@xylabs/sdk-js";
-import { z as z39 } from "zod";
+import { z as z38 } from "zod";
 var TransactionInvalidationQualificationZod = ChainQualificationZod;
 var isTransactionInvalidationQualification = zodIsFactory17(TransactionInvalidationQualificationZod);
-var TransactionInvalidationConfigFieldsZod = z39.object({
-  state: z39.boolean().optional(),
-  value: z39.boolean().optional()
+var TransactionInvalidationConfigFieldsZod = z38.object({
+  state: z38.boolean().optional(),
+  value: z38.boolean().optional()
 });
-var TransactionInvalidationConfigZod = z39.union([
+var TransactionInvalidationConfigZod = z38.union([
   TransactionInvalidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
   TransactionInvalidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
   TransactionInvalidationConfigFieldsZod,
-  z39.object({})
+  z38.object({})
 ]);
 var isTransactionInvalidationConfig = zodIsFactory17(TransactionInvalidationConfigZod);
 var TransactionInvalidationViewerMoniker = "TransactionInvalidationViewer";
 
 // src/viewers/TransactionValidation.ts
 import { zodIsFactory as zodIsFactory18 } from "@xylabs/sdk-js";
-import { z as z40 } from "zod";
+import { z as z39 } from "zod";
 var TransactionValidationQualificationZod = ChainQualificationZod;
 var isTransactionValidationQualification = zodIsFactory18(TransactionValidationQualificationZod);
-var TransactionValidationConfigFieldsZod = z40.object({
-  value: z40.boolean().optional(),
-  state: z40.boolean().optional()
+var TransactionValidationConfigFieldsZod = z39.object({
+  value: z39.boolean().optional(),
+  state: z39.boolean().optional()
 });
-var TransactionValidationConfigZod = z40.union([
+var TransactionValidationConfigZod = z39.union([
   TransactionValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
   TransactionValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
   TransactionValidationConfigFieldsZod,
-  z40.object({})
+  z39.object({})
 ]);
 var isTransactionValidationConfig = zodIsFactory18(TransactionValidationConfigZod);
 var TransactionValidationViewerMoniker = "TransactionValidationViewer";