@xyo-network/xl1-protocol-sdk 4.0.11 → 4.0.12

package/dist/node/context/HostActor.d.ts

@@ -1,651 +0,0 @@
-import { z } from 'zod/mini';
-/** HostActorConfigContext constant. */
-export declare const HostActorConfigContext: z.ZodMiniObject<{
-    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("@xyo-network/xl1-protocol-model").MapType<string, unknown>, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>>;
-    locator: z.ZodMiniOptional<z.ZodMiniType<import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType>, unknown, z.core.$ZodTypeInternals<import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType>, unknown>>>;
-    config: z.ZodMiniObject<{
-        chain: z.ZodMiniDefault<z.ZodMiniObject<{
-            id: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-            genesisRewardAddress: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-        }, z.core.$strip>>;
-        log: z.ZodMiniDefault<import("zod").ZodObject<{
-            logLevel: import("zod").ZodDefault<import("zod").ZodEnum<{
-                error: "error";
-                warn: "warn";
-                info: "info";
-                log: "log";
-                debug: "debug";
-                trace: "trace";
-            }>>;
-            silent: import("zod").ZodDefault<import("zod").ZodBoolean>;
-        }, z.core.$strip>>;
-        connections: z.ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-            access: import("zod").ZodOptional<import("zod").ZodEnum<{
-                read: "read";
-                write: "write";
-            }>>;
-            root: import("zod").ZodString;
-            store: import("zod").ZodOptional<import("zod").ZodString>;
-            type: import("zod").ZodLiteral<"lmdb">;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"mongo">;
-            connectionString: import("zod").ZodOptional<import("zod").ZodString>;
-            database: import("zod").ZodOptional<import("zod").ZodString>;
-            domain: import("zod").ZodOptional<import("zod").ZodString>;
-            password: import("zod").ZodOptional<import("zod").ZodString>;
-            username: import("zod").ZodOptional<import("zod").ZodString>;
-            collection: import("zod").ZodOptional<import("zod").ZodString>;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"rpc">;
-            protocol: import("zod").ZodDefault<import("zod").ZodString>;
-            url: import("zod").ZodOptional<import("zod").ZodString>;
-            networkId: import("zod").ZodOptional<import("zod").ZodString>;
-            sessionId: import("zod").ZodOptional<import("zod").ZodString>;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"rest">;
-            baseUrl: import("zod").ZodString;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            bucket: import("zod").ZodOptional<import("zod").ZodString>;
-            endpoint: import("zod").ZodOptional<import("zod").ZodString>;
-            prefix: import("zod").ZodOptional<import("zod").ZodString>;
-            readUrl: import("zod").ZodOptional<import("zod").ZodString>;
-            type: import("zod").ZodLiteral<"s3">;
-            accessKeyId: import("zod").ZodOptional<import("zod").ZodString>;
-            accountId: import("zod").ZodOptional<import("zod").ZodString>;
-            secretAccessKey: import("zod").ZodOptional<import("zod").ZodString>;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"evm-rpc">;
-            url: import("zod").ZodString;
-            chainId: import("zod").ZodOptional<import("zod").ZodString>;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"memory">;
-        }, z.core.$strip>], "type">>>>;
-        providerBindings: z.ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-            connection: import("zod").ZodOptional<import("zod").ZodString>;
-            provider: import("zod").ZodOptional<import("zod").ZodString>;
-        }, z.core.$strip>>>>;
-        providers: z.ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
-            moniker: import("zod").ZodString;
-            labels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-        }, z.core.$loose>>>>;
-        telemetry: z.ZodMiniDefault<import("zod").ZodObject<{
-            metrics: import("zod").ZodOptional<import("zod").ZodObject<{
-                scrape: import("zod").ZodObject<{
-                    path: import("zod").ZodDefault<import("zod").ZodString>;
-                    port: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
-                }, z.core.$strip>;
-            }, z.core.$strip>>;
-            otel: import("zod").ZodOptional<import("zod").ZodObject<{
-                otlpEndpoint: import("zod").ZodOptional<import("zod").ZodURL>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        validation: z.ZodMiniDefault<import("zod").ZodObject<{
-            signerAuthorizations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"completedStepReward">;
-                signers: import("zod").ZodArray<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>>]>>;
-            }, z.core.$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"derivedReceive">;
-                scope: import("zod").ZodString;
-                signers: import("zod").ZodArray<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>>]>>;
-            }, z.core.$strip>], "type">>>;
-            minCandidates: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
-            backoffMs: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
-        }, z.core.$strip>>;
-        name: z.ZodMiniString<string>;
-        accountPath: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        host: z.ZodMiniDefault<z.ZodMiniString<string>>;
-        port: z.ZodMiniDefault<z.ZodMiniNumber<unknown>>;
-    }, z.core.$strict>;
-}, z.core.$strip>;
-/** HostActorConfigContext type. */
-export type HostActorConfigContext = z.infer<typeof HostActorConfigContext>;
-/** Type guard that checks if a value is a valid HostActorConfigContext. */
-export declare const isHostActorConfigContext: <T>(value: T) => value is T & {
-    singletons: Record<string | symbol, unknown>;
-    caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
-    config: {
-        chain: {
-            id?: import("@ariestools/sdk").BrandedHex | undefined;
-            genesisRewardAddress?: (Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }) | import("@xyo-network/sdk-protocol").XyoQuantAddress | undefined;
-        };
-        log: {
-            logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
-            silent: boolean;
-        };
-        connections: Record<string, {
-            root: string;
-            type: "lmdb";
-            access?: "read" | "write" | undefined;
-            store?: string | undefined;
-        } | {
-            type: "mongo";
-            connectionString?: string | undefined;
-            database?: string | undefined;
-            domain?: string | undefined;
-            password?: string | undefined;
-            username?: string | undefined;
-            collection?: string | undefined;
-        } | {
-            type: "rpc";
-            protocol: string;
-            url?: string | undefined;
-            networkId?: string | undefined;
-            sessionId?: string | undefined;
-        } | {
-            type: "rest";
-            baseUrl: string;
-        } | {
-            type: "s3";
-            bucket?: string | undefined;
-            endpoint?: string | undefined;
-            prefix?: string | undefined;
-            readUrl?: string | undefined;
-            accessKeyId?: string | undefined;
-            accountId?: string | undefined;
-            secretAccessKey?: string | undefined;
-        } | {
-            type: "evm-rpc";
-            url: string;
-            chainId?: string | undefined;
-        } | {
-            type: "memory";
-        }>;
-        providerBindings: Record<string, {
-            connection?: string | undefined;
-            provider?: string | undefined;
-        }>;
-        providers: {
-            [x: string]: unknown;
-            moniker: string;
-            labels?: string[] | undefined;
-        }[];
-        telemetry: {
-            metrics?: {
-                scrape: {
-                    path: string;
-                    port?: number | undefined;
-                };
-            } | undefined;
-            otel?: {
-                otlpEndpoint?: string | undefined;
-            } | undefined;
-        };
-        validation: {
-            signerAuthorizations: ({
-                type: "completedStepReward";
-                signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }))[];
-            } | {
-                type: "derivedReceive";
-                scope: string;
-                signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }))[];
-            })[];
-            minCandidates: number;
-            backoffMs: number;
-        };
-        name: string;
-        host: string;
-        port: number;
-        accountPath?: string | undefined;
-    };
-    logger?: import("@ariestools/sdk").Logger | undefined;
-    meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
-    timeBudgetLimit?: number | undefined;
-    traceProvider?: import("@opentelemetry/api").TracerProvider | undefined;
-    locator?: import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType> | undefined;
-};
-/** Converts a value to HostActorConfigContext, throwing if invalid. */
-export declare const asHostActorConfigContext: {
-    <T>(value: T): (T & {
-        singletons: Record<string | symbol, unknown>;
-        caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
-        config: {
-            chain: {
-                id?: import("@ariestools/sdk").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress | undefined;
-            };
-            log: {
-                logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
-                silent: boolean;
-            };
-            connections: Record<string, {
-                root: string;
-                type: "lmdb";
-                access?: "read" | "write" | undefined;
-                store?: string | undefined;
-            } | {
-                type: "mongo";
-                connectionString?: string | undefined;
-                database?: string | undefined;
-                domain?: string | undefined;
-                password?: string | undefined;
-                username?: string | undefined;
-                collection?: string | undefined;
-            } | {
-                type: "rpc";
-                protocol: string;
-                url?: string | undefined;
-                networkId?: string | undefined;
-                sessionId?: string | undefined;
-            } | {
-                type: "rest";
-                baseUrl: string;
-            } | {
-                type: "s3";
-                bucket?: string | undefined;
-                endpoint?: string | undefined;
-                prefix?: string | undefined;
-                readUrl?: string | undefined;
-                accessKeyId?: string | undefined;
-                accountId?: string | undefined;
-                secretAccessKey?: string | undefined;
-            } | {
-                type: "evm-rpc";
-                url: string;
-                chainId?: string | undefined;
-            } | {
-                type: "memory";
-            }>;
-            providerBindings: Record<string, {
-                connection?: string | undefined;
-                provider?: string | undefined;
-            }>;
-            providers: {
-                [x: string]: unknown;
-                moniker: string;
-                labels?: string[] | undefined;
-            }[];
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                signerAuthorizations: ({
-                    type: "completedStepReward";
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                } | {
-                    type: "derivedReceive";
-                    scope: string;
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                })[];
-                minCandidates: number;
-                backoffMs: number;
-            };
-            name: string;
-            host: string;
-            port: number;
-            accountPath?: string | undefined;
-        };
-        logger?: import("@ariestools/sdk").Logger | undefined;
-        meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
-        timeBudgetLimit?: number | undefined;
-        traceProvider?: import("@opentelemetry/api").TracerProvider | undefined;
-        locator?: import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType> | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        singletons: Record<string | symbol, unknown>;
-        caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
-        config: {
-            chain: {
-                id?: import("@ariestools/sdk").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress | undefined;
-            };
-            log: {
-                logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
-                silent: boolean;
-            };
-            connections: Record<string, {
-                root: string;
-                type: "lmdb";
-                access?: "read" | "write" | undefined;
-                store?: string | undefined;
-            } | {
-                type: "mongo";
-                connectionString?: string | undefined;
-                database?: string | undefined;
-                domain?: string | undefined;
-                password?: string | undefined;
-                username?: string | undefined;
-                collection?: string | undefined;
-            } | {
-                type: "rpc";
-                protocol: string;
-                url?: string | undefined;
-                networkId?: string | undefined;
-                sessionId?: string | undefined;
-            } | {
-                type: "rest";
-                baseUrl: string;
-            } | {
-                type: "s3";
-                bucket?: string | undefined;
-                endpoint?: string | undefined;
-                prefix?: string | undefined;
-                readUrl?: string | undefined;
-                accessKeyId?: string | undefined;
-                accountId?: string | undefined;
-                secretAccessKey?: string | undefined;
-            } | {
-                type: "evm-rpc";
-                url: string;
-                chainId?: string | undefined;
-            } | {
-                type: "memory";
-            }>;
-            providerBindings: Record<string, {
-                connection?: string | undefined;
-                provider?: string | undefined;
-            }>;
-            providers: {
-                [x: string]: unknown;
-                moniker: string;
-                labels?: string[] | undefined;
-            }[];
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                signerAuthorizations: ({
-                    type: "completedStepReward";
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                } | {
-                    type: "derivedReceive";
-                    scope: string;
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                })[];
-                minCandidates: number;
-                backoffMs: number;
-            };
-            name: string;
-            host: string;
-            port: number;
-            accountPath?: string | undefined;
-        };
-        logger?: import("@ariestools/sdk").Logger | undefined;
-        meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
-        timeBudgetLimit?: number | undefined;
-        traceProvider?: import("@opentelemetry/api").TracerProvider | undefined;
-        locator?: import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType> | undefined;
-    };
-};
-/** toHostActorConfigContext constant. */
-export declare const toHostActorConfigContext: {
-    <T>(value: T): (T & {
-        singletons: Record<string | symbol, unknown>;
-        caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
-        config: {
-            chain: {
-                id?: import("@ariestools/sdk").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress | undefined;
-            };
-            log: {
-                logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
-                silent: boolean;
-            };
-            connections: Record<string, {
-                root: string;
-                type: "lmdb";
-                access?: "read" | "write" | undefined;
-                store?: string | undefined;
-            } | {
-                type: "mongo";
-                connectionString?: string | undefined;
-                database?: string | undefined;
-                domain?: string | undefined;
-                password?: string | undefined;
-                username?: string | undefined;
-                collection?: string | undefined;
-            } | {
-                type: "rpc";
-                protocol: string;
-                url?: string | undefined;
-                networkId?: string | undefined;
-                sessionId?: string | undefined;
-            } | {
-                type: "rest";
-                baseUrl: string;
-            } | {
-                type: "s3";
-                bucket?: string | undefined;
-                endpoint?: string | undefined;
-                prefix?: string | undefined;
-                readUrl?: string | undefined;
-                accessKeyId?: string | undefined;
-                accountId?: string | undefined;
-                secretAccessKey?: string | undefined;
-            } | {
-                type: "evm-rpc";
-                url: string;
-                chainId?: string | undefined;
-            } | {
-                type: "memory";
-            }>;
-            providerBindings: Record<string, {
-                connection?: string | undefined;
-                provider?: string | undefined;
-            }>;
-            providers: {
-                [x: string]: unknown;
-                moniker: string;
-                labels?: string[] | undefined;
-            }[];
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                signerAuthorizations: ({
-                    type: "completedStepReward";
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                } | {
-                    type: "derivedReceive";
-                    scope: string;
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                })[];
-                minCandidates: number;
-                backoffMs: number;
-            };
-            name: string;
-            host: string;
-            port: number;
-            accountPath?: string | undefined;
-        };
-        logger?: import("@ariestools/sdk").Logger | undefined;
-        meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
-        timeBudgetLimit?: number | undefined;
-        traceProvider?: import("@opentelemetry/api").TracerProvider | undefined;
-        locator?: import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType> | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        singletons: Record<string | symbol, unknown>;
-        caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
-        config: {
-            chain: {
-                id?: import("@ariestools/sdk").BrandedHex | undefined;
-                genesisRewardAddress?: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress | undefined;
-            };
-            log: {
-                logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
-                silent: boolean;
-            };
-            connections: Record<string, {
-                root: string;
-                type: "lmdb";
-                access?: "read" | "write" | undefined;
-                store?: string | undefined;
-            } | {
-                type: "mongo";
-                connectionString?: string | undefined;
-                database?: string | undefined;
-                domain?: string | undefined;
-                password?: string | undefined;
-                username?: string | undefined;
-                collection?: string | undefined;
-            } | {
-                type: "rpc";
-                protocol: string;
-                url?: string | undefined;
-                networkId?: string | undefined;
-                sessionId?: string | undefined;
-            } | {
-                type: "rest";
-                baseUrl: string;
-            } | {
-                type: "s3";
-                bucket?: string | undefined;
-                endpoint?: string | undefined;
-                prefix?: string | undefined;
-                readUrl?: string | undefined;
-                accessKeyId?: string | undefined;
-                accountId?: string | undefined;
-                secretAccessKey?: string | undefined;
-            } | {
-                type: "evm-rpc";
-                url: string;
-                chainId?: string | undefined;
-            } | {
-                type: "memory";
-            }>;
-            providerBindings: Record<string, {
-                connection?: string | undefined;
-                provider?: string | undefined;
-            }>;
-            providers: {
-                [x: string]: unknown;
-                moniker: string;
-                labels?: string[] | undefined;
-            }[];
-            telemetry: {
-                metrics?: {
-                    scrape: {
-                        path: string;
-                        port?: number | undefined;
-                    };
-                } | undefined;
-                otel?: {
-                    otlpEndpoint?: string | undefined;
-                } | undefined;
-            };
-            validation: {
-                signerAuthorizations: ({
-                    type: "completedStepReward";
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                } | {
-                    type: "derivedReceive";
-                    scope: string;
-                    signers: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
-                        readonly __hex: true;
-                    } & {
-                        readonly __address: true;
-                    }))[];
-                })[];
-                minCandidates: number;
-                backoffMs: number;
-            };
-            name: string;
-            host: string;
-            port: number;
-            accountPath?: string | undefined;
-        };
-        logger?: import("@ariestools/sdk").Logger | undefined;
-        meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
-        timeBudgetLimit?: number | undefined;
-        traceProvider?: import("@opentelemetry/api").TracerProvider | undefined;
-        locator?: import("../index.ts").ProviderFactoryLocatorInstance<import("../model/CreatableProviderContext.zod.ts").CreatableProviderContextType> | undefined;
-    };
-};
-//# sourceMappingURL=HostActor.d.ts.map

