@xyo-network/xl1-protocol-sdk 1.26.43 → 1.26.46

package/dist/neutral/CreatableProvider/AbstractCreatableProvider.d.ts

@@ -32,7 +32,7 @@ export declare abstract class AbstractCreatableProvider<TParams extends Creatabl
             } | undefined;
         };
         log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+            logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
             silent: boolean;
         };
         providers: {

package/dist/neutral/block/hydrate/BoundWitnessHydrator.d.ts

@@ -0,0 +1,57 @@
+import type { Hash } from '@xylabs/sdk-js';
+import type { BoundWitness, Payload } from '@xyo-network/sdk-js';
+import type { DataLakeViewerMethods } from '@xyo-network/xl1-protocol-lib';
+import { LRUCache } from 'lru-cache';
+import type { HydrateFunction } from '../../utils/index.ts';
+/** Valid recursion depths for BoundWitness hydration. */
+export type HydrationDepth = 0 | 1 | 2;
+/** A datalake registered with a caller-supplied name for provenance tracking. */
+export interface NamedDataLake {
+    name: string;
+    viewer: DataLakeViewerMethods;
+}
+/** A function that validates and narrows an unknown value into a typed BoundWitness or hydrated tuple. */
+export type ZodAsserter<T> = (value: unknown, assert: true) => T;
+/** Parameters for BoundWitnessHydrator. */
+export interface BoundWitnessHydratorParams<TBw extends BoundWitness, THydrated> {
+    asBoundWitness: ZodAsserter<TBw>;
+    asHydrated: ZodAsserter<THydrated>;
+    cacheMax?: number;
+    cacheTtl?: number;
+    datalakes: readonly NamedDataLake[];
+    /** Predicate used at maxDepth >= 2 to identify payloads that are themselves BoundWitnesses to recurse into. Defaults to isBoundWitness. */
+    isNestedBoundWitness?: (payload: Payload) => payload is BoundWitness;
+}
+/**
+ * Hydrates a BoundWitness (and its referenced payloads) from one or more datalakes,
+ * tracking which datalake served each hash. Supports depth-2 recursion into nested BoundWitnesses.
+ */
+export declare class BoundWitnessHydrator<TBw extends BoundWitness, THydrated> {
+    protected readonly asBoundWitness: ZodAsserter<TBw>;
+    protected readonly asHydrated: ZodAsserter<THydrated>;
+    protected readonly datalakes: readonly NamedDataLake[];
+    protected readonly isNestedBoundWitness: (payload: Payload) => payload is BoundWitness;
+    protected readonly payloadCache: LRUCache<Hash, Payload>;
+    protected readonly sourceCache: LRUCache<Hash, string>;
+    /**
+     * @throws if `params.datalakes` is empty. Required at construction to fail fast on misconfig.
+     *   The only zero-datalake hydrate calls that would succeed anyway are degenerate (maxDepth=0
+     *   or a BW with empty payload_hashes) — not load-bearing enough to justify loosening the guard.
+     *   If lifecycle ordering ever requires construction before sources are wired, prefer adding
+     *   an `addDatalake()` mutator over removing this assertion.
+     */
+    constructor(params: BoundWitnessHydratorParams<TBw, THydrated>);
+    hydrate(input: Hash | TBw, maxDepth?: HydrationDepth, minDepth?: HydrationDepth): Promise<THydrated>;
+    hydrateWithProvenance(input: Hash | TBw, maxDepth?: HydrationDepth, minDepth?: HydrationDepth): Promise<[THydrated, Map<Hash, string>]>;
+    /** Returns an adapter compatible with HydratedCache. The context arg is ignored. */
+    toHydrateFunction(): HydrateFunction<THydrated>;
+    tryHydrate(input: Hash | TBw, maxDepth?: HydrationDepth): Promise<THydrated | undefined>;
+    tryHydrateWithProvenance(input: Hash | TBw, maxDepth?: HydrationDepth): Promise<[THydrated, Map<Hash, string>] | undefined>;
+    protected appendDirectPayloads(bw: TBw, sources: Map<Hash, string>, minDepth: HydrationDepth, orderedHashes: Set<Hash>, orderedPayloads: Payload[]): Promise<void>;
+    protected appendNestedPayloads(sources: Map<Hash, string>, minDepth: HydrationDepth, orderedHashes: Set<Hash>, orderedPayloads: Payload[]): Promise<void>;
+    protected fetchByHash(hash: Hash, sources: Map<Hash, string>): Promise<Payload | undefined>;
+    protected fetchByHashes(hashes: Hash[], sources: Map<Hash, string>): Promise<Map<Hash, Payload>>;
+    protected hydrateInternal(input: Hash | TBw, maxDepth: HydrationDepth, minDepth: HydrationDepth): Promise<[THydrated, Map<Hash, string>]>;
+    protected resolveBoundWitness(input: Hash | TBw, sources: Map<Hash, string>): Promise<TBw>;
+}
+//# sourceMappingURL=BoundWitnessHydrator.d.ts.map

package/dist/neutral/block/hydrate/BoundWitnessHydrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundWitnessHydrator.d.ts","sourceRoot":"","sources":["../../../../src/block/hydrate/BoundWitnessHydrator.ts"],"names":[],"mappings":"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"}

package/dist/neutral/block/hydrate/createBlockHydrator.d.ts

@@ -0,0 +1,6 @@
+import type { BlockBoundWitnessWithStorageMeta, HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol-lib';
+import type { BoundWitnessHydratorParams } from './BoundWitnessHydrator.ts';
+import { BoundWitnessHydrator } from './BoundWitnessHydrator.ts';
+/** Construct a BoundWitnessHydrator preconfigured to hydrate BlockBoundWitnesses. */
+export declare function createBlockHydrator(params: Omit<BoundWitnessHydratorParams<BlockBoundWitnessWithStorageMeta, HydratedBlockWithStorageMeta>, 'asBoundWitness' | 'asHydrated'>): BoundWitnessHydrator<BlockBoundWitnessWithStorageMeta, HydratedBlockWithStorageMeta>;
+//# sourceMappingURL=createBlockHydrator.d.ts.map

package/dist/neutral/block/hydrate/createBlockHydrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBlockHydrator.d.ts","sourceRoot":"","sources":["../../../../src/block/hydrate/createBlockHydrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAA;AAGnH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEhE,qFAAqF;AACrF,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,IAAI,CACV,0BAA0B,CAAC,gCAAgC,EAAE,4BAA4B,CAAC,EAC1F,gBAAgB,GAAG,YAAY,CAChC,GACA,oBAAoB,CAAC,gCAAgC,EAAE,4BAA4B,CAAC,CAMtF"}

package/dist/neutral/block/hydrate/createBoundWitnessHydrator.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+import type { BoundWitnessHydratorParams } from './BoundWitnessHydrator.ts';
+import { BoundWitnessHydrator } from './BoundWitnessHydrator.ts';
+/** A plain BoundWitness with storage meta attached. */
+export declare const BoundWitnessWithStorageMetaZod: z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness" & {
+        readonly __schema: true;
+    }>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    $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]>>;
+    _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    _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>;
+export type BoundWitnessWithStorageMeta = z.infer<typeof BoundWitnessWithStorageMetaZod>;
+export declare const asBoundWitnessWithStorageMeta: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        payload_hashes: import("@xylabs/sdk-js").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-js").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk-js").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk-js").BrandedHex | null)[];
+        _hash: import("@xylabs/sdk-js").BrandedHash;
+        _dataHash: import("@xylabs/sdk-js").BrandedHash;
+        _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & {
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        payload_hashes: import("@xylabs/sdk-js").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-js").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk-js").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk-js").BrandedHex | null)[];
+        _hash: import("@xylabs/sdk-js").BrandedHash;
+        _dataHash: import("@xylabs/sdk-js").BrandedHash;
+        _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
+    };
+};
+/** A hydrated plain BoundWitness tuple [bw, payloads] where bw and each payload have storage meta. */
+export declare const HydratedBoundWitnessWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness" & {
+        readonly __schema: true;
+    }>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    $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]>>;
+    _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    _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>, z.ZodArray<z.ZodObject<{
+    schema: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>;
+    _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>;
+    _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.$loose>>], null>;
+export type HydratedBoundWitnessWithStorageMeta = z.infer<typeof HydratedBoundWitnessWithStorageMetaZod>;
+export declare const asHydratedBoundWitnessWithStorageMeta: {
+    <T>(value: T): (T & [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        payload_hashes: import("@xylabs/sdk-js").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-js").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk-js").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk-js").BrandedHex | null)[];
+        _hash: import("@xylabs/sdk-js").BrandedHash;
+        _dataHash: import("@xylabs/sdk-js").BrandedHash;
+        _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
+    }, {
+        [x: string]: unknown;
+        schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
+        _hash: import("@xylabs/sdk-js").BrandedHash;
+        _dataHash: import("@xylabs/sdk-js").BrandedHash;
+        _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
+    }[]]) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk-js").ZodFactoryConfig): T & [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        })[];
+        payload_hashes: import("@xylabs/sdk-js").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-js").BrandedSchema<string>[];
+        previous_hashes: (import("@xylabs/sdk-js").BrandedHash | null)[];
+        $signatures: (import("@xylabs/sdk-js").BrandedHex | null)[];
+        _hash: import("@xylabs/sdk-js").BrandedHash;
+        _dataHash: import("@xylabs/sdk-js").BrandedHash;
+        _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
+        $destination?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@xylabs/sdk-js").BrandedHash | undefined;
+    }, {
+        [x: string]: unknown;
+        schema: import("@xyo-network/sdk-js").BrandedSchema<string>;
+        _hash: import("@xylabs/sdk-js").BrandedHash;
+        _dataHash: import("@xylabs/sdk-js").BrandedHash;
+        _sequence: import("@xyo-network/sdk-js").LocalSequence | import("@xyo-network/sdk-js").QualifiedSequence;
+    }[]];
+};
+/** Construct a BoundWitnessHydrator that accepts plain BoundWitnesses (any subtype). */
+export declare function createBoundWitnessHydrator(params: Omit<BoundWitnessHydratorParams<BoundWitnessWithStorageMeta, HydratedBoundWitnessWithStorageMeta>, 'asBoundWitness' | 'asHydrated'>): BoundWitnessHydrator<BoundWitnessWithStorageMeta, HydratedBoundWitnessWithStorageMeta>;
+//# sourceMappingURL=createBoundWitnessHydrator.d.ts.map

