@xyo-network/xl1-protocol 1.13.0 → 1.13.2

package/dist/neutral/model/BlockRange/EthBlockRange.d.ts

@@ -0,0 +1,23 @@
+import type { AssertConfig } from '@xylabs/hex';
+import { type Brand } from '@xylabs/typeof';
+import z from 'zod';
+import { type BlockNumber } from '../BlockNumber/index.ts';
+export type EthBlockRange = [BlockNumber, BlockNumber];
+export type NumberishEthBlockRange = [BlockNumber, BlockNumber];
+export declare const EthBlockRangeZod: z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<BlockNumber, number>>], null>;
+export declare const NumberishEthBlockRangeZod: z.ZodTuple<[z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodTransform<BlockNumber, number>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodTransform<BlockNumber, number>>], null>;
+export declare const asEthBlockRange: {
+    (value: unknown): EthBlockRange | undefined;
+    (value: unknown, assert: AssertConfig): EthBlockRange;
+};
+export declare const toEthBlockRange: {
+    (value: unknown): EthBlockRange | undefined;
+    (value: unknown, assert: AssertConfig): EthBlockRange;
+};
+export type EthBlockRangeKey = Brand<string, {
+    readonly __xl1BlockRangeKey: true;
+}>;
+export declare const toEthBlockNumberKey: (range: EthBlockRange) => EthBlockRangeKey;
+export declare function fromEthBlockNumberKey(key: EthBlockRangeKey): EthBlockRange | undefined;
+export declare function fromEthBlockNumberKey(key: EthBlockRangeKey, assert: AssertConfig): EthBlockRange;
+//# sourceMappingURL=EthBlockRange.d.ts.map

package/dist/neutral/model/BlockRange/EthBlockRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthBlockRange.d.ts","sourceRoot":"","sources":["../../../../src/model/BlockRange/EthBlockRange.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,EAAE,KAAK,KAAK,EAAa,MAAM,gBAAgB,CAAA;AACtD,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAA;AAGhC,MAAM,MAAM,aAAa,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;AACtD,MAAM,MAAM,sBAAsB,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;AAE/D,eAAO,MAAM,gBAAgB,8IAA4C,CAAA;AACzE,eAAO,MAAM,yBAAyB,0ZAA8D,CAAA;AAEpG,eAAO,MAAM,eAAe;;;CAAgD,CAAA;AAC5E,eAAO,MAAM,eAAe;;;CAAyD,CAAA;AAErF,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,kBAAkB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AACnF,eAAO,MAAM,mBAAmB,GAAI,OAAO,aAAa,KAAkC,gBAAgB,CAAA;AAE1G,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,aAAa,GAAG,SAAS,CAAA;AACvF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,EAAE,YAAY,GAAG,aAAa,CAAA"}

package/dist/neutral/model/BlockRange/Numberish.d.ts

@@ -0,0 +1,3 @@
+import z from 'zod';
+export declare const NumberishRangeZod: z.ZodTuple<[z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>], null>;
+//# sourceMappingURL=Numberish.d.ts.map

package/dist/neutral/model/BlockRange/Numberish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Numberish.d.ts","sourceRoot":"","sources":["../../../../src/model/BlockRange/Numberish.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB,0TAAwC,CAAA"}

package/dist/neutral/model/BlockRange/Range.d.ts

@@ -0,0 +1,13 @@
+import z from 'zod';
+export declare const RangeZod: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+export type Range = z.infer<typeof RangeZod>;
+export declare const isRange: (value: unknown) => value is [number, number];
+export declare const asRange: {
+    (value: unknown): [number, number] | undefined;
+    (value: unknown, assert: import("@xylabs/hex").AssertConfig): [number, number];
+};
+export declare const toRange: {
+    (value: unknown): [number, number] | undefined;
+    (value: unknown, assert: import("@xylabs/hex").AssertConfig): [number, number];
+};
+//# sourceMappingURL=Range.d.ts.map

package/dist/neutral/model/BlockRange/Range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Range.d.ts","sourceRoot":"","sources":["../../../../src/model/BlockRange/Range.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,QAAQ,8CAAoC,CAAA;AAEzD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE5C,eAAO,MAAM,OAAO,+CAAgC,CAAA;AACpD,eAAO,MAAM,OAAO;;;CAAgC,CAAA;AACpD,eAAO,MAAM,OAAO;;;CAAgC,CAAA"}

package/dist/neutral/model/BlockRange/XL1BlockRange.d.ts