package/dist/node/context/HostActor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HostActor.d.ts","sourceRoot":"","sources":["../../../src/context/HostActor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,uCAAuC;AACvC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiE,CAAA;AAEpG,mCAAmC;AACnC,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuC,CAAA;AAC5E,uEAAuE;AACvE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmE,CAAA;AACxG,yCAAyC;AACzC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmE,CAAA"}

package/dist/node/context/index.d.ts

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

package/dist/node/context/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}

package/dist/node/createDeclarationPayload.d.ts

@@ -1,5 +0,0 @@
-import type { XyoAddress } from '@xyo-network/sdk';
-import { type ChainStakeIntent, type Intent } from '@xyo-network/xl1-protocol-lib';
-/** createDeclarationIntent constant. */
-export declare const createDeclarationIntent: (address: XyoAddress, intent: Intent, nbf: number, exp?: number) => ChainStakeIntent;
-//# sourceMappingURL=createDeclarationPayload.d.ts.map

package/dist/node/createDeclarationPayload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createDeclarationPayload.d.ts","sourceRoot":"","sources":["../../src/createDeclarationPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,EACL,KAAK,gBAAgB,EAA0B,KAAK,MAAM,EAC3D,MAAM,+BAA+B,CAAA;AAEtC,wCAAwC;AACxC,eAAO,MAAM,uBAAuB,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,MAAM,KAAG,gBAOxG,CAAA"}