@xyo-network/xl1-protocol 4.0.11 → 4.0.14

package/dist/neutral/modules/protocol-lib/validation/block/error.d.ts

@@ -0,0 +1,167 @@
+import type { Hash } from '@ariestools/sdk';
+import { z } from 'zod';
+import type { BlockBoundWitness, ChainId, HydratedBlock } from '../../../protocol-model/index.js';
+import { ValidationError } from '../error.js';
+export declare const BlockValidationErrorZod: z.ZodObject<{
+    hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    message: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnknown;
+    name: z.ZodLiteral<"BlockValidationError">;
+}, z.core.$loose>;
+export type BlockValidationErrorType = z.infer<typeof BlockValidationErrorZod>;
+/** Error thrown during Block validation  operations. */
+export declare class BlockValidationError extends ValidationError<BlockBoundWitness> {
+}
+export declare const isBlockValidationError: <T>(value: T) => value is T & {
+    [x: string]: unknown;
+    hash: import("@ariestools/sdk").BrandedHash;
+    value: unknown;
+    name: "BlockValidationError";
+    message?: string | undefined;
+};
+export declare const asBlockValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "BlockValidationError";
+        message?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "BlockValidationError";
+        message?: string | undefined;
+    };
+};
+export declare const toBlockValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "BlockValidationError";
+        message?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "BlockValidationError";
+        message?: string | undefined;
+    };
+};
+export declare const HydratedBlockValidationErrorZod: z.ZodObject<{
+    hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    message: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnknown;
+    name: z.ZodLiteral<"HydratedBlockValidationError">;
+}, z.core.$loose>;
+export type HydratedBlockValidationErrorType = z.infer<typeof HydratedBlockValidationErrorZod>;
+/** Error thrown during HydratedBlock validation  operations. */
+export declare class HydratedBlockValidationError extends ValidationError<HydratedBlock> {
+}
+export declare const isHydratedBlockValidationError: <T>(value: T) => value is T & {
+    [x: string]: unknown;
+    hash: import("@ariestools/sdk").BrandedHash;
+    value: unknown;
+    name: "HydratedBlockValidationError";
+    message?: string | undefined;
+};
+export declare const asHydratedBlockValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "HydratedBlockValidationError";
+        message?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "HydratedBlockValidationError";
+        message?: string | undefined;
+    };
+};
+export declare const toHydratedBlockValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "HydratedBlockValidationError";
+        message?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        name: "HydratedBlockValidationError";
+        message?: string | undefined;
+    };
+};
+export declare const HydratedBlockStateValidationErrorZod: z.ZodObject<{
+    hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    message: z.ZodOptional<z.ZodString>;
+    value: z.ZodUnknown;
+    chainId: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    name: z.ZodLiteral<"HydratedBlockStateValidationError">;
+    offendingTransactionHashes: z.ZodOptional<z.ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+}, z.core.$loose>;
+export type HydratedBlockStateValidationErrorType = z.infer<typeof HydratedBlockStateValidationErrorZod>;
+/** Error thrown during HydratedBlockState validation  operations. */
+export declare class HydratedBlockStateValidationError extends ValidationError<HydratedBlock> {
+    chainId: ChainId;
+    offendingTransactionHashes?: Hash[];
+    constructor(hash: Hash, chainId: ChainId, value: HydratedBlock, message: string, cause?: unknown, offendingTransactionHashes?: Hash[]);
+}
+export declare const isHydratedBlockStateValidationError: <T>(value: T) => value is T & {
+    [x: string]: unknown;
+    hash: import("@ariestools/sdk").BrandedHash;
+    value: unknown;
+    chainId: import("@ariestools/sdk").BrandedHex;
+    name: "HydratedBlockStateValidationError";
+    message?: string | undefined;
+    offendingTransactionHashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+};
+export declare const asHydratedBlockStateValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        name: "HydratedBlockStateValidationError";
+        message?: string | undefined;
+        offendingTransactionHashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        name: "HydratedBlockStateValidationError";
+        message?: string | undefined;
+        offendingTransactionHashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    };
+};
+export declare const toHydratedBlockStateValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        name: "HydratedBlockStateValidationError";
+        message?: string | undefined;
+        offendingTransactionHashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        value: unknown;
+        chainId: import("@ariestools/sdk").BrandedHex;
+        name: "HydratedBlockStateValidationError";
+        message?: string | undefined;
+        offendingTransactionHashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    };
+};
+//# sourceMappingURL=error.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/block/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/block/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAI3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,iBAAiB,EAAE,OAAO,EAAE,aAAa,EAC1C,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAAE,eAAe,EAAsB,MAAM,aAAa,CAAA;AAEjE,eAAO,MAAM,uBAAuB;;;;;iBAAiF,CAAA;AAErH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE9E,wDAAwD;AACxD,qBAAa,oBAAqB,SAAQ,eAAe,CAAC,iBAAiB,CAAC;CAAG;AAE/E,eAAO,MAAM,sBAAsB;;;;;;CAAwC,CAAA;AAC3E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;CAAgE,CAAA;AACnG,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;CAAgE,CAAA;AAEnG,eAAO,MAAM,+BAA+B;;;;;iBAAyF,CAAA;AAErI,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE9F,gEAAgE;AAChE,qBAAa,4BAA6B,SAAQ,eAAe,CAAC,aAAa,CAAC;CAAG;AAEnF,eAAO,MAAM,8BAA8B;;;;;;CAAgD,CAAA;AAC3F,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;CAAgF,CAAA;AAC3H,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;CAAgF,CAAA;AAE3H,eAAO,MAAM,oCAAoC;;;;;;;iBAIvC,CAAA;AAEV,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAExG,qEAAqE;AACrE,qBAAa,iCAAkC,SAAQ,eAAe,CAAC,aAAa,CAAC;IACnF,OAAO,EAAE,OAAO,CAAA;IAChB,0BAA0B,CAAC,EAAE,IAAI,EAAE,CAAA;gBAEjC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,EACf,0BAA0B,CAAC,EAAE,IAAI,EAAE;CAMtC;AAED,eAAO,MAAM,mCAAmC;;;;;;;;CAAqD,CAAA;AACrG,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;CAA0F,CAAA;AAC1I,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;CAA0F,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/block/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BlockValidationFunction.js';
+export * from './error.js';
+export * from './HydratedBlockStateValidationFunction.js';
+export * from './HydratedBlockValidationFunction.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/block/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/block/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,YAAY,CAAA;AAC1B,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/boundwitness/BoundWitnessValidationFunction.d.ts