package/dist/neutral/block/hydrate/createBoundWitnessHydrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBoundWitnessHydrator.d.ts","sourceRoot":"","sources":["../../../../src/block/hydrate/createBoundWitnessHydrator.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEhE,uDAAuD;AACvD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;iBAAsC,CAAA;AACjF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AACxF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgF,CAAA;AAE1H,sGAAsG;AACtG,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGjD,CAAA;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAA;AACxG,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGjD,CAAA;AAED,wFAAwF;AACxF,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,IAAI,CACV,0BAA0B,CAAC,2BAA2B,EAAE,mCAAmC,CAAC,EAC5F,gBAAgB,GAAG,YAAY,CAChC,GACA,oBAAoB,CAAC,2BAA2B,EAAE,mCAAmC,CAAC,CAMxF"}

package/dist/neutral/block/hydrate/createTransactionHydrator.d.ts

@@ -0,0 +1,6 @@
+import type { HydratedTransactionWithStorageMeta, TransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib';
+import type { BoundWitnessHydratorParams } from './BoundWitnessHydrator.ts';
+import { BoundWitnessHydrator } from './BoundWitnessHydrator.ts';
+/** Construct a BoundWitnessHydrator preconfigured to hydrate TransactionBoundWitnesses. */
+export declare function createTransactionHydrator(params: Omit<BoundWitnessHydratorParams<TransactionBoundWitnessWithStorageMeta, HydratedTransactionWithStorageMeta>, 'asBoundWitness' | 'asHydrated'>): BoundWitnessHydrator<TransactionBoundWitnessWithStorageMeta, HydratedTransactionWithStorageMeta>;
+//# sourceMappingURL=createTransactionHydrator.d.ts.map

package/dist/neutral/block/hydrate/createTransactionHydrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTransactionHydrator.d.ts","sourceRoot":"","sources":["../../../../src/block/hydrate/createTransactionHydrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,sCAAsC,EAAE,MAAM,+BAA+B,CAAA;AAG/H,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEhE,2FAA2F;AAC3F,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,IAAI,CACV,0BAA0B,CAAC,sCAAsC,EAAE,kCAAkC,CAAC,EACtG,gBAAgB,GAAG,YAAY,CAChC,GACA,oBAAoB,CAAC,sCAAsC,EAAE,kCAAkC,CAAC,CAMlG"}

package/dist/neutral/block/hydrate/index.d.ts

@@ -1,5 +1,9 @@
 export * from './allHashesPresent.ts';
 export * from './blockPayloadsFromHydratedBlock.ts';
+export * from './BoundWitnessHydrator.ts';
+export * from './createBlockHydrator.ts';
+export * from './createBoundWitnessHydrator.ts';
+export * from './createTransactionHydrator.ts';
 export * from './flattenHydratedBlock.ts';
 export * from './flattenHydratedBlocks.ts';
 export * from './hydrateBlock.ts';

package/dist/neutral/block/hydrate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/block/hydrate/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,qCAAqC,CAAA;AACnD,cAAc,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mBAAmB,CAAA;AACjC,cAAc,oCAAoC,CAAA;AAClD,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/block/hydrate/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,qCAAqC,CAAA;AACnD,cAAc,2BAA2B,CAAA;AACzC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mBAAmB,CAAA;AACjC,cAAc,oCAAoC,CAAA;AAClD,cAAc,sBAAsB,CAAA"}

package/dist/neutral/config/Actor.d.ts

@@ -33,9 +33,9 @@ export declare const ActorConfigZod: z.ZodObject<{
     }, z.core.$strip>>;
     log: z.ZodDefault<z.ZodObject<{
         logLevel: z.ZodDefault<z.ZodEnum<{
+            info: "info";
             error: "error";
             warn: "warn";
-            info: "info";
             log: "log";
             debug: "debug";
             trace: "trace";
@@ -118,7 +118,7 @@ export declare const isActorConfig: <T>(value: T) => value is T & {
         } | undefined;
     };
     log: {
-        logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+        logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
         silent: boolean;
     };
     providers: {
@@ -198,7 +198,7 @@ export declare const asActorConfig: {
             } | undefined;
         };
         log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+            logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
             silent: boolean;
         };
         providers: {
@@ -276,7 +276,7 @@ export declare const asActorConfig: {
             } | undefined;
         };
         log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+            logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
             silent: boolean;
         };
         providers: {
@@ -357,7 +357,7 @@ export declare const toActorConfig: {
             } | undefined;
         };
         log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+            logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
             silent: boolean;
         };
         providers: {
@@ -435,7 +435,7 @@ export declare const toActorConfig: {
             } | undefined;
         };
         log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+            logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
             silent: boolean;
         };
         providers: {

package/dist/neutral/config/Actor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Actor.d.ts","sourceRoot":"","sources":["../../../src/config/Actor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,aAG1B,CAAA;AAED,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYzB,CAAA;AAEF,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AACzD,4DAA4D;AAC5D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,8BAA8B;AAC9B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA"}
+{"version":3,"file":"Actor.d.ts","sourceRoot":"","sources":["../../../src/config/Actor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,aAG1B,CAAA;AAED,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBzB,CAAA;AAEF,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AACzD,4DAA4D;AAC5D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,8BAA8B;AAC9B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA"}

package/dist/neutral/config/Actors.d.ts

@@ -22,9 +22,9 @@ export declare const ActorsConfigZod: z.ZodDefault<z.ZodArray<z.ZodObject<{
     }, z.z.core.$strip>>;
     log: z.ZodDefault<z.ZodObject<{
         logLevel: z.ZodDefault<z.ZodEnum<{
+            info: "info";
             error: "error";
             warn: "warn";
-            info: "info";
             log: "log";
             debug: "debug";
             trace: "trace";

package/dist/neutral/config/Base.d.ts

@@ -22,9 +22,9 @@ export declare const BaseConfigZod: z.ZodObject<{
     }, z.core.$strip>>;
     log: z.ZodDefault<z.ZodObject<{
         logLevel: z.ZodDefault<z.ZodEnum<{
+            info: "info";
             error: "error";
             warn: "warn";
-            info: "info";
             log: "log";
             debug: "debug";
             trace: "trace";

package/dist/neutral/config/Config.d.ts

@@ -1,4 +1,4 @@
-import type z from 'zod';
+import { z } from 'zod';
 import type { DeepPartial } from './DeepPartial.ts';
 /** ConfigZod constant. */
 export declare const ConfigZod: z.ZodObject<{
@@ -9,43 +9,43 @@ export declare const ConfigZod: z.ZodObject<{
         } & {
             readonly __address: true;
         }, string>>>;
-    }, z.z.core.$strip>>;
-    dataLake: z.ZodOptional<z.ZodType<import("./index.ts").DataLakeConfig, unknown, z.z.core.$ZodTypeInternals<import("./index.ts").DataLakeConfig, unknown>>>;
+    }, z.core.$strip>>;
+    dataLake: z.ZodOptional<z.ZodType<import("./index.ts").DataLakeConfig, unknown, z.core.$ZodTypeInternals<import("./index.ts").DataLakeConfig, unknown>>>;
     evm: z.ZodDefault<z.ZodObject<{
         chainId: z.ZodOptional<z.ZodString>;
         infura: z.ZodOptional<z.ZodObject<{
             projectId: z.ZodOptional<z.ZodString>;
             projectSecret: z.ZodOptional<z.ZodString>;
-        }, z.z.core.$strip>>;
+        }, z.core.$strip>>;
         jsonRpc: z.ZodOptional<z.ZodObject<{
             url: z.ZodOptional<z.ZodURL>;
-        }, z.z.core.$strip>>;
-    }, z.z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     log: z.ZodDefault<z.ZodObject<{
         logLevel: z.ZodDefault<z.ZodEnum<{
+            info: "info";
             error: "error";
             warn: "warn";
-            info: "info";
             log: "log";
             debug: "debug";
             trace: "trace";
         }>>;
         silent: z.ZodDefault<z.ZodBoolean>;
-    }, z.z.core.$strip>>;
+    }, z.core.$strip>>;
     providers: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
         moniker: z.ZodString;
         labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$loose>>>>;
+    }, z.core.$loose>>>>;
     remote: z.ZodDefault<z.ZodObject<{
         rpc: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             protocol: z.ZodDefault<z.ZodString>;
             url: z.ZodString;
-        }, z.z.core.$strip>, z.ZodObject<{
+        }, z.core.$strip>, z.ZodObject<{
             protocol: z.ZodDefault<z.ZodString>;
             networkId: z.ZodString;
             sessionId: z.ZodString;
-        }, z.z.core.$strip>]>>;
-    }, z.z.core.$strip>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
     storage: z.ZodDefault<z.ZodObject<{
         mongo: z.ZodOptional<z.ZodObject<{
             connectionString: z.ZodOptional<z.ZodString>;
@@ -53,20 +53,20 @@ export declare const ConfigZod: z.ZodObject<{
             domain: z.ZodOptional<z.ZodString>;
             password: z.ZodOptional<z.ZodString>;
             username: z.ZodOptional<z.ZodString>;
-        }, z.z.core.$strip>>;
+        }, z.core.$strip>>;
         root: z.ZodOptional<z.ZodString>;
-    }, z.z.core.$strip>>;
+    }, z.core.$strip>>;
     telemetry: z.ZodDefault<z.ZodObject<{
         metrics: z.ZodOptional<z.ZodObject<{
             scrape: z.ZodObject<{
                 path: z.ZodDefault<z.ZodString>;
-                port: z.ZodOptional<z.z.ZodCoercedNumber<unknown>>;
-            }, z.z.core.$strip>;
-        }, z.z.core.$strip>>;
+                port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
         otel: z.ZodOptional<z.ZodObject<{
             otlpEndpoint: z.ZodOptional<z.ZodURL>;
-        }, z.z.core.$strip>>;
-    }, z.z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     validation: z.ZodDefault<z.ZodObject<{
         allowedRewardRedeemers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
             readonly __hex: true;
@@ -78,9 +78,9 @@ export declare const ConfigZod: z.ZodObject<{
         } & {
             readonly __address: true;
         }, string>>>>;
-        minCandidates: z.ZodDefault<z.z.ZodCoercedNumber<unknown>>;
-        backoffMs: z.ZodDefault<z.z.ZodCoercedNumber<unknown>>;
-    }, z.z.core.$strip>>;
+        minCandidates: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        backoffMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
     actors: z.ZodDefault<z.ZodArray<z.ZodObject<{
         chain: z.ZodDefault<z.ZodObject<{
             id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
@@ -89,43 +89,43 @@ export declare const ConfigZod: z.ZodObject<{
             } & {
                 readonly __address: true;
             }, string>>>;
-        }, z.z.core.$strip>>;
-        dataLake: z.ZodOptional<z.ZodType<import("./index.ts").DataLakeConfig, unknown, z.z.core.$ZodTypeInternals<import("./index.ts").DataLakeConfig, unknown>>>;
+        }, z.core.$strip>>;
+        dataLake: z.ZodOptional<z.ZodType<import("./index.ts").DataLakeConfig, unknown, z.core.$ZodTypeInternals<import("./index.ts").DataLakeConfig, unknown>>>;
         evm: z.ZodDefault<z.ZodObject<{
             chainId: z.ZodOptional<z.ZodString>;
             infura: z.ZodOptional<z.ZodObject<{
                 projectId: z.ZodOptional<z.ZodString>;
                 projectSecret: z.ZodOptional<z.ZodString>;
-            }, z.z.core.$strip>>;
+            }, z.core.$strip>>;
             jsonRpc: z.ZodOptional<z.ZodObject<{
                 url: z.ZodOptional<z.ZodURL>;
-            }, z.z.core.$strip>>;
-        }, z.z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         log: z.ZodDefault<z.ZodObject<{
             logLevel: z.ZodDefault<z.ZodEnum<{
+                info: "info";
                 error: "error";
                 warn: "warn";
-                info: "info";
                 log: "log";
                 debug: "debug";
                 trace: "trace";
             }>>;
             silent: z.ZodDefault<z.ZodBoolean>;
-        }, z.z.core.$strip>>;
+        }, z.core.$strip>>;
         providers: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
             moniker: z.ZodString;
             labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.z.core.$loose>>>>;
