@xyo-network/xl1-protocol 1.25.25 → 1.25.27

package/dist/neutral/BlockNumber/BlockNumber.d.ts

@@ -1,11 +1,16 @@
 import { type Brand } from '@xylabs/sdk-js';
 import { z } from 'zod';
+/** Branded number type representing a generic block number */
 export type BlockNumber = Brand<number, {
     readonly __blockNumber: true;
 }>;
+/** Zod schema that validates and brands a number as a BlockNumber */
 export declare const BlockNumberZod: z.ZodPipe<z.ZodNumber, z.ZodTransform<BlockNumber, number>>;
+/** Zod schema that coerces a Numberish value into a BlockNumber */
 export declare const BlockNumberishZod: 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>>;
+/** Input type for BlockNumberishZod, accepting number, string, or bigint */
 export type BlockNumberish = z.input<typeof BlockNumberishZod>;
+/** Casts a number to BlockNumber, returning undefined if validation fails */
 export declare const asBlockNumber: {
     <T>(value: T): (T & number & {
         readonly __blockNumber: true;
@@ -14,6 +19,7 @@ export declare const asBlockNumber: {
         readonly __blockNumber: true;
     };
 };
+/** Coerces a Numberish value to BlockNumber, returning undefined if conversion fails */
 export declare const toBlockNumber: {
     <T>(value: T): (T & number & {
         readonly __blockNumber: true;
@@ -22,6 +28,7 @@ export declare const toBlockNumber: {
         readonly __blockNumber: true;
     };
 };
+/** The zero block number constant */
 export declare const BLOCK_NUMBER_ZERO: (0 & {
     readonly __blockNumber: true;
 }) | undefined;

package/dist/neutral/BlockNumber/BlockNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockNumber.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/BlockNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEzE,eAAO,MAAM,cAAc,6DAA8C,CAAA;AACzE,eAAO,MAAM,iBAAiB,mMAAgD,CAAA;AAE9E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,eAAO,MAAM,aAAa;;gCAPwC,IAAI;;;gCAAJ,IAAI;;CAOiB,CAAA;AACvF,eAAO,MAAM,aAAa;;gCARwC,IAAI;;;gCAAJ,IAAI;;CAQoB,CAAA;AAE1F,eAAO,MAAM,iBAAiB;4BAVoC,IAAI;cAUrB,CAAA"}
+{"version":3,"file":"BlockNumber.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/BlockNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,8DAA8D;AAC9D,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEzE,qEAAqE;AACrE,eAAO,MAAM,cAAc,6DAA8C,CAAA;AACzE,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,mMAAgD,CAAA;AAE9E,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,6EAA6E;AAC7E,eAAO,MAAM,aAAa;;gCAXwC,IAAI;;;gCAAJ,IAAI;;CAWiB,CAAA;AACvF,wFAAwF;AACxF,eAAO,MAAM,aAAa;;gCAbwC,IAAI;;;gCAAJ,IAAI;;CAaoB,CAAA;AAE1F,qCAAqC;AACrC,eAAO,MAAM,iBAAiB;4BAhBoC,IAAI;cAgBrB,CAAA"}

package/dist/neutral/BlockNumber/EthBlockNumber.d.ts

@@ -1,12 +1,17 @@
 import { type Brand } from '@xylabs/sdk-js';
 import { z } from 'zod';
 import type { BlockNumber } from './BlockNumber.ts';
+/** Branded type representing a block number on the Ethereum chain */
 export type EthBlockNumber = Brand<BlockNumber, {
     readonly __ethBlockNumber: true;
 }>;
+/** Zod schema that validates and brands a number as an EthBlockNumber */
 export declare const EthBlockNumberZod: z.ZodPipe<z.ZodNumber, z.ZodTransform<EthBlockNumber, number>>;
+/** Zod schema that coerces a Numberish value into an EthBlockNumber */
 export declare const EthBlockNumberishZod: z.ZodPipe<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.ZodTransform<EthBlockNumber, BlockNumber>>;
+/** Input type for EthBlockNumberishZod, accepting number, string, or bigint */
 export type EthBlockNumberish = z.input<typeof EthBlockNumberishZod>;
+/** Casts a number to EthBlockNumber, returning undefined if validation fails */
 export declare const asEthBlockNumber: {
     <T>(value: T): (T & number & {
         readonly __blockNumber: true;
@@ -19,6 +24,7 @@ export declare const asEthBlockNumber: {
         readonly __ethBlockNumber: true;
     };
 };
+/** Coerces a Numberish value to EthBlockNumber, returning undefined if conversion fails */
 export declare const toEthBlockNumber: {
     <T>(value: T): (T & number & {
         readonly __blockNumber: true;
@@ -31,6 +37,7 @@ export declare const toEthBlockNumber: {
         readonly __ethBlockNumber: true;
     };
 };
+/** The zero block number constant for the Ethereum chain */
 export declare const ETH_BLOCK_NUMBER_ZERO: (0 & {
     readonly __blockNumber: true;
 } & {

package/dist/neutral/BlockNumber/EthBlockNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EthBlockNumber.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/EthBlockNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,WAAW,EAAE;IAAE,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpF,eAAO,MAAM,iBAAiB,gEAAiD,CAAA;AAC/E,eAAO,MAAM,oBAAoB,2PAAwD,CAAA;AAEzF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,eAAO,MAAM,gBAAgB;;;;mCAPgD,IAAI;;;;;mCAAJ,IAAI;;CAOkB,CAAA;AACnG,eAAO,MAAM,gBAAgB;;;;mCARgD,IAAI;;;;;mCAAJ,IAAI;;CAQqB,CAAA;AAEtG,eAAO,MAAM,qBAAqB;;;+BAV2C,IAAI;cAUzB,CAAA"}
+{"version":3,"file":"EthBlockNumber.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/EthBlockNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,qEAAqE;AACrE,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,WAAW,EAAE;IAAE,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpF,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,gEAAiD,CAAA;AAC/E,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,2PAAwD,CAAA;AAEzF,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,gFAAgF;AAChF,eAAO,MAAM,gBAAgB;;;;mCAXgD,IAAI;;;;;mCAAJ,IAAI;;CAWkB,CAAA;AACnG,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB;;;;mCAbgD,IAAI;;;;;mCAAJ,IAAI;;CAaqB,CAAA;AAEtG,4DAA4D;AAC5D,eAAO,MAAM,qBAAqB;;;+BAhB2C,IAAI;cAgBzB,CAAA"}

package/dist/neutral/BlockNumber/Numberish.d.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+/** Zod schema that accepts number, string, or bigint and coerces to number */
 export declare const NumberishZod: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBigInt]>, z.ZodTransform<number, string | number | bigint>>, z.ZodNumber>;
+/** A value that can be coerced to a number: number, string, or bigint */
 export type Numberish = z.input<typeof NumberishZod>;
 //# sourceMappingURL=Numberish.d.ts.map

package/dist/neutral/BlockNumber/Numberish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Numberish.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/Numberish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY,mJAEN,CAAA;AAEnB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"Numberish.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/Numberish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,8EAA8E;AAC9E,eAAO,MAAM,YAAY,mJAEN,CAAA;AAEnB,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/neutral/BlockNumber/XL1BlockNumber.d.ts

@@ -1,12 +1,17 @@
 import { type Brand } from '@xylabs/sdk-js';
 import { z } from 'zod';
 import type { BlockNumber } from './BlockNumber.ts';
+/** Branded type representing a block number on the XL1 chain */
 export type XL1BlockNumber = Brand<BlockNumber, {
     readonly __xl1BlockNumber: true;
 }>;
+/** Zod schema that validates and brands a number as an XL1BlockNumber */
 export declare const XL1BlockNumberZod: z.ZodPipe<z.ZodNumber, z.ZodTransform<XL1BlockNumber, number>>;
+/** Zod schema that coerces a Numberish value into an XL1BlockNumber */
 export declare const XL1BlockNumberishZod: z.ZodPipe<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.ZodTransform<XL1BlockNumber, BlockNumber>>;
+/** Input type for XL1BlockNumberishZod, accepting number, string, or bigint */
 export type XL1BlockNumberish = z.input<typeof XL1BlockNumberishZod>;
+/** Casts a number to XL1BlockNumber, returning undefined if validation fails */
 export declare const asXL1BlockNumber: {
     <T>(value: T): (T & number & {
         readonly __blockNumber: true;
@@ -19,6 +24,7 @@ export declare const asXL1BlockNumber: {
         readonly __xl1BlockNumber: true;
     };
 };
+/** Coerces a Numberish value to XL1BlockNumber, returning undefined if conversion fails */
 export declare const toXL1BlockNumber: {
     <T>(value: T): (T & number & {
         readonly __blockNumber: true;
@@ -31,6 +37,7 @@ export declare const toXL1BlockNumber: {
         readonly __xl1BlockNumber: true;
     };
 };
+/** The zero block number constant for the XL1 chain */
 export declare const XL1_BLOCK_NUMBER_ZERO: (0 & {
     readonly __blockNumber: true;
 } & {

package/dist/neutral/BlockNumber/XL1BlockNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XL1BlockNumber.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/XL1BlockNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,WAAW,EAAE;IAAE,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpF,eAAO,MAAM,iBAAiB,gEAAiD,CAAA;AAC/E,eAAO,MAAM,oBAAoB,2PAAwD,CAAA;AAEzF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,eAAO,MAAM,gBAAgB;;;;mCAPgD,IAAI;;;;;mCAAJ,IAAI;;CAOkB,CAAA;AACnG,eAAO,MAAM,gBAAgB;;;;mCARgD,IAAI;;;;;mCAAJ,IAAI;;CAQqB,CAAA;AAEtG,eAAO,MAAM,qBAAqB;;;+BAV2C,IAAI;cAUzB,CAAA"}
+{"version":3,"file":"XL1BlockNumber.d.ts","sourceRoot":"","sources":["../../../src/BlockNumber/XL1BlockNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,gEAAgE;AAChE,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,WAAW,EAAE;IAAE,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpF,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,gEAAiD,CAAA;AAC/E,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,2PAAwD,CAAA;AAEzF,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,gFAAgF;AAChF,eAAO,MAAM,gBAAgB;;;;mCAXgD,IAAI;;;;;mCAAJ,IAAI;;CAWkB,CAAA;AACnG,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB;;;;mCAbgD,IAAI;;;;;mCAAJ,IAAI;;CAaqB,CAAA;AAEtG,uDAAuD;AACvD,eAAO,MAAM,qBAAqB;;;+BAhB2C,IAAI;cAgBzB,CAAA"}

package/dist/neutral/Initializable.d.ts

@@ -4,5 +4,6 @@ export type InitializableParams<T extends EmptyObject = {}> = T & {
     logger?: Logger;
 };
 /** @deprecated */
+/** Initializable type. */
 export type Initializable<T extends EmptyObject, R> = (params: InitializableParams<T>) => Promisable<R>;
 //# sourceMappingURL=Initializable.d.ts.map

package/dist/neutral/Initializable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Initializable.d.ts","sourceRoot":"","sources":["../../src/Initializable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAAE,MAAM,EAAE,UAAU,EAChC,MAAM,gBAAgB,CAAA;AAEvB,kBAAkB;AAClB,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,WAAW,GAAG,EAAE,IAAI,CAAC,GAAG;IAChE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,kBAAkB;AAElB,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"Initializable.d.ts","sourceRoot":"","sources":["../../src/Initializable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAAE,MAAM,EAAE,UAAU,EAChC,MAAM,gBAAgB,CAAA;AAEvB,kBAAkB;AAClB,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,WAAW,GAAG,EAAE,IAAI,CAAC,GAAG;IAChE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,kBAAkB;AAElB,0BAA0B;AAC1B,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA"}

package/dist/neutral/OpenTelemetryProviders.d.ts

@@ -1,4 +1,5 @@
 import type { MeterProvider, TracerProvider } from '@opentelemetry/api';
+/** Configuration for OpenTelemetry metric and trace providers */
 export interface OpenTelemetryProviders {
     meterProvider?: MeterProvider;
     traceProvider?: TracerProvider;

package/dist/neutral/OpenTelemetryProviders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenTelemetryProviders.d.ts","sourceRoot":"","sources":["../../src/OpenTelemetryProviders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEvE,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,aAAa,CAAC,EAAE,cAAc,CAAA;CAC/B"}
+{"version":3,"file":"OpenTelemetryProviders.d.ts","sourceRoot":"","sources":["../../src/OpenTelemetryProviders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEvE,iEAAiE;AACjE,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,aAAa,CAAC,EAAE,cAAc,CAAA;CAC/B"}

package/dist/neutral/RecordKeyType.d.ts

@@ -1,2 +1,4 @@
+/** Utility type that constrains T to valid record key types (string, number, or symbol) */
+/** RecordKeyType type. */
 export type RecordKeyType<T = keyof any> = T extends keyof any ? T : never;
 //# sourceMappingURL=RecordKeyType.d.ts.map

package/dist/neutral/RecordKeyType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordKeyType.d.ts","sourceRoot":"","sources":["../../src/RecordKeyType.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,KAAK,CAAA"}
+{"version":3,"file":"RecordKeyType.d.ts","sourceRoot":"","sources":["../../src/RecordKeyType.ts"],"names":[],"mappings":"AACA,2FAA2F;AAE3F,0BAA0B;AAC1B,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,KAAK,CAAA"}

package/dist/neutral/Step/StepHash.d.ts

@@ -1,8 +1,10 @@
 import type { Brand, Hash } from '@xylabs/sdk-js';
+/** A block hash paired with its step index */
 export interface StepHash {
     block: Hash;
     step: number;
 }
+/** Branded string representing a hash and step index separated by a pipe character */
 export type StepHashString = Brand<string, {
     readonly __stepHashString: true;
 }>;

package/dist/neutral/Step/StepHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepHash.d.ts","sourceRoot":"","sources":["../../../src/Step/StepHash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAEjD,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,IAAI,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb;AAGD,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}
+{"version":3,"file":"StepHash.d.ts","sourceRoot":"","sources":["../../../src/Step/StepHash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAEjD,8CAA8C;AAC9C,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,IAAI,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb;AAED,sFAAsF;AACtF,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA"}

package/dist/neutral/Step/StepIdentity.d.ts

@@ -1,15 +1,19 @@
 import { type Brand } from '@xylabs/sdk-js';
 import { z } from 'zod';
+/** Zod schema for a step identity combining a block number and step index */
 export declare const StepIdentityZod: z.ZodObject<{
     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../BlockNumber/XL1BlockNumber.ts").XL1BlockNumber, number>>;
     step: z.ZodNumber;
 }, z.core.$strip>;
+/** Identifies a specific step by its block number and step index */
 export type StepIdentity = z.infer<typeof StepIdentityZod>;
 /** @deprecated use StepIdentity instead */
 export interface StepContext extends StepIdentity {
 }
+/** Branded string representing a block number and step index separated by a pipe character */
 export type StepIdentityString = Brand<string, {
     readonly __stepIdentityString: true;
 }>;
+/** Parses a pipe-separated string into a StepIdentity, returning undefined if invalid */
 export declare const asStepIdentity: (stepIdentityString: string) => StepIdentity | undefined;
 //# sourceMappingURL=StepIdentity.d.ts.map

package/dist/neutral/Step/StepIdentity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../src/Step/StepIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,eAAe;;;iBAG1B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,2CAA2C;AAC3C,MAAM,WAAW,WAAY,SAAQ,YAAY;CAAG;AAGpD,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,oBAAoB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAWvF,eAAO,MAAM,cAAc,GAAI,oBAAoB,MAAM,KAAG,YAAY,GAAG,SAgB1E,CAAA"}
+{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../src/Step/StepIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,6EAA6E;AAC7E,eAAO,MAAM,eAAe;;;iBAG1B,CAAA;AACF,oEAAoE;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,2CAA2C;AAC3C,MAAM,WAAW,WAAY,SAAQ,YAAY;CAAG;AAEpD,8FAA8F;AAC9F,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,oBAAoB,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAWvF,yFAAyF;AACzF,eAAO,MAAM,cAAc,GAAI,oBAAoB,MAAM,KAAG,YAAY,GAAG,SAgB1E,CAAA"}

package/dist/neutral/Step/StepSizes.d.ts

@@ -1,7 +1,12 @@
 import { type XL1BlockNumber } from '../BlockNumber/index.ts';
+/** Array of step sizes based on primorial(n+2) + 1, defining the block intervals for each step level */
 export declare const StepSizes: XL1BlockNumber[];
+/** Type guard that checks if a value is a valid step index within the StepSizes array */
 export declare function isValidStep(step: unknown): step is number;
+/** Casts a value to a valid step index, returning undefined if invalid */
 export declare const asValidStep: import("@xylabs/sdk-js").AsTypeFunction<number>;
+/** Returns the block interval size for a given step index */
 export declare function stepSize(step: number): number;
+/** Fraction of block rewards allocated at each step level, expressed as [numerator, denominator] pairs */
 export declare const StepRewardFractions: readonly [readonly [0n, 1n], readonly [0n, 1n], readonly [0n, 1n], readonly [1n, 10000n], readonly [2n, 1000n], readonly [3n, 100n], readonly [45n, 100n]];
 //# sourceMappingURL=StepSizes.d.ts.map

package/dist/neutral/Step/StepSizes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepSizes.d.ts","sourceRoot":"","sources":["../../../src/Step/StepSizes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAK/E,eAAO,MAAM,SAAS,EAAE,cAAc,EAUrC,CAAA;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAKzD;AAED,eAAO,MAAM,WAAW,iDAA4C,CAAA;AAEpE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED,eAAO,MAAM,mBAAmB,4JAQtB,CAAA"}
+{"version":3,"file":"StepSizes.d.ts","sourceRoot":"","sources":["../../../src/Step/StepSizes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAK/E,wGAAwG;AACxG,eAAO,MAAM,SAAS,EAAE,cAAc,EAUrC,CAAA;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAKzD;AAED,0EAA0E;AAC1E,eAAO,MAAM,WAAW,iDAA4C,CAAA;AAEpE,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED,0GAA0G;AAC1G,eAAO,MAAM,mBAAmB,4JAQtB,CAAA"}

package/dist/neutral/TransferPayload.d.ts

@@ -1,8 +1,11 @@
 import { z } from 'zod';
+/** Schema identifier for XYO transfer payloads */
 export declare const TransferSchema: "network.xyo.transfer" & {
     readonly __schema: true;
 };
+/** The literal type of the transfer schema string */
 export type TransferSchema = typeof TransferSchema;
+/** Zod schema for the fields specific to a transfer payload */
 export declare const TransferFieldsZod: z.ZodObject<{
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     epoch: z.ZodNumber;
@@ -17,6 +20,7 @@ export declare const TransferFieldsZod: z.ZodObject<{
         readonly __address: true;
     }, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
 }, z.core.$strip>;
+/** Zod schema for a complete transfer payload including schema and fields */
 export declare const TransferZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.transfer" & {
         readonly __schema: true;
@@ -34,7 +38,9 @@ export declare const TransferZod: z.ZodObject<{
         readonly __address: true;
     }, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
 }, z.core.$strip>;
+/** A transfer payload representing the movement of XL1 tokens between addresses */
 export type Transfer = z.infer<typeof TransferZod>;
+/** Type guard that checks if a value is a Transfer payload */
 export declare const isTransfer: (x?: unknown | null) => x is {
     schema: "network.xyo.transfer" & {
         readonly __schema: true;
@@ -52,6 +58,7 @@ export declare const isTransfer: (x?: unknown | null) => x is {
     }, import("@xylabs/sdk-js").BrandedHex>;
     context?: Record<string, unknown> | undefined;
 };
+/** Casts a value to Transfer or returns undefined if invalid */
 export declare const asTransfer: import("@xylabs/sdk-js").AsTypeFunction<{
     schema: "network.xyo.transfer" & {
         readonly __schema: true;

package/dist/neutral/TransferPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransferPayload.d.ts","sourceRoot":"","sources":["../../src/TransferPayload.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc;;CAAyC,CAAA;AACpE,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAO5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;iBAAqE,CAAA;AAE7F,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAElD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;CAAkD,CAAA;AAEzE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;EAAqC,CAAA"}
+{"version":3,"file":"TransferPayload.d.ts","sourceRoot":"","sources":["../../src/TransferPayload.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,kDAAkD;AAClD,eAAO,MAAM,cAAc;;CAAyC,CAAA;AACpE,qDAAqD;AACrD,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAA;AAElD,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAO5B,CAAA;AAEF,6EAA6E;AAC7E,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;iBAAqE,CAAA;AAE7F,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAElD,8DAA8D;AAC9D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;CAAkD,CAAA;AAEzE,gEAAgE;AAChE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;EAAqC,CAAA"}

package/dist/neutral/amount/ShiftedBigIntConfig.d.ts

@@ -1,3 +1,4 @@
+/** Configuration for formatting a ShiftedBigInt as a decimal string */
 export interface ShiftedBigIntConfig {
     locale: Intl.LocalesArgument;
     maxCharacters: number;

package/dist/neutral/amount/ShiftedBigIntConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShiftedBigIntConfig.d.ts","sourceRoot":"","sources":["../../../src/amount/ShiftedBigIntConfig.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,IAAI,CAAC,eAAe,CAAA;IAC5B,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACf"}
+{"version":3,"file":"ShiftedBigIntConfig.d.ts","sourceRoot":"","sources":["../../../src/amount/ShiftedBigIntConfig.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,IAAI,CAAC,eAAe,CAAA;IAC5B,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACf"}

package/dist/neutral/amount/XL1AmountInstance.d.ts

@@ -0,0 +1,16 @@
+import type { AttoXL1, FemtoXL1, MicroXL1, MilliXL1, NanoXL1, PicoXL1, XL1 } from '../xl1/index.ts';
+import type { ShiftedBigIntConfig } from './ShiftedBigIntConfig.ts';
+/** Interface for an XL1 token amount with conversion accessors for various denominations */
+export interface XL1AmountInstance {
+    atto: AttoXL1;
+    femto: FemtoXL1;
+    micro: MicroXL1;
+    milli: MilliXL1;
+    nano: NanoXL1;
+    pico: PicoXL1;
+    value: AttoXL1;
+    xl1: XL1;
+    to(places: bigint | number): bigint;
+    toString(places: number, config: Partial<ShiftedBigIntConfig>): string;
+}
+//# sourceMappingURL=XL1AmountInstance.d.ts.map

package/dist/neutral/amount/XL1AmountInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XL1AmountInstance.d.ts","sourceRoot":"","sources":["../../../src/amount/XL1AmountInstance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAC7D,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnE,4FAA4F;AAC5F,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,QAAQ,CAAA;IACf,KAAK,EAAE,QAAQ,CAAA;IACf,KAAK,EAAE,QAAQ,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,GAAG,EAAE,GAAG,CAAA;IAER,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,MAAM,CAAA;CACvE"}

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

@@ -1,5 +1,3 @@
-export * from './ShiftedBigInt.ts';
-export * from './splitOnDecimal.ts';
-export * from './splitOnDecimalToString.ts';
-export * from './XL1Amount.ts';
+export * from './ShiftedBigIntConfig.ts';
+export * from './XL1AmountInstance.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/amount/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/amount/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA"}

package/dist/neutral/block/AllowedBlockPayload.d.ts

@@ -3,7 +3,9 @@ import { z } from 'zod';
 import type { BridgeDestinationObservation, BridgeIntent, BridgeSourceObservation, ChainStakeIntent, HashPayload, StepComplete, TimePayload } from '../payload/index.ts';
 import { type TransactionBoundWitness } from '../transaction/index.ts';
 import { type Transfer } from '../TransferPayload.ts';
+/** AllowedBlockPayload type. */
 export type AllowedBlockPayload = BridgeDestinationObservation | BridgeIntent | BridgeSourceObservation | ChainStakeIntent | HashPayload | SchemaPayload | StepComplete | TimePayload | TransactionBoundWitness | Transfer;
+/** AllowedBlockPayloadSchemas constant. */
 export declare const AllowedBlockPayloadSchemas: (("network.xyo.chain.bridge.observation.destination" & {
     readonly __schema: true;
 }) | ("network.xyo.chain.bridge.intent" & {
@@ -25,9 +27,14 @@ export declare const AllowedBlockPayloadSchemas: (("network.xyo.chain.bridge.obs
 }) | ("network.xyo.boundwitness" & {
     readonly __schema: true;
 }))[];
+/** AllowedBlockPayloadSchemaZod constant. */
 export declare const AllowedBlockPayloadSchemaZod: z.ZodEnum<{}>;
+/** Schema type for AllowedBlockPayload payloads. */
 export type AllowedBlockPayloadSchema = z.infer<typeof AllowedBlockPayloadSchemaZod>;
+/** Schema identifier for isAllowedBlockPayload payloads. */
 export declare const isAllowedBlockPayloadSchema: <T>(value: T) => value is T;
+/** Type guard that checks if a value is a valid AllowedBlockPayload. */
 export declare const isAllowedBlockPayload: <T>(value: T) => value is AllowedBlockPayload & T;
+/** Type guard that checks if a value is a valid AllowedBlockPayloadWithHashMeta. */
 export declare const isAllowedBlockPayloadWithHashMeta: <T>(value: T) => value is WithStorageMeta<AllowedBlockPayload & T>;
 //# sourceMappingURL=AllowedBlockPayload.d.ts.map

package/dist/neutral/block/AllowedBlockPayload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AllowedBlockPayload.d.ts","sourceRoot":"","sources":["../../../src/block/AllowedBlockPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACF,aAAa,EAAE,eAAe,EACvC,MAAM,qBAAqB,CAAA;AAI5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,4BAA4B,EAAE,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAC9H,MAAM,qBAAqB,CAAA;AAM5B,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AACjG,OAAO,EACO,KAAK,QAAQ,EAC1B,MAAM,uBAAuB,CAAA;AAE9B,MAAM,MAAM,mBAAmB,GACzB,4BAA4B,GAC5B,YAAY,GACZ,uBAAuB,GACvB,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,uBAAuB,GACvB,QAAQ,CAAA;AAEd,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;KAWnB,CAAA;AAEpB,eAAO,MAAM,4BAA4B,eAAqC,CAAA;AAC9E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,eAAO,MAAM,2BAA2B,6BAA6C,CAAA;AAErF,eAAO,MAAM,qBAAqB,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,mBAAmB,GAAG,CAUlF,CAAA;AAED,eAAO,MAAM,iCAAiC,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,eAAe,CAAC,mBAAmB,GAAG,CAAC,CAE/G,CAAA"}
+{"version":3,"file":"AllowedBlockPayload.d.ts","sourceRoot":"","sources":["../../../src/block/AllowedBlockPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACF,aAAa,EAAE,eAAe,EACvC,MAAM,qBAAqB,CAAA;AAI5B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EACV,4BAA4B,EAAE,YAAY,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAC9H,MAAM,qBAAqB,CAAA;AAM5B,OAAO,EAA6B,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AACjG,OAAO,EACO,KAAK,QAAQ,EAC1B,MAAM,uBAAuB,CAAA;AAE9B,gCAAgC;AAChC,MAAM,MAAM,mBAAmB,GACzB,4BAA4B,GAC5B,YAAY,GACZ,uBAAuB,GACvB,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,uBAAuB,GACvB,QAAQ,CAAA;AAEd,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;KAWnB,CAAA;AAEpB,6CAA6C;AAC7C,eAAO,MAAM,4BAA4B,eAAqC,CAAA;AAC9E,oDAAoD;AACpD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACpF,4DAA4D;AAC5D,eAAO,MAAM,2BAA2B,6BAA6C,CAAA;AAErF,wEAAwE;AACxE,eAAO,MAAM,qBAAqB,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,mBAAmB,GAAG,CAUlF,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,iCAAiC,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,eAAe,CAAC,mBAAmB,GAAG,CAAC,CAE/G,CAAA"}

package/dist/neutral/block/BlockBoundWitness.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+/** BlockBoundWitnessFieldsZod constant. */
 export declare const BlockBoundWitnessFieldsZod: z.ZodObject<{
     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../BlockNumber/XL1BlockNumber.ts").XL1BlockNumber, number>>;
     chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
@@ -6,9 +7,11 @@ export declare const BlockBoundWitnessFieldsZod: z.ZodObject<{
     protocol: z.ZodOptional<z.ZodNumber>;
     step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
 }, z.core.$strip>;
+/** BlockBoundWitnessMetaZod constant. */
 export declare const BlockBoundWitnessMetaZod: z.ZodObject<{
     $epoch: z.ZodNumber;
 }, z.core.$strip>;
+/** BlockBoundWitnessZod constant. */
 export declare const BlockBoundWitnessZod: z.ZodObject<{
     $epoch: z.ZodNumber;
     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../BlockNumber/XL1BlockNumber.ts").XL1BlockNumber, number>>;
@@ -35,7 +38,9 @@ export declare const BlockBoundWitnessZod: z.ZodObject<{
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodNull]>>;
 }, z.core.$strip>;
+/** BlockBoundWitness type. */
 export type BlockBoundWitness = z.infer<typeof BlockBoundWitnessZod>;
+/** Type guard that checks if a value is a valid BlockBoundWitness. */
 export declare const isBlockBoundWitness: <T>(value: T) => value is T & {
     $epoch: number;
     block: import("../BlockNumber/XL1BlockNumber.ts").XL1BlockNumber;
@@ -62,6 +67,7 @@ export declare const isBlockBoundWitness: <T>(value: T) => value is T & {
     }) | undefined;
     $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
 };
+/** Converts a value to BlockBoundWitness, throwing if invalid. */
 export declare const asBlockBoundWitness: {
     <T>(value: T): (T & {
         $epoch: number;
@@ -116,6 +122,7 @@ export declare const asBlockBoundWitness: {
         $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
     };
 };
+/** toBlockBoundWitness constant. */
 export declare const toBlockBoundWitness: {
     <T>(value: T): (T & {
         $epoch: number;
@@ -200,7 +207,9 @@ export declare const BlockBoundWitnessWithHashMetaZod: z.ZodObject<{
     _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
 }, z.core.$strip>;
 /** @deprecated use WithHashMeta(BlockBoundWitness) instead */
+/** BlockBoundWitnessWithHashMeta type. */
 export type BlockBoundWitnessWithHashMeta = z.infer<typeof BlockBoundWitnessWithHashMetaZod>;
+/** Type guard that checks if a value is a valid BlockBoundWitnessWithHashMeta. */
 export declare const isBlockBoundWitnessWithHashMeta: <T>(value: T) => value is T & {
     $epoch: number;
     block: import("../BlockNumber/XL1BlockNumber.ts").XL1BlockNumber;
@@ -229,6 +238,7 @@ export declare const isBlockBoundWitnessWithHashMeta: <T>(value: T) => value is
     }) | undefined;
     $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
 };
+/** Converts a value to BlockBoundWitnessWithHashMeta, throwing if invalid. */
 export declare const asBlockBoundWitnessWithHashMeta: {
     <T>(value: T): (T & {
         $epoch: number;
@@ -287,6 +297,7 @@ export declare const asBlockBoundWitnessWithHashMeta: {
         $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
     };
 };
+/** toBlockBoundWitnessWithHashMeta constant. */
 export declare const toBlockBoundWitnessWithHashMeta: {
     <T>(value: T): (T & {
         $epoch: number;
@@ -376,7 +387,9 @@ export declare const BlockBoundWitnessWithStorageMetaZod: z.ZodObject<{
     _sequence: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").QualifiedSequence, string>>]>;
 }, z.core.$strip>;
 /** @deprecated use WithStorageMeta(BlockBoundWitness) instead */
+/** BlockBoundWitnessWithStorageMeta type. */
 export type BlockBoundWitnessWithStorageMeta = z.infer<typeof BlockBoundWitnessWithStorageMetaZod>;
+/** Type guard that checks if a value is a valid BlockBoundWitnessWithStorageMeta. */
 export declare const isBlockBoundWitnessWithStorageMeta: <T>(value: T) => value is T & {
     $epoch: number;
     block: import("../BlockNumber/XL1BlockNumber.ts").XL1BlockNumber;
@@ -406,6 +419,7 @@ export declare const isBlockBoundWitnessWithStorageMeta: <T>(value: T) => value
     }) | undefined;
     $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
 };
+/** Converts a value to BlockBoundWitnessWithStorageMeta, throwing if invalid. */
 export declare const asBlockBoundWitnessWithStorageMeta: {
     <T>(value: T): (T & {
         $epoch: number;
@@ -466,6 +480,7 @@ export declare const asBlockBoundWitnessWithStorageMeta: {
         $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
     };
 };
+/** toBlockBoundWitnessWithStorageMeta constant. */
 export declare const toBlockBoundWitnessWithStorageMeta: {
     <T>(value: T): (T & {
         $epoch: number;

package/dist/neutral/block/BlockBoundWitness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../src/block/BlockBoundWitness.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;iBAAmC,CAAA;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/B,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAE5F,oEAAoE;AACpE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwC,CAAA;AAErF,8DAA8D;AAE9D,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE5F,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAClG,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyF,CAAA;AACrI,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyF,CAAA;AAErI,uEAAuE;AACvE,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2C,CAAA;AAE3F,iEAAiE;AAEjE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAElG,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyD,CAAA;AACxG,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+F,CAAA;AAC9I,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+F,CAAA"}
+{"version":3,"file":"BlockBoundWitness.d.ts","sourceRoot":"","sources":["../../../src/block/BlockBoundWitness.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAA;AAEF,yCAAyC;AACzC,eAAO,MAAM,wBAAwB;;iBAAmC,CAAA;AAExE,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/B,CAAA;AAEF,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,kEAAkE;AAClE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAE5F,oEAAoE;AACpE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwC,CAAA;AAErF,8DAA8D;AAE9D,0CAA0C;AAC1C,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE5F,kFAAkF;AAClF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAClG,8EAA8E;AAC9E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyF,CAAA;AACrI,gDAAgD;AAChD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyF,CAAA;AAErI,uEAAuE;AACvE,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2C,CAAA;AAE3F,iEAAiE;AAEjE,6CAA6C;AAC7C,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAElG,qFAAqF;AACrF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyD,CAAA;AACxG,iFAAiF;AACjF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+F,CAAA;AAC9I,mDAAmD;AACnD,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+F,CAAA"}