@@ -0,0 +1,6 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { BoundWitness } from '@xyo-network/sdk';
+import type { BoundWitnessValidationError } from './error.js';
+/** Function type for BoundWitnessValidation operations. */
+export type BoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: T) => Promisable<BoundWitnessValidationError[]>;
+//# sourceMappingURL=BoundWitnessValidationFunction.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/boundwitness/BoundWitnessValidationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundWitnessValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/boundwitness/BoundWitnessValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAA;AAE7D,2DAA2D;AAC3D,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,IAAI,CAClF,EAAE,EAAE,CAAC,KACF,UAAU,CAAC,2BAA2B,EAAE,CAAC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/boundwitness/HydratedBoundWitnessValidationFunction.d.ts

@@ -0,0 +1,8 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { BoundWitness, Payload, WithHashMeta } from '@xyo-network/sdk';
+import type { HydratedBoundWitnessValidationError } from './error.js';
+/** Type representing a hydrated BoundWitnessWithHashMeta with resolved payloads. */
+export type HydratedBoundWitnessWithHashMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [WithHashMeta<T>, WithHashMeta<P>[]];
+/** Type representing a hydrated BoundWitnessValidationFunction with resolved payloads. */
+export type HydratedBoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: HydratedBoundWitnessWithHashMeta<T>) => Promisable<HydratedBoundWitnessValidationError[]>;
+//# sourceMappingURL=HydratedBoundWitnessValidationFunction.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/boundwitness/HydratedBoundWitnessValidationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydratedBoundWitnessValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/boundwitness/HydratedBoundWitnessValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EACV,YAAY,EAAE,OAAO,EAAE,YAAY,EACpC,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,YAAY,CAAA;AAErE,oFAAoF;AACpF,MAAM,MAAM,gCAAgC,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAAE,CAAC,SAAS,OAAO,GAAG,OAAO,IAC3G,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAExC,0FAA0F;AAC1F,MAAM,MAAM,sCAAsC,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,IAAI,CAC1F,EAAE,EAAE,gCAAgC,CAAC,CAAC,CAAC,KACpC,UAAU,CAAC,mCAAmC,EAAE,CAAC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/boundwitness/error.d.ts