+        }, z.core.$loose>>>>;
         remote: z.ZodDefault<z.ZodObject<{
             rpc: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                 protocol: z.ZodDefault<z.ZodString>;
                 url: z.ZodString;
-            }, z.z.core.$strip>, z.ZodObject<{
+            }, z.core.$strip>, z.ZodObject<{
                 protocol: z.ZodDefault<z.ZodString>;
                 networkId: z.ZodString;
                 sessionId: z.ZodString;
-            }, z.z.core.$strip>]>>;
-        }, z.z.core.$strip>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
         storage: z.ZodDefault<z.ZodObject<{
             mongo: z.ZodOptional<z.ZodObject<{
                 connectionString: z.ZodOptional<z.ZodString>;
@@ -133,20 +133,20 @@ export declare const ConfigZod: z.ZodObject<{
                 domain: z.ZodOptional<z.ZodString>;
                 password: z.ZodOptional<z.ZodString>;
                 username: z.ZodOptional<z.ZodString>;
-            }, z.z.core.$strip>>;
+            }, z.core.$strip>>;
             root: z.ZodOptional<z.ZodString>;
-        }, z.z.core.$strip>>;
+        }, z.core.$strip>>;
         telemetry: z.ZodDefault<z.ZodObject<{
             metrics: z.ZodOptional<z.ZodObject<{
                 scrape: z.ZodObject<{
                     path: z.ZodDefault<z.ZodString>;
-                    port: z.ZodOptional<z.z.ZodCoercedNumber<unknown>>;
-                }, z.z.core.$strip>;
-            }, z.z.core.$strip>>;
+                    port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
             otel: z.ZodOptional<z.ZodObject<{
                 otlpEndpoint: z.ZodOptional<z.ZodURL>;
-            }, z.z.core.$strip>>;
-        }, z.z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         validation: z.ZodDefault<z.ZodObject<{
             allowedRewardRedeemers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
                 readonly __hex: true;
@@ -158,14 +158,15 @@ export declare const ConfigZod: z.ZodObject<{
             } & {
                 readonly __address: true;
             }, string>>>>;
-            minCandidates: z.ZodDefault<z.z.ZodCoercedNumber<unknown>>;
-            backoffMs: z.ZodDefault<z.z.ZodCoercedNumber<unknown>>;
-        }, z.z.core.$strip>>;
+            minCandidates: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            backoffMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>>;
         name: z.ZodString;
         accountPath: z.ZodOptional<z.ZodString>;
