@xyo-network/xl1-protocol 4.0.11 → 4.0.14

package/dist/neutral/modules/protocol-model/model/BlockRate.d.ts

@@ -0,0 +1,290 @@
+import { z } from 'zod';
+import type { EthBlockNumber, XL1BlockNumber } from '../BlockNumber/index.js';
+/** TimeDurationsZod constant. */
+export declare const TimeDurationsZod: z.ZodObject<{
+    millis: z.ZodNumber;
+    seconds: z.ZodNumber;
+    minutes: z.ZodNumber;
+    hours: z.ZodNumber;
+    days: z.ZodNumber;
+    weeks: z.ZodNumber;
+}, z.core.$strip>;
+/** Type guard that checks if a value is a valid TimeDurations. */
+export declare const isTimeDurations: <T>(value: T) => value is T & {
+    millis: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+    weeks: number;
+};
+/** Converts a value to TimeDurations, throwing if invalid. */
+export declare const asTimeDurations: {
+    <T>(value: T): (T & {
+        millis: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        weeks: number;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        millis: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        weeks: number;
+    };
+};
+/** toTimeDurations constant. */
+export declare const toTimeDurations: {
+    <T>(value: T): (T & {
+        millis: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        weeks: number;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        millis: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        weeks: number;
+    };
+};
+/** TimeDurations type. */
+export type TimeDurations = z.infer<typeof TimeDurationsZod>;
+/** BlockRateZod constant. */
+export declare const BlockRateZod: z.ZodObject<{
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<XL1BlockNumber, number>>], null>;
+    rate: z.ZodNumber;
+    timeUnit: z.ZodEnum<{
+        millis: "millis";
+        seconds: "seconds";
+        minutes: "minutes";
+        hours: "hours";
+        days: "days";
+        weeks: "weeks";
+    }>;
+    span: z.ZodInt;
+    timeDifference: z.ZodNumber;
+    timePerBlock: z.ZodNumber;
+}, z.core.$strip>;
+/** BlockRate type. */
+export type BlockRate = z.infer<typeof BlockRateZod>;
+/** GenericBlockRate type. */
+export type GenericBlockRate<TBlockNumber extends number> = Omit<BlockRate, 'range'> & {
+    range: [TBlockNumber, TBlockNumber];
+};
+/** XL1BlockRate interface. */
+export interface XL1BlockRate extends GenericBlockRate<XL1BlockNumber> {
+}
+/** EthBlockRate interface. */
+export interface EthBlockRate extends GenericBlockRate<EthBlockNumber> {
+}
+/** Type guard that checks if a value is a valid BlockRate. */
+export declare const isBlockRate: <T>(value: T) => value is T & {
+    range: [XL1BlockNumber, XL1BlockNumber];
+    rate: number;
+    timeUnit: "millis" | "seconds" | "minutes" | "hours" | "days" | "weeks";
+    span: number;
+    timeDifference: number;
+    timePerBlock: number;
+};
+/** Converts a value to BlockRate, throwing if invalid. */
+export declare const asBlockRate: {
+    <T>(value: T): (T & {
+        range: [XL1BlockNumber, XL1BlockNumber];
+        rate: number;
+        timeUnit: "millis" | "seconds" | "minutes" | "hours" | "days" | "weeks";
+        span: number;
+        timeDifference: number;
+        timePerBlock: number;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        range: [XL1BlockNumber, XL1BlockNumber];
+        rate: number;
+        timeUnit: "millis" | "seconds" | "minutes" | "hours" | "days" | "weeks";
+        span: number;
+        timeDifference: number;
+        timePerBlock: number;
+    };
+};
+/** toBlockRate constant. */
+export declare const toBlockRate: {
+    <T>(value: T): (T & {
+        range: [XL1BlockNumber, XL1BlockNumber];
+        rate: number;
+        timeUnit: "millis" | "seconds" | "minutes" | "hours" | "days" | "weeks";
+        span: number;
+        timeDifference: number;
+        timePerBlock: number;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        range: [XL1BlockNumber, XL1BlockNumber];
+        rate: number;
+        timeUnit: "millis" | "seconds" | "minutes" | "hours" | "days" | "weeks";
+        span: number;
+        timeDifference: number;
+        timePerBlock: number;
+    };
+};
+/** CountZod constant. */
+export declare const CountZod: z.ZodInt;
+/** Count type. */
+export type Count = z.infer<typeof CountZod>;
+/** StepIndexZod constant. */
+export declare const StepIndexZod: z.ZodInt;
+/** StepIndex type. */
+export type StepIndex = z.infer<typeof StepIndexZod>;
+/** TimeConfigZod constant. */
+export declare const TimeConfigZod: z.ZodObject<{
+    minutes: z.ZodOptional<z.ZodNumber>;
+    hours: z.ZodOptional<z.ZodNumber>;
+    days: z.ZodOptional<z.ZodNumber>;
+    weeks: z.ZodOptional<z.ZodNumber>;
+    months: z.ZodOptional<z.ZodNumber>;
+    years: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** TimeConfig type. */
+export type TimeConfig = z.infer<typeof TimeConfigZod>;
+/** Type guard that checks if a value is a valid TimeConfig. */
+export declare const isTimeConfig: <T>(value: T) => value is T & {
+    minutes?: number | undefined;
+    hours?: number | undefined;
+    days?: number | undefined;
+    weeks?: number | undefined;
+    months?: number | undefined;
+    years?: number | undefined;
+};
+/** Converts a value to TimeConfig, throwing if invalid. */
+export declare const asTimeConfig: {
+    <T>(value: T): (T & {
+        minutes?: number | undefined;
+        hours?: number | undefined;
+        days?: number | undefined;
+        weeks?: number | undefined;
+        months?: number | undefined;
+        years?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        minutes?: number | undefined;
+        hours?: number | undefined;
+        days?: number | undefined;
+        weeks?: number | undefined;
+        months?: number | undefined;
+        years?: number | undefined;
+    };
+};
+/** toTimeConfig constant. */
+export declare const toTimeConfig: {
+    <T>(value: T): (T & {
+        minutes?: number | undefined;
+        hours?: number | undefined;
+        days?: number | undefined;
+        weeks?: number | undefined;
+        months?: number | undefined;
+        years?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        minutes?: number | undefined;
+        hours?: number | undefined;
+        days?: number | undefined;
+        weeks?: number | undefined;
+        months?: number | undefined;
+        years?: number | undefined;
+    };
+};
+/** SingleTimeConfigZod constant. */
+export declare const SingleTimeConfigZod: z.ZodUnion<readonly [z.ZodObject<{
+    minutes: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    hours: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    days: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    weeks: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    months: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    years: z.ZodNumber;
+}, z.core.$strip>]>;
+/** SingleTimeConfig type. */
+export type SingleTimeConfig = z.infer<typeof SingleTimeConfigZod>;
+/** Type guard that checks if a value is a valid SingleTimeConfig. */
+export declare const isSingleTimeConfig: <T>(value: T) => value is T & ({
+    minutes: number;
+} | {
+    hours: number;
+} | {
+    days: number;
+} | {
+    weeks: number;
+} | {
+    months: number;
+} | {
+    years: number;
+});
+/** Converts a value to SingleTimeConfig, throwing if invalid. */
+export declare const asSingleTimeConfig: {
+    <T>(value: T): (T & ({
+        minutes: number;
+    } | {
+        hours: number;
+    } | {
+        days: number;
+    } | {
+        weeks: number;
+    } | {
+        months: number;
+    } | {
+        years: number;
+    })) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & ({
+        minutes: number;
+    } | {
+        hours: number;
+    } | {
+        days: number;
+    } | {
+        weeks: number;
+    } | {
+        months: number;
+    } | {
+        years: number;
+    });
+};
+/** toSingleTimeConfig constant. */
+export declare const toSingleTimeConfig: {
+    <T>(value: T): (T & ({
+        minutes: number;
+    } | {
+        hours: number;
+    } | {
+        days: number;
+    } | {
+        weeks: number;
+    } | {
+        months: number;
+    } | {
+        years: number;
+    })) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & ({
+        minutes: number;
+    } | {
+        hours: number;
+    } | {
+        days: number;
+    } | {
+        weeks: number;
+    } | {
+        months: number;
+    } | {
+        years: number;
+    });
+};
+//# sourceMappingURL=BlockRate.d.ts.map

package/dist/neutral/modules/protocol-model/model/BlockRate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockRate.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/BlockRate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAI7E,iCAAiC;AACjC,eAAO,MAAM,gBAAgB;;;;;;;iBAO3B,CAAA;AAEF,kEAAkE;AAClE,eAAO,MAAM,eAAe;;;;;;;CAAiC,CAAA;AAC7D,8DAA8D;AAC9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAChF,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAEhF,0BAA0B;AAC1B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE5D,6BAA6B;AAC7B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;iBAOvB,CAAA;AAEF,sBAAsB;AACtB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEpD,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,CAAC,YAAY,SAAS,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG;IACrF,KAAK,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,CAAA;CACpC,CAAA;AAED,8BAA8B;AAC9B,MAAM,WAAW,YAAa,SAAQ,gBAAgB,CAAC,cAAc,CAAC;CAAG;AACzE,8BAA8B;AAC9B,MAAM,WAAW,YAAa,SAAQ,gBAAgB,CAAC,cAAc,CAAC;CAAG;AAEzE,8DAA8D;AAC9D,eAAO,MAAM,WAAW;;;;;;;CAA6B,CAAA;AACrD,0DAA0D;AAC1D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;CAA4C,CAAA;AACpE,4BAA4B;AAC5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;CAA4C,CAAA;AAEpE,yBAAyB;AACzB,eAAO,MAAM,QAAQ,UAAiE,CAAA;AACtF,kBAAkB;AAClB,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE5C,6BAA6B;AAC7B,eAAO,MAAM,YAAY,UAAqF,CAAA;AAC9G,sBAAsB;AACtB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAIpD,8BAA8B;AAC9B,eAAO,MAAM,aAAa;;;;;;;iBAOgC,CAAA;AAE1D,uBAAuB;AACvB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEtD,+DAA+D;AAC/D,eAAO,MAAM,YAAY;;;;;;;CAA8B,CAAA;AACvD,2DAA2D;AAC3D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAA8C,CAAA;AACvE,6BAA6B;AAC7B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAA8C,CAAA;AAEvE,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;mBAO4B,CAAA;AAE5D,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAElE,qEAAqE;AACrE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAAoC,CAAA;AACnE,iEAAiE;AACjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0D,CAAA;AACzF,mCAAmC;AACnC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0D,CAAA"}

package/dist/neutral/modules/protocol-model/model/ChainQualification.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/** ChainQualificationZod constant. */
+export declare const ChainQualificationZod: z.ZodObject<{
+    head: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>], null>;
+}, z.core.$strip>;
+/** ChainQualification type. */
+export type ChainQualification = z.infer<typeof ChainQualificationZod>;
+/** Type guard that checks if a value is a valid ChainQualification. */
+export declare const isChainQualification: <T>(value: T) => value is T & {
+    head: import("@ariestools/sdk").BrandedHash;
+    range: [import('../index.js').XL1BlockNumber, import('../index.js').XL1BlockNumber];
+};
+/** ChainQualifiedRangeConfigZod constant. */
+export declare const ChainQualifiedRangeConfigZod: z.ZodObject<{
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>], null>;
+}, z.core.$strip>;
+/** ChainQualifiedRangeConfig type. */
+export type ChainQualifiedRangeConfig = z.infer<typeof ChainQualifiedRangeConfigZod>;
+/** Type guard that checks if a value is a valid ChainQualifiedRangeConfig. */
+export declare const isChainQualifiedRangeConfig: <T>(value: T) => value is T & {
+    range: [import('../index.js').XL1BlockNumber, import('../index.js').XL1BlockNumber];
+};
+/** ChainQualifiedHeadConfigZod constant. */
+export declare const ChainQualifiedHeadConfigZod: z.ZodObject<{
+    head: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** ChainQualifiedHeadConfig type. */
+export type ChainQualifiedHeadConfig = z.infer<typeof ChainQualifiedHeadConfigZod>;
+/** Type guard that checks if a value is a valid ChainQualifiedHeadConfig. */
+export declare const isChainQualifiedHeadConfig: <T>(value: T) => value is T & {
+    head: import("@ariestools/sdk").BrandedHash;
+};
+/** ChainQualifiedConfigZod constant. */
+export declare const ChainQualifiedConfigZod: z.ZodUnion<readonly [z.ZodObject<{
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    head: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>;
+/** ChainQualifiedConfig type. */
+export type ChainQualifiedConfig = z.infer<typeof ChainQualifiedConfigZod>;
+/** Type guard that checks if a value is a valid ChainQualifiedConfig. */
+export declare const isChainQualifiedConfig: <T>(value: T) => value is T & (Record<string, never> | {
+    range: [import('../index.js').XL1BlockNumber, import('../index.js').XL1BlockNumber];
+} | {
+    head: import("@ariestools/sdk").BrandedHash;
+});
+/** ExtendChainQualifiedConfigZod constant. */
+export declare const ExtendChainQualifiedConfigZod: <T>(zodType: z.ZodType<T>) => z.ZodType<T & ChainQualifiedConfig>;
+/** ChainQualified type. */
+export type ChainQualified<T> = [T, ChainQualification];
+/** ChainQualifiedZod constant. */
+export declare const ChainQualifiedZod: <T>(zodType: z.ZodType<T>) => z.ZodTuple<[z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>, z.ZodObject<{
+    head: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    range: z.ZodTuple<[z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../index.js').XL1BlockNumber, number>>], null>;
+}, z.core.$strip>], null>;
+//# sourceMappingURL=ChainQualification.d.ts.map

package/dist/neutral/modules/protocol-model/model/ChainQualification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainQualification.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/ChainQualification.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,sCAAsC;AACtC,eAAO,MAAM,qBAAqB;;;iBAAuD,CAAA;AACzF,+BAA+B;AAC/B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACtE,uEAAuE;AACvE,eAAO,MAAM,oBAAoB;;;CAAsC,CAAA;AAEvE,6CAA6C;AAC7C,eAAO,MAAM,4BAA4B;;iBAAwC,CAAA;AACjF,sCAAsC;AACtC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,8EAA8E;AAC9E,eAAO,MAAM,2BAA2B;;CAA6C,CAAA;AAErF,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B;;iBAA8B,CAAA;AACtE,qCAAqC;AACrC,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAClF,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B;;CAA4C,CAAA;AAEnF,wCAAwC;AACxC,eAAO,MAAM,uBAAuB;;;;mDAAqF,CAAA;AACzH,iCAAiC;AACjC,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC1E,yEAAyE;AACzE,eAAO,MAAM,sBAAsB;;;;EAAwC,CAAA;AAE3E,8CAA8C;AAC9C,eAAO,MAAM,6BAA6B,EAMpC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAA;AAEvE,2BAA2B;AAC3B,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAA;AACvD,kCAAkC;AAClC,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;;;yBAEzD,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/BaseContext.d.ts

@@ -0,0 +1,5 @@
+import type z from 'zod';
+import type { BaseContextZod } from './BaseContext.zod.js';
+/** BaseContext type. */
+export type BaseContext = z.infer<typeof BaseContextZod>;
+//# sourceMappingURL=BaseContext.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/BaseContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseContext.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/BaseContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/BaseContext.zod.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '@ariestools/sdk';
+import type { MeterProvider, TracerProvider } from '@opentelemetry/api';
+import { z } from 'zod';
+import type { MapType } from '../../map/index.js';
+/** CachesZod constant. */
+export declare const CachesZod: z.ZodRecord<z.ZodString, z.ZodCustom<MapType<string, unknown>, MapType<string, unknown>>>;
+/** SingletonsZod constant. */
+export declare const SingletonsZod: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+/** LoggerZod constant. */
+export declare const LoggerZod: z.ZodCustom<Logger, Logger>;
+/** MeterProviderZod constant. */
+export declare const MeterProviderZod: z.ZodCustom<MeterProvider, MeterProvider>;
+/** TracerProviderZod constant. */
+export declare const TracerProviderZod: z.ZodCustom<TracerProvider, TracerProvider>;
+/** TimeBudgetLimitZod constant. */
+export declare const TimeBudgetLimitZod: z.ZodNumber;
+/** BaseContextZod constant. */
+export declare const BaseContextZod: z.ZodObject<{
+    caches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<MapType<string, unknown>, MapType<string, unknown>>>>;
+    logger: z.ZodOptional<z.ZodCustom<Logger, Logger>>;
+    meterProvider: z.ZodOptional<z.ZodCustom<MeterProvider, MeterProvider>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<TracerProvider, TracerProvider>>;
+}, z.core.$strip>;
+//# sourceMappingURL=BaseContext.zod.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/BaseContext.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/BaseContext.zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAEjD,0BAA0B;AAC1B,eAAO,MAAM,SAAS,2FAGrB,CAAA;AAED,8BAA8B;AAC9B,eAAO,MAAM,aAAa,4EAA2D,CAAA;AAErF,0BAA0B;AAC1B,eAAO,MAAM,SAAS,6BAAqG,CAAA;AAE3H,iCAAiC;AACjC,eAAO,MAAM,gBAAgB,2CAA8F,CAAA;AAE3H,kCAAkC;AAClC,eAAO,MAAM,iBAAiB,6CAAgG,CAAA;AAE9H,mCAAmC;AACnC,eAAO,MAAM,kBAAkB,aAAa,CAAA;AAE5C,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;;iBAOzB,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/BlockContext.d.ts

@@ -0,0 +1,9 @@
+import type z from 'zod';
+import type { BlockContextReadZod, BlockContextWriteZod, BlockContextZod } from './BlockContext.zod.js';
+/** BlockContextRead type. */
+export type BlockContextRead = z.infer<typeof BlockContextReadZod>;
+/** BlockContextWrite type. */
+export type BlockContextWrite = z.infer<typeof BlockContextWriteZod>;
+/** BlockContext type. */
+export type BlockContext = z.infer<typeof BlockContextZod>;
+//# sourceMappingURL=BlockContext.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/BlockContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockContext.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/BlockContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAC3D,MAAM,uBAAuB,CAAA;AAE9B,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACpE,yBAAyB;AACzB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/BlockContext.zod.d.ts

@@ -0,0 +1,33 @@
+import type { Payload, ReadArchivist, WriteArchivist } from '@xyo-network/sdk';
+import z from 'zod';
+/** BlockContextReadZod constant. */
+export declare const BlockContextReadZod: z.ZodObject<{
+    logger: z.ZodOptional<z.ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: z.ZodRecord<z.ZodString, z.ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+    chainMap: z.ZodCustom<ReadArchivist<Payload, import("@ariestools/sdk").BrandedHash, import("@xyo-network/sdk").Sequence>, ReadArchivist<Payload, import("@ariestools/sdk").BrandedHash, import("@xyo-network/sdk").Sequence>>;
+}, z.z.core.$strip>;
+/** BlockContextWriteZod constant. */
+export declare const BlockContextWriteZod: z.ZodObject<{
+    logger: z.ZodOptional<z.ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: z.ZodRecord<z.ZodString, z.ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+    chainMap: z.ZodCustom<WriteArchivist<Payload, Payload, Payload, import("@ariestools/sdk").BrandedHash>, WriteArchivist<Payload, Payload, Payload, import("@ariestools/sdk").BrandedHash>>;
+}, z.z.core.$strip>;
+/** BlockContextZod constant. */
+export declare const BlockContextZod: z.ZodObject<{
+    logger: z.ZodOptional<z.ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodSymbol]>, z.ZodUnknown>;
+    timeBudgetLimit: z.ZodOptional<z.ZodNumber>;
+    traceProvider: z.ZodOptional<z.ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: z.ZodRecord<z.ZodString, z.ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+    chainMap: z.ZodCustom<WriteArchivist<Payload, Payload, Payload, import("@ariestools/sdk").BrandedHash>, WriteArchivist<Payload, Payload, Payload, import("@ariestools/sdk").BrandedHash>>;
+}, z.z.core.$strip>;
+//# sourceMappingURL=BlockContext.zod.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/BlockContext.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/BlockContext.zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EAAE,cAAc,EAC9B,MAAM,kBAAkB,CAAA;AACzB,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;mBAE/B,CAAA;AAED,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;mBAEhC,CAAA;AAED,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;mBAAuB,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/CachingContext.d.ts

@@ -0,0 +1,5 @@
+import type z from 'zod';
+import type { CachingContextZod } from './CachingContext.zod.js';
+/** CachingContext type. */
+export type CachingContext = z.infer<typeof CachingContextZod>;
+//# sourceMappingURL=CachingContext.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/CachingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CachingContext.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/CachingContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/CachingContext.zod.d.ts

@@ -0,0 +1,10 @@
+/** CachingContextZod constant. */
+export declare const CachingContextZod: import("zod").ZodObject<{
+    logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+}, import("zod/v4/core").$strip>;
+//# sourceMappingURL=CachingContext.zod.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/CachingContext.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CachingContext.zod.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/CachingContext.zod.ts"],"names":[],"mappings":"AAEA,kCAAkC;AAClC,eAAO,MAAM,iBAAiB;;;;;;;gCAA+C,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/ChainContext.d.ts

@@ -0,0 +1,9 @@
+import type z from 'zod';
+import type { ChainContextReadZod, ChainContextWriteZod, ChainContextZod } from './ChainContext.zod.js';
+/** ChainContextRead type. */
+export type ChainContextRead = z.infer<typeof ChainContextReadZod>;
+/** ChainContextWrite type. */
+export type ChainContextWrite = z.infer<typeof ChainContextWriteZod>;
+/** ChainContext type. */
+export type ChainContext = z.infer<typeof ChainContextZod>;
+//# sourceMappingURL=ChainContext.d.ts.map

package/dist/neutral/modules/protocol-model/model/Context/ChainContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChainContext.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/model/Context/ChainContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EACV,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAC3D,MAAM,uBAAuB,CAAA;AAE9B,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAClE,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACpE,yBAAyB;AACzB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/neutral/modules/protocol-model/model/Context/ChainContext.zod.d.ts

@@ -0,0 +1,115 @@
+/** ChainContextReadZod constant. */
+export declare const ChainContextReadZod: import("zod").ZodObject<{
+    logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+    chainMap: import("zod").ZodCustom<import("@xyo-network/sdk").ReadArchivist<import("@xyo-network/sdk-protocol").Payload, import("@ariestools/sdk").BrandedHash, import("@xyo-network/sdk-protocol").Sequence>, import("@xyo-network/sdk").ReadArchivist<import("@xyo-network/sdk-protocol").Payload, import("@ariestools/sdk").BrandedHash, import("@xyo-network/sdk-protocol").Sequence>>;
+    head: import("zod/mini").ZodMiniObject<{
+        $epoch: import("zod/mini").ZodMiniNumber<number>;
+        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../../index.js').XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+        step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+        payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
+        previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+        $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, import("zod/mini").ZodMiniNull]>>;
+        _hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        _dataHash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+/** ChainContextWriteZod constant. */
+export declare const ChainContextWriteZod: import("zod").ZodObject<{
+    logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+    chainMap: import("zod").ZodCustom<import("@xyo-network/sdk").WriteArchivist<import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@ariestools/sdk").BrandedHash>, import("@xyo-network/sdk").WriteArchivist<import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@ariestools/sdk").BrandedHash>>;
+    head: import("zod/mini").ZodMiniObject<{
+        $epoch: import("zod/mini").ZodMiniNumber<number>;
+        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../../index.js').XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+        step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+        payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
+        previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+        $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, import("zod/mini").ZodMiniNull]>>;
+        _hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        _dataHash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+/** ChainContextZod constant. */
+export declare const ChainContextZod: import("zod").ZodObject<{
+    logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@ariestools/sdk").Logger, import("@ariestools/sdk").Logger>>;
+    meterProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").MeterProvider, import("@opentelemetry/api").MeterProvider>>;
+    singletons: import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodSymbol]>, import("zod").ZodUnknown>;
+    timeBudgetLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    traceProvider: import("zod").ZodOptional<import("zod").ZodCustom<import("@opentelemetry/api").TracerProvider, import("@opentelemetry/api").TracerProvider>>;
+    caches: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodCustom<import('../../index.js').MapType<string, unknown>, import('../../index.js').MapType<string, unknown>>>;
+    chainMap: import("zod").ZodCustom<import("@xyo-network/sdk").WriteArchivist<import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@ariestools/sdk").BrandedHash>, import("@xyo-network/sdk").WriteArchivist<import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@xyo-network/sdk-protocol").Payload, import("@ariestools/sdk").BrandedHash>>;
+    head: import("zod/mini").ZodMiniObject<{
+        $epoch: import("zod/mini").ZodMiniNumber<number>;
+        block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import('../../index.js').XL1BlockNumber, number>>;
+        chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+        previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+        step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+            readonly __schema: true;
+        }>;
+        addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+        payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
+        previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+        $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+        $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+        $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>, import("zod/mini").ZodMiniNull]>>;
+        _hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+        _dataHash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+//# sourceMappingURL=ChainContext.zod.d.ts.map