@@ -0,0 +1,13 @@
+import type { BoundWitness, HydratedBoundWitness } from '@xyo-network/sdk';
+import { ValidationError } from '../error.js';
+/** Error thrown during BoundWitnessvalidation  operations. */
+export declare class BoundWitnessValidationError extends ValidationError<BoundWitness> {
+}
+/** Type guard that checks if a value is a valid BoundWitnessValidationError. */
+export declare const isBoundWitnessValidationError: (error: unknown) => error is BoundWitnessValidationError;
+/** Error thrown during HydratedBoundWitnessvalidation  operations. */
+export declare class HydratedBoundWitnessValidationError extends ValidationError<HydratedBoundWitness> {
+}
+/** Type guard that checks if a value is a valid HydratedBoundWitnessValidationError. */
+export declare const isHydratedBoundWitnessValidationError: (error: unknown) => error is HydratedBoundWitnessValidationError;
+//# sourceMappingURL=error.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/boundwitness/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/boundwitness/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE1E,OAAO,EAAqB,eAAe,EAAE,MAAM,aAAa,CAAA;AAEhE,8DAA8D;AAC9D,qBAAa,2BAA4B,SAAQ,eAAe,CAAC,YAAY,CAAC;CAAG;AAEjF,gFAAgF;AAChF,eAAO,MAAM,6BAA6B,GACxC,OAAO,OAAO,KACb,KAAK,IAAI,2BAKX,CAAA;AAED,sEAAsE;AACtE,qBAAa,mCAAoC,SAAQ,eAAe,CAAC,oBAAoB,CAAC;CAAG;AAEjG,wFAAwF;AACxF,eAAO,MAAM,qCAAqC,GAChD,OAAO,OAAO,KACb,KAAK,IAAI,mCAKX,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/boundwitness/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BoundWitnessValidationFunction.js';
+export * from './error.js';
+export * from './HydratedBoundWitnessValidationFunction.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/boundwitness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/boundwitness/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAA;AACnD,cAAc,YAAY,CAAA;AAC1B,cAAc,6CAA6C,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/error.d.ts

@@ -0,0 +1,59 @@
+import { type Hash } from '@ariestools/sdk';
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod';
+export declare const ValidationErrorZod: z.ZodObject<{
+    hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    message: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    value: z.ZodUnknown;
+}, z.core.$loose>;
+export type ValidationErrorType = z.infer<typeof ValidationErrorZod>;
+/** Error thrown during validation  operations. */
+export declare class ValidationError<TValue = Payload> extends Error {
+    cause?: unknown;
+    hash: Hash;
+    message: string;
+    value: TValue;
+    constructor(hash: Hash, value: TValue, message: string, cause?: unknown);
+}
+/** Type guard that checks if a value is a valid ValidationError. */
+export declare const isValidationError: <T>(value: T) => value is T & {
+    [x: string]: unknown;
+    hash: import("@ariestools/sdk").BrandedHash;
+    name: string;
+    value: unknown;
+    message?: string | undefined;
+};
+export declare const asValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        value: unknown;
+        message?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        value: unknown;
+        message?: string | undefined;
+    };
+};
+export declare const toValidationError: {
+    <T>(value: T): (T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        value: unknown;
+        message?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        [x: string]: unknown;
+        hash: import("@ariestools/sdk").BrandedHash;
+        name: string;
+        value: unknown;
+        message?: string | undefined;
+    };
+};
+//# sourceMappingURL=error.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/validation/error.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EACV,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,kBAAkB;;;;;iBAKrB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEpE,kDAAkD;AAClD,qBAAa,eAAe,CAAC,MAAM,GAAG,OAAO,CAAE,SAAQ,KAAK;IACjD,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB,IAAI,EAAE,IAAI,CAAA;IACD,OAAO,EAAE,MAAM,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;gBACD,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAQxE;AAED,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;CAAmC,CAAA;AACjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAAsD,CAAA;AACpF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAAsD,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/index.d.ts

@@ -0,0 +1,6 @@
+export * from './block/index.js';
+export * from './boundwitness/index.js';
+export * from './error.js';
+export * from './payload/index.js';
+export * from './transaction/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/validation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.d.ts

@@ -0,0 +1,10 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { Payload, WithHashMeta } from '@xyo-network/sdk';
+import type { BaseContext, HydratedBlockWithHashMeta } from '../../../protocol-model/index.js';
+import type { InBlockPayloadValidationError } from './error.js';
+/** Context for InBlockPayloadValidationFunction operations. */
+export interface InBlockPayloadValidationFunctionContext extends BaseContext {
+}
+/** Function type for InBlockPayloadValidation operations. */
+export type InBlockPayloadValidationFunction = (context: InBlockPayloadValidationFunctionContext, payload: WithHashMeta<Payload>, block: HydratedBlockWithHashMeta) => Promisable<InBlockPayloadValidationError[]>;
+//# sourceMappingURL=InBlockPayloadValidationFunction.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InBlockPayloadValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/InBlockPayloadValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAA;AAE7E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAA;AAE/D,+DAA+D;AAC/D,MAAM,WAAW,uCAAwC,SAAQ,WAAW;CAE3E;AAED,6DAA6D;AAC7D,MAAM,MAAM,gCAAgC,GAAG,CAC7C,OAAO,EAAE,uCAAuC,EAChD,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,yBAAyB,KAC7D,UAAU,CAAC,6BAA6B,EAAE,CAAC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/payload/error.d.ts