@@ -0,0 +1,23 @@
+import type { AssertConfig } from '@xylabs/hex';
+import { type Brand } from '@xylabs/typeof';
+import z from 'zod';
+import { type BlockNumber } from '../BlockNumber/index.ts';
+export type XL1BlockRange = [BlockNumber, BlockNumber];
+export type NumberishXL1BlockRange = [BlockNumber, BlockNumber];
+export declare const XL1BlockRangeZod: z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<BlockNumber, number>>], null>;
+export declare const NumberishXL1BlockRangeZod: z.ZodTuple<[z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodTransform<BlockNumber, number>>, z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>, z.ZodTransform<BlockNumber, number>>], null>;
+export declare const asXL1BlockRange: {
+    (value: unknown): XL1BlockRange | undefined;
+    (value: unknown, assert: AssertConfig): XL1BlockRange;
+};
+export declare const toXL1BlockRange: {
+    (value: unknown): XL1BlockRange | undefined;
+    (value: unknown, assert: AssertConfig): XL1BlockRange;
+};
+export type XL1BlockRangeKey = Brand<string, {
+    readonly __xl1BlockRangeKey: true;
+}>;
+export declare const toXL1BlockNumberKey: (range: XL1BlockRange) => XL1BlockRangeKey;
+export declare function fromXL1BlockNumberKey(key: XL1BlockRangeKey): XL1BlockRange | undefined;
+export declare function fromXL1BlockNumberKey(key: XL1BlockRangeKey, assert: AssertConfig): XL1BlockRange;
+//# sourceMappingURL=XL1BlockRange.d.ts.map

package/dist/neutral/model/BlockRange/XL1BlockRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XL1BlockRange.d.ts","sourceRoot":"","sources":["../../../../src/model/BlockRange/XL1BlockRange.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,EAAE,KAAK,KAAK,EAAa,MAAM,gBAAgB,CAAA;AACtD,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAA;AAGhC,MAAM,MAAM,aAAa,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;AACtD,MAAM,MAAM,sBAAsB,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;AAE/D,eAAO,MAAM,gBAAgB,8IAA4C,CAAA;AACzE,eAAO,MAAM,yBAAyB,0ZAA8D,CAAA;AAEpG,eAAO,MAAM,eAAe;;;CAAgD,CAAA;AAC5E,eAAO,MAAM,eAAe;;;CAAyD,CAAA;AAErF,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,kBAAkB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AACnF,eAAO,MAAM,mBAAmB,GAAI,OAAO,aAAa,KAAkC,gBAAgB,CAAA;AAE1G,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,aAAa,GAAG,SAAS,CAAA;AACvF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,EAAE,YAAY,GAAG,aAAa,CAAA"}

package/dist/neutral/model/BlockRange/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BlockRange.ts';
+export * from './EthBlockRange.ts';
+export * from './Range.ts';
+export * from './XL1BlockRange.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/model/BlockRange/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/BlockRange/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA"}

package/dist/neutral/model/RangeMultipliers.d.ts

@@ -1,4 +1,4 @@
-import type { BlockRangeKey, EthBlockRangeKey, XL1BlockRangeKey } from './BlockNumber/index.ts';
+import type { BlockRangeKey, EthBlockRangeKey, XL1BlockRangeKey } from './BlockRange/index.ts';
 export type BigFraction = [bigint, bigint];
 export type RangeMultipliers = Record<BlockRangeKey, BigFraction>;
 export type EthRangeMultipliers = Record<EthBlockRangeKey, BigFraction>;