-        healthCheckPort: z.ZodOptional<z.z.ZodCoercedNumber<unknown>>;
-    }, z.z.core.$loose>>>;
-}, z.z.core.$strip>;
+        healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$loose>>>;
+    healthCheckPort: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
 /** Config type. */
 export type Config = z.infer<typeof ConfigZod>;
 /** ResolveConfig helper function. */
@@ -189,7 +190,7 @@ export declare function resolveConfig(config: DeepPartial<Config>): {
         } | undefined;
     };
     log: {
-        logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+        logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
         silent: boolean;
     };
     providers: {
@@ -263,7 +264,7 @@ export declare function resolveConfig(config: DeepPartial<Config>): {
             } | undefined;
         };
         log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
+            logLevel: "info" | "error" | "warn" | "log" | "debug" | "trace";
             silent: boolean;
         };
         providers: {
@@ -322,5 +323,6 @@ export declare function resolveConfig(config: DeepPartial<Config>): {
         healthCheckPort?: number | undefined;
     }[];
     dataLake?: import("./index.ts").DataLakeConfig | undefined;
+    healthCheckPort?: number | undefined;
 };
 //# sourceMappingURL=Config.d.ts.map

package/dist/neutral/config/Config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,0BAA0B;AAC1B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAoK,CAAA;AAE1L,mBAAmB;AACnB,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,qCAAqC;AACrC,wBAAgB,aAAa,CAC3B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ5B"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../src/config/Config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,0BAA0B;AAC1B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO4F,CAAA;AAElH,mBAAmB;AACnB,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAE9C,qCAAqC;AACrC,wBAAgB,aAAa,CAC3B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ5B"}