@@ -0,0 +1,12 @@
+import type { Hash } from '@ariestools/sdk';
+import { type Payload } from '@xyo-network/sdk';
+import type { HydratedBlock } from '../../../protocol-model/index.js';
+import { ValidationError } from '../error.js';
+/** Error thrown during InBlockPayload validation  operations. */
+export declare class InBlockPayloadValidationError extends ValidationError<Payload> {
+    block: HydratedBlock;
+    constructor(hash: Hash, block: HydratedBlock, value: Payload, message: string, cause?: unknown);
+}
+/** Type guard that checks if a value is a valid InBlockPayloadValidationError. */
+export declare const isInBlockPayloadValidationError: (error: unknown) => error is InBlockPayloadValidationError;
+//# sourceMappingURL=error.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/payload/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,EAAqB,eAAe,EAAE,MAAM,aAAa,CAAA;AAEhE,iEAAiE;AACjE,qBAAa,6BAA8B,SAAQ,eAAe,CAAC,OAAO,CAAC;IACzE,KAAK,EAAE,aAAa,CAAA;gBACR,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAI/F;AAED,kFAAkF;AAClF,eAAO,MAAM,+BAA+B,GAC1C,OAAO,OAAO,KACb,KAAK,IAAI,6BAKX,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/payload/index.d.ts

@@ -0,0 +1,3 @@
+export * from './error.js';
+export * from './InBlockPayloadValidationFunction.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/payload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/payload/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,uCAAuC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/transaction/HydratedTransactionStateValidationFunction.d.ts

@@ -0,0 +1,18 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { AccountBalanceViewer, BaseContext, ChainId, HydratedTransactionWithHashMeta } from '../../../protocol-model/index.js';
+import type { BlockViewer } from '../../viewers/index.js';
+import type { HydratedTransactionValidationError } from './error.js';
+/** Context for HydratedTransactionStateValidationFunction operations. */
+export interface HydratedTransactionStateValidationFunctionContext extends BaseContext {
+    accountBalanceViewer: AccountBalanceViewer;
+    blockViewer: BlockViewer;
+    chainId: ChainId;
+}
+/**
+ * A function that validates a hydrated transaction against chain state.
+ * @param context The context to use for validation.
+ * @param hydratedTransaction The hydrated transaction to validate.
+ * @returns An array of errors if the transaction is invalid, or an empty array if it is valid.
+ */
+export type HydratedTransactionStateValidationFunction = (context: HydratedTransactionStateValidationFunctionContext, hydratedTransaction: HydratedTransactionWithHashMeta) => Promisable<HydratedTransactionValidationError[]>;
+//# sourceMappingURL=HydratedTransactionStateValidationFunction.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/transaction/HydratedTransactionStateValidationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydratedTransactionStateValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/transaction/HydratedTransactionStateValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EACV,oBAAoB,EACpB,WAAW,EAAE,OAAO,EACpB,+BAA+B,EAChC,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,YAAY,CAAA;AAEpE,yEAAyE;AACzE,MAAM,WAAW,iDAAkD,SAAQ,WAAW;IACpF,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;GAKG;AACH,MAAM,MAAM,0CAA0C,GAAG,CACvD,OAAO,EAAE,iDAAiD,EAC1D,mBAAmB,EAAE,+BAA+B,KACjD,UAAU,CAAC,kCAAkC,EAAE,CAAC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/transaction/HydratedTransactionValidationFunction.d.ts

@@ -0,0 +1,16 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { BaseContext, ChainId, HydratedTransactionWithHashMeta, StepIdentity } from '../../../protocol-model/index.js';
+import type { HydratedTransactionValidationError } from './error.js';
+/** Context for HydratedTransactionValidationFunction operations. */
+export interface HydratedTransactionValidationFunctionContext extends BaseContext {
+    chainId: ChainId;
+    step?: StepIdentity;
+}
+/**
+ * A function that validates a hydrated transaction.
+ * @param bw The hydrated transaction to validate.
+ * @param context The context to use for validation.
+ * @returns An array of errors if the transaction is invalid, or an empty array if it is valid.
+ */
+export type HydratedTransactionValidationFunction<TContext extends HydratedTransactionValidationFunctionContext = HydratedTransactionValidationFunctionContext> = (context: TContext, hydratedTransaction: HydratedTransactionWithHashMeta, additionalValidators?: HydratedTransactionValidationFunction<TContext>[]) => Promisable<HydratedTransactionValidationError[]>;
+//# sourceMappingURL=HydratedTransactionValidationFunction.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/transaction/HydratedTransactionValidationFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HydratedTransactionValidationFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/transaction/HydratedTransactionValidationFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EACV,WAAW,EAAE,OAAO,EAAE,+BAA+B,EAAE,YAAY,EACpE,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,YAAY,CAAA;AAEpE,oEAAoE;AACpE,MAAM,WAAW,4CAA6C,SAAQ,WAAW;IAC/E,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,qCAAqC,CAAC,QAAQ,SAAS,4CAA4C,GAAG,4CAA4C,IAAI,CAChK,OAAO,EAAE,QAAQ,EACjB,mBAAmB,EAAE,+BAA+B,EACpD,oBAAoB,CAAC,EAAE,qCAAqC,CAAC,QAAQ,CAAC,EAAE,KACrE,UAAU,CAAC,kCAAkC,EAAE,CAAC,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/transaction/error.d.ts