package/dist/neutral/model/RangeMultipliers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RangeMultipliers.d.ts","sourceRoot":"","sources":["../../../src/model/RangeMultipliers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAClD,MAAM,wBAAwB,CAAA;AAE/B,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE1C,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAA;AACvE,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAA"}
+{"version":3,"file":"RangeMultipliers.d.ts","sourceRoot":"","sources":["../../../src/model/RangeMultipliers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAClD,MAAM,uBAAuB,CAAA;AAE9B,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE1C,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAA;AACvE,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAA"}

package/dist/neutral/model/index.d.ts

@@ -7,4 +7,5 @@ export * from './RangeMultipliers.ts';
 export * from './RewardShare.ts';
 export * from './StepHash.ts';
 export * from './StepIdentity.ts';
+export * from './zod/index.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/model/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA"}

package/dist/neutral/model/zod/index.d.ts

@@ -0,0 +1,4 @@
+export * from './zodAsFactory.ts';
+export * from './zodIsFactory.ts';
+export * from './zodToFactory.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/model/zod/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/model/zod/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA"}

package/dist/neutral/model/zod/zodAsFactory.d.ts

@@ -0,0 +1,7 @@
+import type { AssertConfig } from '@xylabs/hex';
+import type z from 'zod';
+export declare function zodAsFactory<T>(zod: z.ZodType<T>): {
+    (value: unknown): T | undefined;
+    (value: unknown, assert: AssertConfig): T;
+};
+//# sourceMappingURL=zodAsFactory.d.ts.map

package/dist/neutral/model/zod/zodAsFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../../../src/model/zod/zodAsFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;YACxB,OAAO,GAAG,CAAC,GAAG,SAAS;YACvB,OAAO,UAAU,YAAY,GAAG,CAAC;EAUzD"}

package/dist/neutral/model/zod/zodIsFactory.d.ts

@@ -0,0 +1,3 @@
+import type z from 'zod';
+export declare function zodIsFactory<T>(zod: z.ZodType<T>): (value: unknown) => value is T;
+//# sourceMappingURL=zodIsFactory.d.ts.map

package/dist/neutral/model/zod/zodIsFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodIsFactory.d.ts","sourceRoot":"","sources":["../../../../src/model/zod/zodIsFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IACvC,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,CACpC"}

package/dist/neutral/model/zod/zodToFactory.d.ts

@@ -0,0 +1,6 @@
+import type z from 'zod';
+export declare function zodToFactory<T>(zod: z.ZodType<T>): {
+    (value: unknown): T | undefined;
+    (value: unknown, assert: import("@xylabs/hex").AssertConfig): T;
+};
+//# sourceMappingURL=zodToFactory.d.ts.map

package/dist/neutral/model/zod/zodToFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodToFactory.d.ts","sourceRoot":"","sources":["../../../../src/model/zod/zodToFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;;;EAEhD"}

package/dist/neutral/transaction/HydratedTransactionWithHashMeta.d.ts

@@ -0,0 +1,7 @@
+import { type Signed } from '@xyo-network/boundwitness-model';
+import { type Payload, type WithHashMeta } from '@xyo-network/payload-model';
+import { type TransactionBoundWitness } from './TransactionBoundWitness.ts';
+export type HydratedTransactionWithHashMeta<T extends TransactionBoundWitness = TransactionBoundWitness, P extends Payload = Payload> = [WithHashMeta<Signed<T>>, WithHashMeta<P>[]];
+export declare const isHydratedTransactionWithHashMeta: (value: unknown) => value is HydratedTransactionWithHashMeta;
+export declare const asHydratedTransactionWithHashMeta: import("@xylabs/object").AsTypeFunction<HydratedTransactionWithHashMeta<TransactionBoundWitness, Payload>>;
+//# sourceMappingURL=HydratedTransactionWithHashMeta.d.ts.map

package/dist/neutral/transaction/HydratedTransactionWithHashMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydratedTransactionWithHashMeta.d.ts","sourceRoot":"","sources":["../../../src/transaction/HydratedTransactionWithHashMeta.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,EACU,KAAK,OAAO,EAAE,KAAK,YAAY,EAC/C,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAE3E,MAAM,MAAM,+BAA+B,CAAC,CAAC,SAAS,uBAAuB,GAAG,uBAAuB,EACrG,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAE7E,eAAO,MAAM,iCAAiC,GAC5C,OAAO,OAAO,KACb,KAAK,IAAI,+BAIX,CAAA;AAED,eAAO,MAAM,iCAAiC,4GAE7C,CAAA"}

package/dist/neutral/transaction/SignedHydratedTransactionWithHashMeta.d.ts

@@ -0,0 +1,7 @@
+import { type Signed } from '@xyo-network/boundwitness-model';
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model';
+import { type TransactionBoundWitness } from './TransactionBoundWitness.ts';
+export type SignedHydratedTransactionWithHashMeta<T extends TransactionBoundWitness = TransactionBoundWitness, P extends Payload = Payload> = [WithHashMeta<Signed<T>>, WithHashMeta<P>[]];
+export declare const isSignedHydratedTransactionWithHashMeta: (value: unknown) => value is SignedHydratedTransactionWithHashMeta;
+export declare const asSignedHydratedTransactionWithHashMeta: import("@xylabs/object").AsTypeFunction<SignedHydratedTransactionWithHashMeta<TransactionBoundWitness, Payload>>;
+//# sourceMappingURL=SignedHydratedTransactionWithHashMeta.d.ts.map

package/dist/neutral/transaction/SignedHydratedTransactionWithHashMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignedHydratedTransactionWithHashMeta.d.ts","sourceRoot":"","sources":["../../../src/transaction/SignedHydratedTransactionWithHashMeta.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,KAAK,EACV,OAAO,EACP,YAAY,EACb,MAAM,4BAA4B,CAAA;AAInC,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAE3E,MAAM,MAAM,qCAAqC,CAAC,CAAC,SAAS,uBAAuB,GAAG,uBAAuB,EAC3G,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAE7E,eAAO,MAAM,uCAAuC,GAClD,OAAO,OAAO,KACb,KAAK,IAAI,qCAIX,CAAA;AAED,eAAO,MAAM,uCAAuC,kHAEnD,CAAA"}

package/dist/neutral/transaction/SignedHydratedTransactionWithStorageMeta.d.ts

@@ -1,5 +1,5 @@
 import { type Signed } from '@xyo-network/boundwitness-model';
-import { type Payload, type WithStorageMeta } from '@xyo-network/payload-model';
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model';
 import { type TransactionBoundWitness } from './TransactionBoundWitness.ts';
 export type SignedHydratedTransactionWithStorageMeta<T extends TransactionBoundWitness = TransactionBoundWitness, P extends Payload = Payload> = [WithStorageMeta<Signed<T>>, WithStorageMeta<P>[]];
 export declare const isSignedHydratedTransactionWithStorageMeta: (value: unknown) => value is SignedHydratedTransactionWithStorageMeta;

package/dist/neutral/transaction/SignedHydratedTransactionWithStorageMeta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SignedHydratedTransactionWithStorageMeta.d.ts","sourceRoot":"","sources":["../../../src/transaction/SignedHydratedTransactionWithStorageMeta.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,EACU,KAAK,OAAO,EAAE,KAAK,eAAe,EAClD,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAE3E,MAAM,MAAM,wCAAwC,CAAC,CAAC,SAAS,uBAAuB,GAAG,uBAAuB,EAC9G,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAEnF,eAAO,MAAM,0CAA0C,GACrD,OAAO,OAAO,KACb,KAAK,IAAI,wCAIX,CAAA;AAED,eAAO,MAAM,0CAA0C,qHAEtD,CAAA"}
+{"version":3,"file":"SignedHydratedTransactionWithStorageMeta.d.ts","sourceRoot":"","sources":["../../../src/transaction/SignedHydratedTransactionWithStorageMeta.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,KAAK,EACV,OAAO,EACP,eAAe,EAChB,MAAM,4BAA4B,CAAA;AAInC,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAE3E,MAAM,MAAM,wCAAwC,CAAC,CAAC,SAAS,uBAAuB,GAAG,uBAAuB,EAC9G,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAEnF,eAAO,MAAM,0CAA0C,GACrD,OAAO,OAAO,KACb,KAAK,IAAI,wCAIX,CAAA;AAED,eAAO,MAAM,0CAA0C,qHAEtD,CAAA"}

package/dist/neutral/transaction/index.d.ts

@@ -1,7 +1,9 @@
 export * from './AnyHydratedTransaction.ts';
 export * from './HydratedTransaction.ts';
+export * from './HydratedTransactionWithHashMeta.ts';
 export * from './HydratedTransactionWithStorageMeta.ts';
 export * from './SignedHydratedTransaction.ts';
+export * from './SignedHydratedTransactionWithHashMeta.ts';
 export * from './SignedHydratedTransactionWithStorageMeta.ts';
 export * from './TransactionBoundWitness.ts';
 export * from './TransactionBoundWitnessDeprecated.ts';

package/dist/neutral/transaction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transaction/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,0BAA0B,CAAA;AACxC,cAAc,yCAAyC,CAAA;AACvD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+CAA+C,CAAA;AAC7D,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wCAAwC,CAAA;AACtD,cAAc,4BAA4B,CAAA;AAC1C,cAAc,kCAAkC,CAAA;AAChD,cAAc,8CAA8C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transaction/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,0BAA0B,CAAA;AACxC,cAAc,sCAAsC,CAAA;AACpD,cAAc,yCAAyC,CAAA;AACvD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,4CAA4C,CAAA;AAC1D,cAAc,+CAA+C,CAAA;AAC7D,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wCAAwC,CAAA;AACtD,cAAc,4BAA4B,CAAA;AAC1C,cAAc,kCAAkC,CAAA;AAChD,cAAc,8CAA8C,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "XYO Layer One Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {

package/src/constants/StepSizes.ts

@@ -6,15 +6,15 @@ import { asXL1BlockNumber, type XL1BlockNumber } from '../model/index.ts'
 // primorial(n+2) = 2 → 2×3=6 → 6×5=30 → 30×7=210 → 210×11=2310
 
 export const StepSizes: XL1BlockNumber[] = [
-  asXL1BlockNumber(7),
-  asXL1BlockNumber(31),
-  asXL1BlockNumber(211),
-  asXL1BlockNumber(2311),
-  asXL1BlockNumber(30_031),
-  asXL1BlockNumber(510_511),
-  asXL1BlockNumber(9_699_691),
-  asXL1BlockNumber(223_092_871),
-  asXL1BlockNumber(6_469_693_231),
+  asXL1BlockNumber(7, true),
+  asXL1BlockNumber(31, true),
+  asXL1BlockNumber(211, true),
+  asXL1BlockNumber(2311, true),
+  asXL1BlockNumber(30_031, true),
+  asXL1BlockNumber(510_511, true),
+  asXL1BlockNumber(9_699_691, true),
+  asXL1BlockNumber(223_092_871, true),
+  asXL1BlockNumber(6_469_693_231, true),
 ]
 
 export function isValidStep(step: unknown): step is number {

package/src/model/BlockNumber/BlockNumber.ts

@@ -1,29 +1,15 @@
-import { assertEx } from '@xylabs/assert'
-import {
-  type Brand, isArray, isNumber,
-} from '@xylabs/typeof'
+import { type Brand } from '@xylabs/typeof'
+import z from 'zod'
 
-export type BlockNumber = Brand<number, { readonly __blockNumber: true }>
+import { zodAsFactory, zodToFactory } from '../zod/index.ts'
+import { NumberishZod } from './Numberish.ts'
 
-export type BlockRange = [BlockNumber, BlockNumber]
+export type BlockNumber = Brand<number, { readonly __blockNumber: true }>
 
-export function asBlockNumber(value: unknown) {
-  assertEx(isNumber(value), () => 'Not a valid BlockNumber')
-  return value as BlockNumber
-}
+export const BlockNumberZod = z.number().transform(v => v as BlockNumber)
+export const NumberishBlockNumberZod = NumberishZod.transform(v => v as BlockNumber)
 
-export function asBlockRange(value: unknown) {
-  if (isArray(value) && value.length === 2 && isNumber(value[0]) && isNumber(value[1])) {
-    return value as BlockRange
-  }
-  throw new Error('Not a valid BlockNumberRange')
-}
+export const asBlockNumber = zodAsFactory<BlockNumber>(BlockNumberZod)
+export const toBlockNumber = zodToFactory<BlockNumber>(NumberishBlockNumberZod)
 
 export const BLOCK_NUMBER_ZERO = asBlockNumber(0)
-
-export type BlockRangeKey = Brand<string, { readonly __blockRangeKey: true }>
-export const toBlockNumberKey = (range: BlockRange) => `${range[0]}|${range[1]}` as BlockRangeKey
-export const fromBlockNumberKey = (key: BlockRangeKey): BlockRange => {
-  const [start, end] = key.split('|').map(v => asBlockNumber(Number(v)))
-  return [start, end]
-}

package/src/model/BlockNumber/EthBlockNumber.ts

@@ -1,25 +1,16 @@
 import { type Brand } from '@xylabs/typeof'
+import z from 'zod'
 
+import { zodAsFactory, zodToFactory } from '../zod/index.ts'
 import type { BlockNumber } from './BlockNumber.ts'
-import { asBlockNumber, asBlockRange } from './BlockNumber.ts'
+import { NumberishBlockNumberZod } from './BlockNumber.ts'
 
-export type EthBlockNumber = Brand<BlockNumber, { __ethBlockNumber: true }>
+export type EthBlockNumber = Brand<BlockNumber, { readonly __ethBlockNumber: true }>
 
-export type EthBlockRange = [EthBlockNumber, EthBlockNumber]
+export const EthBlockNumberZod = z.number().transform(v => v as EthBlockNumber)
+export const NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform(v => v as EthBlockNumber)
 
-export function asEthBlockNumber(value: unknown) {
-  return asBlockNumber(value) as EthBlockNumber
-}
-
-export function asEthBlockRange(value: unknown) {
-  return asBlockRange(value) as EthBlockRange
-}
+export const asEthBlockNumber = zodAsFactory<EthBlockNumber>(EthBlockNumberZod)
+export const toEthBlockNumber = zodToFactory<EthBlockNumber>(NumberishEthBlockNumberZod)
 
 export const ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0)
-
-export type EthBlockRangeKey = Brand<string, { readonly __blockRangeKey: true }>
-export const toEthBlockRangeKey = (range: EthBlockRange) => `${range[0]}|${range[1]}` as EthBlockRangeKey
-export const fromEthBlockNumberKey = (key: EthBlockRangeKey): EthBlockRange => {
-  const [start, end] = key.split('|').map(v => asEthBlockNumber(Number(v)))
-  return [start, end]
-}

package/src/model/BlockNumber/Numberish.ts

@@ -0,0 +1,5 @@
+import z from 'zod'
+
+export const NumberishZod = z.union([z.number(), z.string(), z.bigint()])
+  .transform(v => (typeof v === 'bigint' ? Number(v) : typeof v === 'string' ? Number(v) : v))
+  .pipe(z.number())

package/src/model/BlockNumber/XL1BlockNumber.ts

@@ -1,25 +1,16 @@
 import { type Brand } from '@xylabs/typeof'
+import z from 'zod'
 
+import { zodAsFactory, zodToFactory } from '../zod/index.ts'
 import type { BlockNumber } from './BlockNumber.ts'
-import { asBlockNumber, asBlockRange } from './BlockNumber.ts'
+import { NumberishBlockNumberZod } from './BlockNumber.ts'
 
 export type XL1BlockNumber = Brand<BlockNumber, { readonly __xl1BlockNumber: true }>
 
-export type XL1BlockRange = [XL1BlockNumber, XL1BlockNumber]
+export const XL1BlockNumberZod = z.number().transform(v => v as XL1BlockNumber)
+export const NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform(v => v as XL1BlockNumber)
 
-export function asXL1BlockNumber(value: unknown) {
-  return asBlockNumber(value) as XL1BlockNumber
-}
-
-export function asXL1BlockRange(value: unknown) {
-  return asBlockRange(value) as XL1BlockRange
-}
+export const asXL1BlockNumber = zodAsFactory<XL1BlockNumber>(XL1BlockNumberZod)
+export const toXL1BlockNumber = zodToFactory<XL1BlockNumber>(NumberishXL1BlockNumberZod)
 
 export const XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0)
-
-export type XL1BlockRangeKey = Brand<string, { readonly __blockRangeKey: true }>
-export const toXL1BlockRangeKey = (range: XL1BlockRange) => `${range[0]}|${range[1]}` as XL1BlockRangeKey
-export const fromXL1BlockNumberKey = (key: XL1BlockRangeKey): XL1BlockRange => {
-  const [start, end] = key.split('|').map(v => asXL1BlockNumber(Number(v)))
-  return [start, end]
-}

package/src/model/BlockNumber/index.ts

@@ -1,3 +1,4 @@
 export * from './BlockNumber.ts'
 export * from './EthBlockNumber.ts'
+export * from './Numberish.ts'
 export * from './XL1BlockNumber.ts'

package/src/model/BlockRange/BlockRange.ts

@@ -0,0 +1,30 @@
+import type { AssertConfig } from '@xylabs/hex'
+import { assertError } from '@xylabs/hex'
+import { type Brand, isDefined } from '@xylabs/typeof'
+import z from 'zod'
+
+import {
+  asBlockNumber,
+  type BlockNumber, BlockNumberZod, NumberishBlockNumberZod,
+} from '../BlockNumber/index.ts'
+import { zodAsFactory, zodToFactory } from '../zod/index.ts'
+
+export type BlockRange = [BlockNumber, BlockNumber]
+export type NumberishBlockRange = [BlockNumber, BlockNumber]
+
+export const BlockRangeZod = z.tuple([BlockNumberZod, BlockNumberZod])
+export const NumberishBlockRangeZod = z.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod])
+
+export const asBlockRange = zodAsFactory<BlockRange>(BlockRangeZod)
+export const toBlockRange = zodToFactory<BlockRange>(NumberishBlockRangeZod)
+
+export type BlockRangeKey = Brand<string, { readonly __blockRangeKey: true }>
+export const toBlockNumberKey = (range: BlockRange) => `${range[0]}|${range[1]}` as BlockRangeKey
+
+export function fromBlockNumberKey(key: BlockRangeKey): BlockRange | undefined
+export function fromBlockNumberKey(key: BlockRangeKey, assert: AssertConfig): BlockRange
+export function fromBlockNumberKey(key: BlockRangeKey, assert?: AssertConfig): BlockRange | undefined {
+  const [start, end] = key.split('|').map(v => asBlockNumber(Number(v)))
+  const result = (isDefined(start) && isDefined(end)) ? [start, end] : undefined
+  return assertError(result, assert, `Invalid BlockRangeKey: ${key}`)
+}

