@xyo-network/xl1-protocol-sdk 4.0.4 → 4.0.5

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

@@ -0,0 +1,645 @@
+import { z } from 'zod/mini';
+/** HostActorConfigContext constant. */
+export declare const HostActorConfigContext: z.ZodMiniObject<{
+    logger: import("zod").ZodOptional<import("zod").ZodCustom<import("@xylabs/sdk").Logger, import("@xylabs/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("@xylabs/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>;
+        }, 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("@xylabs/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;
+        } | {
+            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("@xylabs/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("@xylabs/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;
+            } | {
+                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("@xylabs/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("@xylabs/sdk").ZodFactoryConfig): T & {
+        singletons: Record<string | symbol, unknown>;
+        caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
+        config: {
+            chain: {
+                id?: import("@xylabs/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;
+            } | {
+                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("@xylabs/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("@xylabs/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;
+            } | {
+                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("@xylabs/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("@xylabs/sdk").ZodFactoryConfig): T & {
+        singletons: Record<string | symbol, unknown>;
+        caches: Record<string, import("@xyo-network/xl1-protocol-model").MapType<string, unknown>>;
+        config: {
+            chain: {
+                id?: import("@xylabs/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;
+            } | {
+                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("@xylabs/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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,5 @@
+import type { XyoAddress } from '@xyo-network/sdk-js';
+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

@@ -0,0 +1 @@
+{"version":3,"file":"createDeclarationPayload.d.ts","sourceRoot":"","sources":["../../src/createDeclarationPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD,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"}

package/dist/node/createTransferPayload.d.ts

@@ -0,0 +1,6 @@
+import type { JsonObject } from '@xylabs/sdk';
+import type { XyoAddress } from '@xyo-network/sdk-js';
+import type { Transfer } from '@xyo-network/xl1-protocol-lib';
+/** Creates a TransferPayload instance. */
+export declare function createTransferPayload(from: XyoAddress, transfers: Record<XyoAddress, bigint>, context?: JsonObject): Transfer;
+//# sourceMappingURL=createTransferPayload.d.ts.map