@arkade-os/sdk 0.4.27 → 0.4.28

package/dist/types/worker/messageBus.d.ts

@@ -1,189 +0,0 @@
-import { ArkProvider } from "../providers/ark.js";
-import { type SerializedIdentity, type LegacySerializedIdentity } from "../identity/index.js";
-import { ReadonlyWallet, Wallet } from "../wallet/wallet.js";
-import type { SettlementConfig } from "../wallet/vtxo-manager.js";
-import type { ContractWatcherConfig } from "../contracts/contractWatcher.js";
-import { ContractRepository, WalletRepository } from "../repositories/index.js";
-export type RequestEnvelope = {
-    tag: string;
-    id: string;
-    broadcast?: boolean;
-};
-export type ResponseEnvelope = {
-    tag: string;
-    id?: string;
-    error?: Error;
-    broadcast?: boolean;
-};
-export interface MessageHandler<REQ extends RequestEnvelope = RequestEnvelope, RES extends ResponseEnvelope = ResponseEnvelope> {
-    /**
-     * A unique identifier for the updater.
-     * This is used to route messages to the correct updater.
-     */
-    readonly messageTag: string;
-    /**
-     * Called once when the SW is starting up
-     * @param services - Providers and wallet instances available to the handler.
-     * @param repositories - Repositories available to the handler.
-     **/
-    start(services: {
-        arkProvider: ArkProvider;
-        wallet?: Wallet;
-        readonlyWallet: ReadonlyWallet;
-    }, repositories: {
-        walletRepository: WalletRepository;
-    }): Promise<void>;
-    /** Called once when the SW is shutting down */
-    stop(): Promise<void>;
-    /**
-     * Called by the scheduler to perform a tick.
-     * Can be used by the updater to perform periodic tasks or return
-     * delayed responses (eg: subscriptions).
-     * @param now The current time in milliseconds since the epoch.
-     **/
-    tick(now: number): Promise<RES[]>;
-    /**
-     * Handle routed messages from the clients
-     **/
-    handleMessage(message: REQ): Promise<RES | null>;
-    /**
-     * Optional opt-out from the bus-level message timeout.
-     *
-     * Long-running flows (e.g. settlement) surrender control to remote peers
-     * and can legitimately sit idle for longer than `messageTimeoutMs`. When
-     * this returns true, the bus awaits `handleMessage` without a deadline.
-     * Defaults to false.
-     */
-    isLongRunning?(message: REQ): boolean;
-}
-type Options = {
-    messageHandlers: MessageHandler[];
-    tickIntervalMs?: number;
-    messageTimeoutMs?: number;
-    /**
-     * Per-operation timeout overrides. Keys are either message types
-     * (e.g. "SETTLE") or handler tags (e.g. "WALLET_UPDATER"). Message-type
-     * matches take precedence over tag matches. Unspecified operations use
-     * `messageTimeoutMs`. These are treated as defaults: any map supplied
-     * via `INITIALIZE_MESSAGE_BUS` overrides per-key and is re-applied on
-     * every (re-)init.
-     */
-    messageTimeoutOverrides?: Record<string, number>;
-    debug?: boolean;
-    buildServices?: (config: Initialize["config"]) => Promise<{
-        arkProvider: ArkProvider;
-        wallet?: Wallet;
-        readonlyWallet: ReadonlyWallet;
-    }>;
-};
-type Initialize = {
-    type: "INITIALIZE_MESSAGE_BUS";
-    id: string;
-    config: {
-        wallet: SerializedIdentity | LegacySerializedIdentity;
-        arkServer: {
-            url: string;
-            publicKey?: string;
-        };
-        delegatorUrl?: string;
-        indexerUrl?: string;
-        esploraUrl?: string;
-        settlementConfig?: SettlementConfig | false;
-        walletMode?: "auto" | "static" | "hd";
-        watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
-        /**
-         * Page-supplied per-operation timeout map. Keys are message types
-         * (e.g. "SETTLE"). Overrides constructor-supplied
-         * `messageTimeoutOverrides` per-key; re-applied on every init.
-         */
-        messageTimeouts?: Record<string, number>;
-    };
-};
-export declare class MessageBus {
-    private readonly walletRepository;
-    private readonly contractRepository;
-    private handlers;
-    private tickIntervalMs;
-    private messageTimeoutMs;
-    private readonly constructorTimeoutOverrides;
-    private messageTimeoutOverrides;
-    private lateDeliveries;
-    private running;
-    private tickTimeout;
-    private tickInProgress;
-    private debug;
-    private initialized;
-    private readonly buildServicesFn;
-    private readonly boundOnMessage;
-    /** Create the service-worker message bus with repositories and handler configuration. */
-    constructor(walletRepository: WalletRepository, contractRepository: ContractRepository, { messageHandlers, tickIntervalMs, messageTimeoutMs, messageTimeoutOverrides, debug, buildServices, }: Options);
-    /** Start the message bus and attach service-worker event listeners. */
-    start(): Promise<void>;
-    /** Stop the message bus, cancel ticks, and stop all registered handlers. */
-    stop(): Promise<void>;
-    private scheduleNextTick;
-    private runTick;
-    private waitForInit;
-    private buildServices;
-    private onMessage;
-    private processMessage;
-    /**
-     * Race `promise` against a timeout. Note: this does NOT cancel the
-     * underlying work — the original promise keeps running. Call
-     * `attachLateDelivery` after catching the timeout to surface the
-     * eventual result so the message id does not go silent.
-     */
-    private withTimeout;
-    /**
-     * Extract the declared `type` from a request envelope (e.g. "SETTLE").
-     * Not every envelope carries a type (PING/INIT are special cased
-     * earlier), so this returns undefined for envelopes that lack one.
-     */
-    private extractMessageType;
-    /**
-     * Resolve the timeout for an operation. Message-type overrides take
-     * precedence over handler-tag overrides, with the bus-wide default
-     * (`messageTimeoutMs`) as the final fallback.
-     */
-    private resolveTimeoutMs;
-    /**
-     * Build a human-readable label for timeout errors. Format:
-     * `"<MESSAGE_TYPE> via <HANDLER_TAG>"` when both are known, else the
-     * handler tag alone. Used so timeout errors name the operation the
-     * client actually triggered (e.g. SETTLE) rather than just the
-     * handler that received it (e.g. WALLET_UPDATER).
-     */
-    private labelFor;
-    /**
-     * Post a response to the originating client. When `source` is null
-     * (client tab closed, detached frame, etc.) the response cannot be
-     * delivered; we log the drop in debug mode so it is not invisible.
-     */
-    private deliverResponse;
-    /**
-     * After a handler times out the client has already received a timeout
-     * error, but the handler keeps running. Attach a follow-up so the
-     * handler's eventual result (or error) is delivered under the same
-     * message id, or — if the handler never completes within
-     * {@link LATE_DELIVERY_GRACE_MS} — an "Operation abandoned" error is
-     * sent so the client's listener (if still attached) does not hang.
-     */
-    private attachLateDelivery;
-    /**
-     * Returns the registered SW for the path.
-     * It uses the functions in `service-worker-manager.ts` module.
-     * @param path
-     * @return the Service Worker
-     * @throws if not running in a browser environment
-     */
-    static getServiceWorker(path?: string): Promise<ServiceWorker>;
-    /**
-     * Set up and register the Service Worker, ensuring it's done once at most.
-     * It uses the functions in `service-worker-manager.ts` module.
-     * @param path
-     * @return the Service Worker
-     * @throws if not running in a browser environment
-     */
-    static setup(path: string): Promise<ServiceWorker>;
-}
-export {};