package/src/model/BlockRange/EthBlockRange.ts

@@ -0,0 +1,30 @@
+import type { AssertConfig } from '@xylabs/hex'
+import { assertError } from '@xylabs/hex'
+import { type Brand, isDefined } from '@xylabs/typeof'
+import z from 'zod'
+
+import {
+  asEthBlockNumber,
+  type BlockNumber, BlockNumberZod, NumberishBlockNumberZod,
+} from '../BlockNumber/index.ts'
+import { zodAsFactory, zodToFactory } from '../zod/index.ts'
+
+export type EthBlockRange = [BlockNumber, BlockNumber]
+export type NumberishEthBlockRange = [BlockNumber, BlockNumber]
+
+export const EthBlockRangeZod = z.tuple([BlockNumberZod, BlockNumberZod])
+export const NumberishEthBlockRangeZod = z.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod])
+
+export const asEthBlockRange = zodAsFactory<EthBlockRange>(EthBlockRangeZod)
+export const toEthBlockRange = zodToFactory<EthBlockRange>(NumberishEthBlockRangeZod)
+
+export type EthBlockRangeKey = Brand<string, { readonly __xl1BlockRangeKey: true }>
+export const toEthBlockNumberKey = (range: EthBlockRange) => `${range[0]}|${range[1]}` as EthBlockRangeKey
+
+export function fromEthBlockNumberKey(key: EthBlockRangeKey): EthBlockRange | undefined
+export function fromEthBlockNumberKey(key: EthBlockRangeKey, assert: AssertConfig): EthBlockRange
+export function fromEthBlockNumberKey(key: EthBlockRangeKey, assert?: AssertConfig): EthBlockRange | undefined {
+  const [start, end] = key.split('|').map(v => asEthBlockNumber(Number(v)))
+  const result = (isDefined(start) && isDefined(end)) ? [start, end] : undefined
+  return assertError(result, assert, `Invalid EthBlockRangeKey: ${key}`)
+}