@@ -0,0 +1,8 @@
+import type { HydratedTransaction } from '../../../protocol-model/index.js';
+import { ValidationError } from '../error.js';
+/** Error thrown during HydratedTransactionvalidation  operations. */
+export declare class HydratedTransactionValidationError extends ValidationError<HydratedTransaction> {
+}
+/** Type guard that checks if a value is a valid HydratedTransactionValidationError. */
+export declare const isHydratedTransactionValidationError: (error: unknown) => error is HydratedTransactionValidationError;
+//# sourceMappingURL=error.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/transaction/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/transaction/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D,OAAO,EAAqB,eAAe,EAAE,MAAM,aAAa,CAAA;AAEhE,qEAAqE;AACrE,qBAAa,kCAAmC,SAAQ,eAAe,CAAC,mBAAmB,CAAC;CAAG;AAE/F,uFAAuF;AACvF,eAAO,MAAM,oCAAoC,GAC/C,OAAO,OAAO,KACb,KAAK,IAAI,kCAKX,CAAA"}

package/dist/neutral/modules/protocol-lib/validation/transaction/index.d.ts

@@ -0,0 +1,4 @@
+export * from './error.js';
+export * from './HydratedTransactionStateValidationFunction.js';
+export * from './HydratedTransactionValidationFunction.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-lib/validation/transaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-lib/validation/transaction/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,iDAAiD,CAAA;AAC/D,cAAc,4CAA4C,CAAA"}

package/dist/neutral/modules/protocol-lib/viewers/Block.d.ts

@@ -0,0 +1,38 @@
+import type { EventData, EventEmitter, Hash, Promisable } from '@ariestools/sdk';
+import type { Payload, WithHashMeta } from '@xyo-network/sdk';
+import type { BlockRate, ChainId, Provider, ProviderMoniker, SignedHydratedBlockWithHashMeta, SingleTimeConfig, TimeDurations, XL1BlockNumber, XL1BlockRange } from '../../protocol-model/index.js';
+/** Payload for the BlockViewer `headUpdated` event. */
+export interface BlockViewerHeadUpdatedEvent {
+    block: SignedHydratedBlockWithHashMeta;
+}
+/** Event map for BlockViewer instances. */
+export interface BlockViewerEventData extends EventData {
+    headUpdated: BlockViewerHeadUpdatedEvent;
+}
+/** BlockViewerMethods interface. */
+export interface BlockViewerMethods {
+    blocksByHash(hash: Hash, limit?: number): Promisable<SignedHydratedBlockWithHashMeta[]>;
+    blocksByNumber(block: XL1BlockNumber, limit?: number): Promisable<SignedHydratedBlockWithHashMeta[]>;
+    blocksByStep(stepLevel: number, stepIndex: number): Promisable<SignedHydratedBlockWithHashMeta[]>;
+    currentBlock(): Promisable<SignedHydratedBlockWithHashMeta>;
+    payloadsByHash(hashes: Hash[]): Promisable<WithHashMeta<Payload>[]>;
+}
+/** Moniker identifier for the BlockViewer provider. */
+export declare const BlockViewerMoniker: "BlockViewer";
+/** Type literal for the BlockViewer provider moniker. */
+export type BlockViewerMoniker = typeof BlockViewerMoniker;
+/** Viewer interface for reading Block data. */
+export interface BlockViewer<TMoniker extends ProviderMoniker = BlockViewerMoniker> extends BlockViewerMethods, EventEmitter<BlockViewerEventData>, Provider<TMoniker> {
+    blockByHash(hash: Hash): Promisable<SignedHydratedBlockWithHashMeta | null>;
+    blockByNumber(block: XL1BlockNumber): Promisable<SignedHydratedBlockWithHashMeta | null>;
+    chainId(): Promisable<ChainId>;
+    chainId(blockNumber: XL1BlockNumber): Promisable<ChainId>;
+    chainId(blockNumber: 'latest'): Promisable<ChainId>;
+    currentBlockHash(): Promisable<Hash>;
+    currentBlockNumber(): Promisable<XL1BlockNumber>;
+    payloadByHash(hash: Hash): Promisable<WithHashMeta<Payload> | null>;
+    rate(range: XL1BlockRange, timeUnit?: keyof TimeDurations): Promisable<BlockRate>;
+    stepSizeRate(start: XL1BlockNumber, stepIndex: number, count?: number, timeUnit?: keyof TimeDurations): Promisable<BlockRate>;
+    timeDurationRate(timeConfig: SingleTimeConfig, startBlockNumber?: XL1BlockNumber, timeUnit?: keyof TimeDurations, toleranceMs?: number, maxAttempts?: number): Promisable<BlockRate>;
+}
+//# sourceMappingURL=Block.d.ts.map

