@nori-zk/mina-token-bridge/target/src/machines/bridge.d.ts

A Mina zk-program contract allowing users to mint tokens on Nori Bridge.

import { WebSocketServiceTopicSubscriptionMessage } from '@nori-zk/pts-types';
type WebSocketContext = {
    url?: string;
    data?: WebSocketServiceTopicSubscriptionMessage;
    error?: Event;
};
type SendEvent = {
    type: 'SEND';
    data: string;
};
type WebSocketEvent = {
    type: 'WS_OPEN';
} | {
    type: 'WS_CLOSE';
    code: number;
} | {
    type: 'WS_MESSAGE';
    data: WebSocketServiceTopicSubscriptionMessage;
} | {
    type: 'WS_ERROR';
    error: Event;
} | SendEvent;
export declare const webSocketMachine: import("xstate").StateMachine<WebSocketContext, WebSocketEvent, {
    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<SendEvent, {
        url: string;
    }, import("xstate").EventObject>>;
}, {
    src: "webSocketActor";
    logic: import("xstate").CallbackActorLogic<SendEvent, {
        url: string;
    }, import("xstate").EventObject>;
    id: string;
}, never, never, never, "connecting" | "connected" | "disconnected", string, {
    url: string;
}, {}, import("xstate").EventObject, import("xstate").MetaObject, {
    readonly id: "websocket";
    readonly initial: "connecting";
    readonly context: ({ input }: {
        spawn: {
            <TSrc extends "webSocketActor">(logic: TSrc, ...[options]: {
                src: "webSocketActor";
                logic: import("xstate").CallbackActorLogic<SendEvent, {
                    url: string;
                }, import("xstate").EventObject>;
                id: string;
            } extends infer T ? T extends {
                src: "webSocketActor";
                logic: import("xstate").CallbackActorLogic<SendEvent, {
                    url: string;
                }, import("xstate").EventObject>;
                id: string;
            } ? T extends {
                src: TSrc;
            } ? import("xstate").ConditionalRequired<[options?: {
                id?: T["id"];
                systemId?: string;
                input?: import("xstate").InputFrom<T["logic"]>;
                syncSnapshot?: boolean;
            } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never): import("xstate").ActorRefFromLogic<import("xstate").GetConcreteByKey<{
                src: "webSocketActor";
                logic: import("xstate").CallbackActorLogic<SendEvent, {
                    url: string;
                }, import("xstate").EventObject>;
                id: string;
            }, "src", TSrc>["logic"]>;
            <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, ...[options]: import("xstate").ConditionalRequired<[options?: {
                id?: never;
                systemId?: string;
                input?: import("xstate").InputFrom<TLogic>;
                syncSnapshot?: boolean;
            } & { [K in import("xstate").RequiredLogicInput<TLogic>]: unknown; }], import("xstate").IsNotNever<import("xstate").RequiredLogicInput<TLogic>>>): import("xstate").ActorRefFromLogic<TLogic>;
        };
        input: {
            url: string;
        };
        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<WebSocketContext, WebSocketEvent, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, WebSocketEvent, import("xstate").AnyEventObject>;
    }) => {
        url: string;
        data: any;
        error: any;
    };
    readonly states: {
        readonly connecting: {
            readonly invoke: {
                readonly id: "websocket";
                readonly src: "webSocketActor";
            };
            readonly on: {
                readonly WS_OPEN: {
                    readonly target: "connected";
                };
                readonly WS_ERROR: {
                    readonly target: "disconnected";
                    readonly actions: import("xstate").ActionFunction<WebSocketContext, {
                        type: "WS_ERROR";
                        error: Event;
                    }, WebSocketEvent, undefined, {
                        src: "webSocketActor";
                        logic: import("xstate").CallbackActorLogic<SendEvent, {
                            url: string;
                        }, import("xstate").EventObject>;
                        id: string;
                    }, never, never, never, never>;
                };
                readonly WS_CLOSE: {
                    readonly target: "disconnected";
                };
            };
        };
        readonly connected: {
            readonly on: {
                readonly WS_MESSAGE: readonly [{
                    readonly guard: ({ event }: import("xstate/dist/declarations/src/guards.js").GuardArgs<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }>) => boolean;
                    readonly actions: ({ event }: import("xstate").ActionArgs<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }, WebSocketEvent>) => void;
                }, {
                    readonly guard: ({ event }: import("xstate/dist/declarations/src/guards.js").GuardArgs<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }>) => boolean;
                    readonly actions: ({ event }: import("xstate").ActionArgs<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }, WebSocketEvent>) => void;
                }, {
                    readonly guard: ({ event }: import("xstate/dist/declarations/src/guards.js").GuardArgs<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }>) => boolean;
                    readonly actions: ({ event }: import("xstate").ActionArgs<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }, WebSocketEvent>) => void;
                }, {
                    readonly actions: import("xstate").ActionFunction<WebSocketContext, {
                        type: "WS_MESSAGE";
                        data: WebSocketServiceTopicSubscriptionMessage;
                    }, WebSocketEvent, undefined, {
                        src: "webSocketActor";
                        logic: import("xstate").CallbackActorLogic<SendEvent, {
                            url: string;
                        }, import("xstate").EventObject>;
                        id: string;
                    }, never, never, never, never>;
                }];
                readonly SEND: {
                    readonly actions: import("xstate").ActionFunction<WebSocketContext, SendEvent, WebSocketEvent, undefined, never, never, never, never, never>;
                };
                readonly WS_ERROR: "disconnected";
                readonly WS_CLOSE: "disconnected";
            };
        };
        readonly disconnected: {
            readonly type: "final";
        };
    };
}>;
export {};