package/src/model/BlockRange/Numberish.ts

@@ -0,0 +1,5 @@
+import z from 'zod'
+
+import { NumberishZod } from '../BlockNumber/index.ts'
+
+export const NumberishRangeZod = z.tuple([NumberishZod, NumberishZod])

package/src/model/BlockRange/Range.ts

@@ -0,0 +1,13 @@
+import z from 'zod'
+
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '../zod/index.ts'
+
+export const RangeZod = z.tuple([z.number(), z.number()])
+
+export type Range = z.infer<typeof RangeZod>
+
+export const isRange = zodIsFactory<Range>(RangeZod)
+export const asRange = zodAsFactory<Range>(RangeZod)
+export const toRange = zodToFactory<Range>(RangeZod)

package/src/model/BlockRange/XL1BlockRange.ts

@@ -0,0 +1,30 @@
+import type { AssertConfig } from '@xylabs/hex'
+import { assertError } from '@xylabs/hex'
+import { type Brand, isDefined } from '@xylabs/typeof'
+import z from 'zod'
+
+import {
+  asXL1BlockNumber,
+  type BlockNumber, BlockNumberZod, NumberishBlockNumberZod,
+} from '../BlockNumber/index.ts'
+import { zodAsFactory, zodToFactory } from '../zod/index.ts'
+
+export type XL1BlockRange = [BlockNumber, BlockNumber]
+export type NumberishXL1BlockRange = [BlockNumber, BlockNumber]
+
+export const XL1BlockRangeZod = z.tuple([BlockNumberZod, BlockNumberZod])
+export const NumberishXL1BlockRangeZod = z.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod])
+
+export const asXL1BlockRange = zodAsFactory<XL1BlockRange>(XL1BlockRangeZod)
+export const toXL1BlockRange = zodToFactory<XL1BlockRange>(NumberishXL1BlockRangeZod)
+
+export type XL1BlockRangeKey = Brand<string, { readonly __xl1BlockRangeKey: true }>
+export const toXL1BlockNumberKey = (range: XL1BlockRange) => `${range[0]}|${range[1]}` as XL1BlockRangeKey
+
+export function fromXL1BlockNumberKey(key: XL1BlockRangeKey): XL1BlockRange | undefined
+export function fromXL1BlockNumberKey(key: XL1BlockRangeKey, assert: AssertConfig): XL1BlockRange
+export function fromXL1BlockNumberKey(key: XL1BlockRangeKey, assert?: AssertConfig): XL1BlockRange | undefined {
+  const [start, end] = key.split('|').map(v => asXL1BlockNumber(Number(v)))
+  const result = (isDefined(start) && isDefined(end)) ? [start, end] : undefined
+  return assertError(result, assert, `Invalid XL1BlockRangeKey: ${key}`)
+}