package/dist/neutral/modules/protocol-lib/viewers/Block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Block.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/viewers/Block.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,EAC1C,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE7D,OAAO,KAAK,EACV,SAAS,EAAE,OAAO,EAClB,QAAQ,EAAE,eAAe,EAAE,+BAA+B,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAC3H,MAAM,iBAAiB,CAAA;AAExB,uDAAuD;AACvD,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,+BAA+B,CAAA;CACvC;AAED,2CAA2C;AAC3C,MAAM,WAAW,oBAAqB,SAAQ,SAAS;IACrD,WAAW,EAAE,2BAA2B,CAAA;CACzC;AAED,oCAAoC;AACpC,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,+BAA+B,EAAE,CAAC,CAAA;IACvF,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,+BAA+B,EAAE,CAAC,CAAA;IACpG,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC,+BAA+B,EAAE,CAAC,CAAA;IACjG,YAAY,IAAI,UAAU,CAAC,+BAA+B,CAAC,CAAA;IAC3D,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;CACpE;AAED,uDAAuD;AACvD,eAAO,MAAM,kBAAkB,EAAG,aAAsB,CAAA;AACxD,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D,+CAA+C;AAC/C,MAAM,WAAW,WAAW,CAAC,QAAQ,SAAS,eAAe,GAAG,kBAAkB,CAChF,SAAQ,kBAAkB,EAAE,YAAY,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC;IAClF,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAAA;IAC3E,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAAA;IACxF,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;IAC9B,OAAO,CAAC,WAAW,EAAE,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IACzD,OAAO,CAAC,WAAW,EAAE,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IACnD,gBAAgB,IAAI,UAAU,CAAC,IAAI,CAAC,CAAA;IACpC,kBAAkB,IAAI,UAAU,CAAC,cAAc,CAAC,CAAA;IAChD,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;IACnE,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;IACjF,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;IAC7H,gBAAgB,CACd,UAAU,EAAE,gBAAgB,EAC5B,gBAAgB,CAAC,EAAE,cAAc,EACjC,QAAQ,CAAC,EAAE,MAAM,aAAa,EAC9B,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,GACnB,UAAU,CAAC,SAAS,CAAC,CAAA;CACzB"}

package/dist/neutral/modules/protocol-lib/viewers/BlockInvalidation.d.ts

@@ -0,0 +1,56 @@
+import { type Promisable } from '@ariestools/sdk';
+import { z } from 'zod';
+import type { ChainQualified, Provider, SignedHydratedBlock, SignedHydratedBlockWithHashMeta } from '../../protocol-model/index.js';
+import type { HydratedBlockValidationError } from '../validation/index.js';
+/** BlockInvalidationConfigFieldsZod constant. */
+export declare const BlockInvalidationConfigFieldsZod: z.ZodObject<{
+    state: z.ZodOptional<z.ZodBoolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** BlockInvalidationConfigZod constant. */
+export declare const BlockInvalidationConfigZod: z.ZodUnion<readonly [z.ZodObject<{
+    state: z.ZodOptional<z.ZodBoolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+    head: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodOptional<z.ZodBoolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<import('../../protocol-model/index.js').XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../../protocol-model/index.js').XL1BlockNumber, number>>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodOptional<z.ZodBoolean>;
+    value: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>;
+/** BlockInvalidationConfig type. */
+export type BlockInvalidationConfig = z.infer<typeof BlockInvalidationConfigZod>;
+/** Type guard that checks if a value is a valid BlockInvalidationConfig. */
+export declare const isBlockInvalidationConfig: <T>(value: T) => value is T & (Record<string, never> | {
+    state?: boolean | undefined;
+    value?: boolean | undefined;
+} | {
+    head: import("@ariestools/sdk").BrandedHash;
+    state?: boolean | undefined;
+    value?: boolean | undefined;
+} | {
+    range: [import('../../protocol-model/index.js').XL1BlockNumber, import('../../protocol-model/index.js').XL1BlockNumber];
+    state?: boolean | undefined;
+    value?: boolean | undefined;
+});
+/**
+ * Checks if blocks are invalid (impossible to ever become valid) according to protocol rules.
+ */
+export interface BlockInvalidationViewerMethods {
+    qualifiedInvalidateBlocks(blocks: SignedHydratedBlock[], config?: BlockInvalidationConfig): Promisable<ChainQualified<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>>;
+    qualifiedInvalidateUncle(blocks: SignedHydratedBlock[], config?: BlockInvalidationConfig): Promisable<ChainQualified<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>>;
+}
+/** Moniker identifier for the BlockInvalidationViewer provider. */
+export declare const BlockInvalidationViewerMoniker: "BlockInvalidationViewer";
+/** Type literal for the BlockInvalidationViewer provider moniker. */
+export type BlockInvalidationViewerMoniker = typeof BlockInvalidationViewerMoniker;
+/** Viewer interface for reading BlockInvalidation data. */
+export interface BlockInvalidationViewer extends BlockInvalidationViewerMethods, Provider<BlockInvalidationViewerMoniker> {
+    invalidateBlock(block: SignedHydratedBlock, config?: BlockInvalidationConfig): Promisable<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta>;
+    invalidateBlocks(blocks: SignedHydratedBlock[], config?: BlockInvalidationConfig): Promisable<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>;
+    invalidateUncle(blocks: SignedHydratedBlock[], config?: BlockInvalidationConfig): Promisable<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>;
+    qualifiedInvalidateBlock(block: SignedHydratedBlock, config?: BlockInvalidationConfig): Promisable<ChainQualified<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta>>;
+}
+//# sourceMappingURL=BlockInvalidation.d.ts.map

package/dist/neutral/modules/protocol-lib/viewers/BlockInvalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockInvalidation.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/viewers/BlockInvalidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EAAE,mBAAmB,EAAE,+BAA+B,EAC/D,MAAM,iBAAiB,CAAA;AAGxB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAA;AAE1E,iDAAiD;AACjD,eAAO,MAAM,gCAAgC;;;iBAG3C,CAAA;AAEF,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;mDAKrC,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAChF,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;EAA2C,CAAA;AAEjF;;GAEG;AAEH,MAAM,WAAW,8BAA8B;IAC7C,yBAAyB,CACvB,MAAM,EAAE,mBAAmB,EAAE,EAC7B,MAAM,CAAC,EAAE,uBAAuB,GAC/B,UAAU,CAAC,cAAc,CAAC,CAAC,4BAA4B,EAAE,GAAG,+BAA+B,CAAC,EAAE,CAAC,CAAC,CAAA;IAEnG,wBAAwB,CACtB,MAAM,EAAE,mBAAmB,EAAE,EAC7B,MAAM,CAAC,EAAE,uBAAuB,GAC/B,UAAU,CAAC,cAAc,CAAC,CAAC,4BAA4B,EAAE,GAAG,+BAA+B,CAAC,EAAE,CAAC,CAAC,CAAA;CACpG;AAED,mEAAmE;AACnE,eAAO,MAAM,8BAA8B,EAAG,yBAAkC,CAAA;AAChF,qEAAqE;AACrE,MAAM,MAAM,8BAA8B,GAAG,OAAO,8BAA8B,CAAA;AAElF,2DAA2D;AAC3D,MAAM,WAAW,uBAAwB,SAAQ,8BAA8B,EAAE,QAAQ,CAAC,8BAA8B,CAAC;IACvH,eAAe,CACb,KAAK,EAAE,mBAAmB,EAC1B,MAAM,CAAC,EAAE,uBAAuB,GAC/B,UAAU,CAAC,4BAA4B,EAAE,GAAG,+BAA+B,CAAC,CAAA;IAE/E,gBAAgB,CACd,MAAM,EAAE,mBAAmB,EAAE,EAC7B,MAAM,CAAC,EAAE,uBAAuB,GAC/B,UAAU,CAAC,CAAC,4BAA4B,EAAE,GAAG,+BAA+B,CAAC,EAAE,CAAC,CAAA;IAEnF,eAAe,CACb,MAAM,EAAE,mBAAmB,EAAE,EAC7B,MAAM,CAAC,EAAE,uBAAuB,GAC/B,UAAU,CAAC,CAAC,4BAA4B,EAAE,GAAG,+BAA+B,CAAC,EAAE,CAAC,CAAA;IAEnF,wBAAwB,CACtB,KAAK,EAAE,mBAAmB,EAC1B,MAAM,CAAC,EAAE,uBAAuB,GAC/B,UAAU,CAAC,cAAc,CAAC,4BAA4B,EAAE,GAAG,+BAA+B,CAAC,CAAC,CAAA;CAChG"}

package/dist/neutral/modules/protocol-lib/viewers/BlockReward.d.ts

@@ -0,0 +1,14 @@
+import type { Promisable } from '@ariestools/sdk';
+import type { AttoXL1, Provider, XL1BlockNumber } from '../../protocol-model/index.js';
+/** BlockRewardViewerMethods interface. */
+export interface BlockRewardViewerMethods {
+    allowedRewardForBlock(block: XL1BlockNumber): Promisable<AttoXL1>;
+}
+/** Moniker identifier for the BlockRewardViewer provider. */
+export declare const BlockRewardViewerMoniker: "BlockRewardViewer";
+/** Type literal for the BlockRewardViewer provider moniker. */
+export type BlockRewardViewerMoniker = typeof BlockRewardViewerMoniker;
+/** Viewer interface for reading BlockReward data. */
+export interface BlockRewardViewer extends BlockRewardViewerMethods, Provider<BlockRewardViewerMoniker> {
+}
+//# sourceMappingURL=BlockReward.d.ts.map

package/dist/neutral/modules/protocol-lib/viewers/BlockReward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockReward.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-lib/viewers/BlockReward.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EACV,OAAO,EAAE,QAAQ,EAAE,cAAc,EAClC,MAAM,iBAAiB,CAAA;AAExB,0CAA0C;AAC1C,MAAM,WAAW,wBAAwB;IAEvC,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;CAClE;AAED,6DAA6D;AAC7D,eAAO,MAAM,wBAAwB,EAAG,mBAA4B,CAAA;AACpE,+DAA+D;AAC/D,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAA;AAEtE,qDAAqD;AACrD,MAAM,WAAW,iBAAkB,SAAQ,wBAAwB,EAAE,QAAQ,CAAC,wBAAwB,CAAC;CAAG"}

package/dist/neutral/modules/protocol-lib/viewers/BlockValidation.d.ts

@@ -0,0 +1,56 @@
+import { type Promisable } from '@ariestools/sdk';
+import { z } from 'zod';
+import type { ChainQualified, Provider, SignedHydratedBlock, SignedHydratedBlockWithHashMeta } from '../../protocol-model/index.js';
+import type { HydratedBlockValidationError } from '../validation/index.js';
+/** BlockValidationConfigFieldsZod constant. */
+export declare const BlockValidationConfigFieldsZod: z.ZodObject<{
+    value: z.ZodOptional<z.ZodBoolean>;
+    state: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** BlockValidationConfigZod constant. */
+export declare const BlockValidationConfigZod: z.ZodUnion<readonly [z.ZodObject<{
+    value: z.ZodOptional<z.ZodBoolean>;
+    state: z.ZodOptional<z.ZodBoolean>;
+    head: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>, z.ZodObject<{
+    value: z.ZodOptional<z.ZodBoolean>;
+    state: z.ZodOptional<z.ZodBoolean>;
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<import('../../protocol-model/index.js').XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../../protocol-model/index.js').XL1BlockNumber, number>>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    value: z.ZodOptional<z.ZodBoolean>;
+    state: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>;
+/** BlockValidationConfig type. */
+export type BlockValidationConfig = z.infer<typeof BlockValidationConfigZod>;
+/** Type guard that checks if a value is a valid BlockValidationConfig. */
+export declare const isBlockValidationConfig: <T>(value: T) => value is T & (Record<string, never> | {
+    value?: boolean | undefined;
+    state?: boolean | undefined;
+} | {
+    head: import("@ariestools/sdk").BrandedHash;
+    value?: boolean | undefined;
+    state?: boolean | undefined;
+} | {
+    range: [import('../../protocol-model/index.js').XL1BlockNumber, import('../../protocol-model/index.js').XL1BlockNumber];
+    value?: boolean | undefined;
+    state?: boolean | undefined;
+});
+/** BlockValidationViewerMethods interface. */
+export interface BlockValidationViewerMethods {
+    qualifiedValidateBlocks(blocks: SignedHydratedBlock[], config?: BlockValidationConfig): Promisable<ChainQualified<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>>;
+    qualifiedValidateUncle(blocks: SignedHydratedBlock[], config?: BlockValidationConfig): Promisable<ChainQualified<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>>;
+}
+/** Moniker identifier for the BlockValidationViewer provider. */
+export declare const BlockValidationViewerMoniker: "BlockValidationViewer";
+/** Type literal for the BlockValidationViewer provider moniker. */
+export type BlockValidationViewerMoniker = typeof BlockValidationViewerMoniker;
+/**
+ * Checks if blocks are valid (currently valid) according to protocol rules.  In the case that they are not valid, they may still become valid in the future.
+ */
+export interface BlockValidationViewer extends BlockValidationViewerMethods, Provider<BlockValidationViewerMoniker> {
+    qualifiedValidateBlock(block: SignedHydratedBlock, config?: BlockValidationConfig): Promisable<ChainQualified<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta>>;
+    validateBlock(block: SignedHydratedBlock, config?: BlockValidationConfig): Promisable<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta>;
+    validateBlocks(blocks: SignedHydratedBlock[], config?: BlockValidationConfig): Promisable<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>;
+    validateUncle(blocks: SignedHydratedBlock[], config?: BlockValidationConfig): Promisable<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]>;
+}
+//# sourceMappingURL=BlockValidation.d.ts.map