package/src/model/BlockRange/index.ts

@@ -0,0 +1,4 @@
+export * from './BlockRange.ts'
+export * from './EthBlockRange.ts'
+export * from './Range.ts'
+export * from './XL1BlockRange.ts'

package/src/model/RangeMultipliers.ts

@@ -1,6 +1,6 @@
 import type {
   BlockRangeKey, EthBlockRangeKey, XL1BlockRangeKey,
-} from './BlockNumber/index.ts'
+} from './BlockRange/index.ts'
 
 export type BigFraction = [bigint, bigint] // numerator, denominator
 

package/src/model/StepIdentity.ts

@@ -1,6 +1,6 @@
 import { type Brand, isUndefined } from '@xylabs/typeof'
 
-import { asXL1BlockNumber, type XL1BlockNumber } from './BlockNumber/index.ts'
+import { toXL1BlockNumber, type XL1BlockNumber } from './BlockNumber/index.ts'
 
 export interface StepIdentity {
   block: XL1BlockNumber
@@ -30,11 +30,11 @@ export const asStepIdentity = (stepIdentityString: string): StepIdentity | undef
       return undefined
     }
     const step = tryParseInt(stepString)
-    const blockNumber = tryParseInt(blockNumberString)
-    if (isUndefined(blockNumber) || isUndefined(step)) {
+    const block = toXL1BlockNumber(blockNumberString)
+    if (isUndefined(block) || isUndefined(step)) {
       return undefined
     }
-    const block = asXL1BlockNumber(blockNumber)
+
     return { block, step }
   } catch {
     return undefined

package/src/model/index.ts

@@ -7,3 +7,4 @@ export * from './RangeMultipliers.ts'
 export * from './RewardShare.ts'
 export * from './StepHash.ts'
 export * from './StepIdentity.ts'
+export * from './zod/index.ts'

package/src/model/zod/index.ts

@@ -0,0 +1,3 @@
+export * from './zodAsFactory.ts'
+export * from './zodIsFactory.ts'
+export * from './zodToFactory.ts'

package/src/model/zod/zodAsFactory.ts

@@ -0,0 +1,17 @@
+import type { AssertConfig } from '@xylabs/hex'
+import { assertError } from '@xylabs/hex'
+import type z from 'zod'
+
+export function zodAsFactory<T>(zod: z.ZodType<T>) {
+  function asFunc(value: unknown): T | undefined
+  function asFunc(value: unknown, assert: AssertConfig): T
+  function asFunc(value: unknown, assert?: AssertConfig): T | undefined {
+    const result = zod.safeParse(value)
+    if (result.success) {
+      return result.data
+    }
+    return assertError(value, assert, result.error.message)
+  }
+
+  return asFunc
+}

package/src/model/zod/zodIsFactory.ts

@@ -0,0 +1,5 @@
+import type z from 'zod'
+
+export function zodIsFactory<T>(zod: z.ZodType<T>) {
+  return (value: unknown): value is T => zod.safeParse(value).success
+}

package/src/model/zod/zodToFactory.ts

@@ -0,0 +1,7 @@
+import type z from 'zod'
+
+import { zodAsFactory } from './zodAsFactory.ts'
+
+export function zodToFactory<T>(zod: z.ZodType<T>) {
+  return zodAsFactory<T>(zod)
+}

package/src/transaction/HydratedTransactionWithHashMeta.ts

@@ -0,0 +1,23 @@
+import { AsObjectFactory } from '@xylabs/object'
+import { type Signed } from '@xyo-network/boundwitness-model'
+import {
+  isStorageMeta, type Payload, type WithHashMeta,
+} from '@xyo-network/payload-model'
+
+import { isAnyHydratedTransaction } from './AnyHydratedTransaction.ts'
+import { type TransactionBoundWitness } from './TransactionBoundWitness.ts'
+
+export type HydratedTransactionWithHashMeta<T extends TransactionBoundWitness = TransactionBoundWitness,
+  P extends Payload = Payload> = [WithHashMeta<Signed<T>>, WithHashMeta<P>[]]
+
+export const isHydratedTransactionWithHashMeta = (
+  value: unknown,
+): value is HydratedTransactionWithHashMeta => {
+  return (
+    isAnyHydratedTransaction(value) && isStorageMeta(value[0]) && !value[1].some(v => !isStorageMeta(v))
+  )
+}
+
+export const asHydratedTransactionWithHashMeta = AsObjectFactory.create<HydratedTransactionWithHashMeta>(
+  isHydratedTransactionWithHashMeta,
+)