@flow-industries/id 0.2.0

package/dist/sdk/client/dialog-host.d.ts

@@ -0,0 +1,19 @@
+import type { CreateDialogHostOptions, DialogHost } from "../types";
+/**
+ * Creates a host that owns the dialog iframe (or popup) and exposes an RPC
+ * channel into the Flow auth dialog at `id.flow.industries`.
+ *
+ * The iframe is mounted lazily on first use, kept hidden until `open()` is
+ * called, and reused across requests so a single passkey-bound iframe handles
+ * login, signing, and silent restore. The iframe is required (not just
+ * `fetch`) because it's first-party to id.flow.industries and is the only way
+ * to read the cross-origin cookie session in third-party-cookie-blocking
+ * browsers (Safari, Firefox).
+ *
+ * Returned methods:
+ *  - `request()` — open the dialog UI and dispatch an RPC (interactive flows)
+ *  - `requestSilent()` — dispatch without showing the dialog (silent restore)
+ *  - `open()`/`close()` — manual visibility control
+ *  - `destroy()` — tear down the iframe and abort pending requests
+ */
+export declare function createDialogHost(options: CreateDialogHostOptions): DialogHost;

package/dist/sdk/client/dialog-host.js

@@ -0,0 +1,192 @@
+import * as Messenger from "../dialog/remote/Messenger";
+const HIDDEN_STYLE = {
+    position: "fixed",
+    inset: "0",
+    width: "100%",
+    height: "100%",
+    border: "none",
+    zIndex: "2147483647",
+    display: "none",
+    pointerEvents: "none",
+};
+const VISIBLE_STYLE = {
+    display: "block",
+    pointerEvents: "auto",
+    background: "transparent",
+};
+/**
+ * Creates a host that owns the dialog iframe (or popup) and exposes an RPC
+ * channel into the Flow auth dialog at `id.flow.industries`.
+ *
+ * The iframe is mounted lazily on first use, kept hidden until `open()` is
+ * called, and reused across requests so a single passkey-bound iframe handles
+ * login, signing, and silent restore. The iframe is required (not just
+ * `fetch`) because it's first-party to id.flow.industries and is the only way
+ * to read the cross-origin cookie session in third-party-cookie-blocking
+ * browsers (Safari, Firefox).
+ *
+ * Returned methods:
+ *  - `request()` — open the dialog UI and dispatch an RPC (interactive flows)
+ *  - `requestSilent()` — dispatch without showing the dialog (silent restore)
+ *  - `open()`/`close()` — manual visibility control
+ *  - `destroy()` — tear down the iframe and abort pending requests
+ */
+export function createDialogHost(options) {
+    const { host, container = document.body } = options;
+    let iframe = null;
+    let messenger = null;
+    const pending = new Map();
+    /**
+     * Mounts the iframe and wires up the postMessage bridge. Idempotent — safe
+     * to call before every request. The `allow` attribute grants WebAuthn and
+     * clipboard permissions to the dialog (required for passkey ceremonies).
+     */
+    function ensureFrame() {
+        if (iframe)
+            return;
+        iframe = document.createElement("iframe");
+        iframe.src = `${host}`;
+        iframe.dataset.flowId = "";
+        iframe.allow = "publickey-credentials-create; publickey-credentials-get; clipboard-write";
+        Object.assign(iframe.style, HIDDEN_STYLE);
+        iframe.style.colorScheme = "normal";
+        container.appendChild(iframe);
+        messenger = Messenger.bridge({
+            from: Messenger.fromWindow(window),
+            to: Messenger.fromWindow(iframe.contentWindow),
+            waitForReady: true,
+        });
+        messenger.on("rpc-response", (payload) => {
+            const id = payload?.id;
+            const handler = pending.get(id);
+            if (!handler)
+                return;
+            pending.delete(id);
+            if (payload.error) {
+                handler.reject(new Error(payload.error.message ?? "Request failed"));
+            }
+            else {
+                handler.resolve(payload.result);
+            }
+        });
+        messenger.on("close", () => {
+            close();
+        });
+        messenger.on("__internal", (payload) => {
+            if (payload.type === "switch" && payload.mode === "popup") {
+                switchToPopup();
+            }
+        });
+    }
+    /**
+     * Replaces the iframe channel with a popup. Some browsers (older Safari,
+     * embedded webviews) refuse to run WebAuthn inside an iframe; popping out
+     * to a top-level window is the documented escape hatch.
+     */
+    function switchToPopup() {
+        const popup = window.open(`${host}`, "flow-id", "width=400,height=600,popup=true");
+        if (!popup)
+            return;
+        if (messenger)
+            messenger.destroy();
+        messenger = Messenger.bridge({
+            from: Messenger.fromWindow(window),
+            to: Messenger.fromWindow(popup),
+            waitForReady: true,
+        });
+    }
+    let initSent = false;
+    /**
+     * Sends the one-time init handshake to the dialog (referrer info, theme,
+     * mode). Guarded so reusing the iframe across requests doesn't re-init it
+     * — the dialog only expects this once.
+     */
+    function sendInit(opts) {
+        if (initSent)
+            return;
+        initSent = true;
+        messenger?.send("__internal", {
+            type: "init",
+            mode: "iframe",
+            referrer: opts?.referrer ?? { title: document.title },
+            theme: opts?.theme,
+        });
+    }
+    function show() {
+        if (!iframe)
+            return;
+        Object.assign(iframe.style, VISIBLE_STYLE);
+    }
+    function hide() {
+        if (!iframe)
+            return;
+        Object.assign(iframe.style, { display: "none", pointerEvents: "none" });
+    }
+    function open(opts) {
+        if (opts?.mode === "popup") {
+            switchToPopup();
+            return;
+        }
+        ensureFrame();
+        show();
+        sendInit(opts);
+    }
+    function close() {
+        hide();
+        pending.forEach((handler, id) => {
+            handler.reject(new Error("Dialog closed"));
+            pending.delete(id);
+        });
+    }
+    function destroy() {
+        close();
+        messenger?.destroy();
+        iframe?.remove();
+        iframe = null;
+        messenger = null;
+    }
+    /**
+     * Sends a JSON-RPC request to the dialog and registers a resolver keyed by
+     * request id. The matching `rpc-response` message in `ensureFrame()`
+     * dispatches the result back. Pending entries are rejected if the dialog
+     * is closed before responding.
+     */
+    function dispatchRequest(method, params) {
+        const id = Math.floor(Math.random() * 1e9);
+        const rpcRequest = { id, method, params, jsonrpc: "2.0" };
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            messenger.send("rpc-requests", [
+                { request: rpcRequest, status: "pending" },
+            ]);
+        });
+    }
+    /** Opens the dialog UI and dispatches an interactive RPC (login, sign, etc.). */
+    async function request(method, params) {
+        ensureFrame();
+        open();
+        return dispatchRequest(method, params);
+    }
+    /**
+     * Dispatches an RPC without showing the dialog UI. Used for headless flows
+     * (silent restore, refresh, sign-out) where the dialog route runs invisibly
+     * and resolves immediately. The iframe is still mounted so postMessage
+     * works, but its `display` stays `none`.
+     */
+    async function requestSilent(method, params) {
+        ensureFrame();
+        sendInit();
+        return dispatchRequest(method, params);
+    }
+    return {
+        open,
+        close,
+        destroy,
+        request,
+        requestSilent,
+        get messenger() {
+            ensureFrame();
+            return messenger;
+        },
+    };
+}

package/dist/sdk/client/idb.d.ts

@@ -0,0 +1,5 @@
+export declare const idb: {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set(key: string, value: unknown): Promise<unknown>;
+    delete(key: string): Promise<unknown>;
+};

package/dist/sdk/client/idb.js

@@ -0,0 +1,47 @@
+let defaultGetStoreFunc;
+function createStore(dbName, storeName) {
+    let dbp;
+    const getDB = () => {
+        if (dbp)
+            return dbp;
+        const request = indexedDB.open(dbName);
+        request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+        dbp = promisify(request);
+        dbp.then((db) => {
+            db.onclose = () => {
+                dbp = undefined;
+            };
+        }, () => { });
+        return dbp;
+    };
+    return (txMode, callback) => getDB().then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
+}
+function promisify(request) {
+    return new Promise((resolve, reject) => {
+        request.oncomplete = request.onsuccess = () => resolve(request.result);
+        request.onabort = request.onerror = () => reject(request.error);
+    });
+}
+export const idb = {
+    get(key) {
+        if (!defaultGetStoreFunc)
+            defaultGetStoreFunc = createStore("flow-id", "keyval");
+        return defaultGetStoreFunc("readonly", (store) => promisify(store.get(key)));
+    },
+    set(key, value) {
+        if (!defaultGetStoreFunc)
+            defaultGetStoreFunc = createStore("flow-id", "keyval");
+        return defaultGetStoreFunc("readwrite", (store) => {
+            store.put(value, key);
+            return promisify(store.transaction);
+        });
+    },
+    delete(key) {
+        if (!defaultGetStoreFunc)
+            defaultGetStoreFunc = createStore("flow-id", "keyval");
+        return defaultGetStoreFunc("readwrite", (store) => {
+            store.delete(key);
+            return promisify(store.transaction);
+        });
+    },
+};

package/dist/sdk/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createFlow, getFlow, requireFlow, resetFlow } from "./create-flow";
+export { createDialogHost } from "./dialog-host";
+export { METHODS } from "./methods";
+export type { AccessKeyOptions, Address, ConnectCapabilities, ConnectResponse, CreateFlowOptions, DialogHost, Flow, FlowCredential, FlowState, FlowUser, LoginOptions, MethodName, Session, } from "../types";

package/dist/sdk/client/index.js

@@ -0,0 +1,3 @@
+export { createFlow, getFlow, requireFlow, resetFlow } from "./create-flow";
+export { createDialogHost } from "./dialog-host";
+export { METHODS } from "./methods";

package/dist/sdk/client/methods.d.ts

@@ -0,0 +1,9 @@
+export declare const METHODS: {
+    readonly connect: "wallet_connect";
+    readonly signMessage: "personal_sign";
+    readonly signTypedData: "eth_signTypedData";
+    readonly sendTransaction: "eth_sendTransaction";
+    readonly sendCalls: "wallet_sendCalls";
+    readonly restore: "wallet_restore";
+    readonly signOut: "wallet_signout";
+};

package/dist/sdk/client/methods.js

@@ -0,0 +1,9 @@
+export const METHODS = {
+    connect: "wallet_connect",
+    signMessage: "personal_sign",
+    signTypedData: "eth_signTypedData",
+    sendTransaction: "eth_sendTransaction",
+    sendCalls: "wallet_sendCalls",
+    restore: "wallet_restore",
+    signOut: "wallet_signout",
+};

package/dist/sdk/client/protocol.d.ts

@@ -0,0 +1,97 @@
+import type { FlowUser, FlowCredential, WebAuthnSignature } from "../types";
+export declare const METHODS: {
+    readonly connect: "wallet_connect";
+    readonly signMessage: "personal_sign";
+    readonly signTypedData: "eth_signTypedData";
+    readonly sendTransaction: "eth_sendTransaction";
+    readonly sendCalls: "wallet_sendCalls";
+    readonly restore: "wallet_restore";
+    readonly signOut: "wallet_signout";
+};
+export type Method = (typeof METHODS)[keyof typeof METHODS];
+export type ConnectCapabilities = {
+    createAccount?: boolean;
+    signIn?: boolean;
+    accessKeyHash?: string;
+    headless?: boolean;
+    credentialId?: string;
+};
+export type ConnectRequest = [{
+    capabilities?: ConnectCapabilities;
+}];
+export type ConnectResponse = {
+    jwt: string;
+    user: FlowUser;
+    credential: FlowCredential;
+    webauthn?: WebAuthnSignature;
+};
+export type SignMessageRequest = [message: string, address: string];
+export type SignMessageResponse = `0x${string}`;
+export type TypedDataDomain = {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: string;
+};
+export type TypedDataField = {
+    name: string;
+    type: string;
+};
+export type TypedData = {
+    domain: TypedDataDomain;
+    types: Record<string, readonly TypedDataField[]>;
+    primaryType: string;
+    message: Record<string, unknown>;
+};
+export type SignTypedDataRequest = [address: string, typedData: TypedData];
+export type SignTypedDataResponse = `0x${string}`;
+export type Call = {
+    to?: string;
+    value?: string;
+    data?: string;
+};
+export type TransactionArgs = Call & {
+    chainId?: string;
+};
+export type SendTransactionRequest = [TransactionArgs];
+export type SendTransactionResponse = `0x${string}`;
+export type SendCallsRequest = [
+    {
+        calls: readonly Call[];
+        chainId?: string;
+        capabilities?: Record<string, unknown>;
+    }
+];
+export type SendCallsResponse = {
+    id: string;
+};
+export type RestoreRequest = [];
+export type RestoreResponse = {
+    jwt: string;
+    user: FlowUser;
+    credential: FlowCredential;
+    address: `0x${string}`;
+};
+export type SignOutRequest = [];
+export type SignOutResponse = {
+    ok: true;
+};
+export type MethodParams = {
+    [METHODS.connect]: ConnectRequest;
+    [METHODS.signMessage]: SignMessageRequest;
+    [METHODS.signTypedData]: SignTypedDataRequest;
+    [METHODS.sendTransaction]: SendTransactionRequest;
+    [METHODS.sendCalls]: SendCallsRequest;
+    [METHODS.restore]: RestoreRequest;
+    [METHODS.signOut]: SignOutRequest;
+};
+export type MethodResult = {
+    [METHODS.connect]: ConnectResponse;
+    [METHODS.signMessage]: SignMessageResponse;
+    [METHODS.signTypedData]: SignTypedDataResponse;
+    [METHODS.sendTransaction]: SendTransactionResponse;
+    [METHODS.sendCalls]: SendCallsResponse;
+    [METHODS.restore]: RestoreResponse;
+    [METHODS.signOut]: SignOutResponse;
+};

package/dist/sdk/client/protocol.js

@@ -0,0 +1,9 @@
+export const METHODS = {
+    connect: "wallet_connect",
+    signMessage: "personal_sign",
+    signTypedData: "eth_signTypedData",
+    sendTransaction: "eth_sendTransaction",
+    sendCalls: "wallet_sendCalls",
+    restore: "wallet_restore",
+    signOut: "wallet_signout",
+};

package/dist/sdk/client/session.d.ts

@@ -0,0 +1,45 @@
+import type { Address, FlowCredential, FlowState, RunLoginParams, RunLoginResult, Store } from "../types";
+/**
+ * Reads the active credential from IndexedDB and seeds the in-memory store
+ * with `{ credential, address }`. Run on every page load so signing operations
+ * can derive the address before the JWT is refreshed — the credential is
+ * the durable identity, the JWT is just an access token.
+ *
+ * Idempotent and silent: missing credential is a normal "first visit" state,
+ * not an error.
+ */
+export declare function restoreCredential(store: Store<FlowState>): Promise<void>;
+/**
+ * Drives the interactive `wallet_connect` flow through the dialog and
+ * commits the result to local state.
+ *
+ * The capabilities bag is built from the call site (signUp/signIn intent +
+ * any extras like accessKeyHash) plus a "last credential" hint pulled from
+ * IDB. The hint lets the dialog pre-fill the username and skip a step when
+ * the user has signed in here before — without it every login looks like a
+ * first-time sign-in.
+ *
+ * Persists the credential under both `activeCredential` (current session)
+ * and `lastActiveCredential` (next-time hint) so the hint survives logout.
+ */
+export declare function runLogin(params: RunLoginParams): Promise<RunLoginResult>;
+/**
+ * Clears local-only auth state: active credential in IDB, the access key for
+ * the current address (if any), and the in-memory store. Does NOT touch the
+ * server cookie session — the caller (createFlow.logout) handles that
+ * separately via `wallet_signout`.
+ *
+ * The `lastActiveCredential` IDB key is intentionally preserved so the next
+ * login can pre-fill the username.
+ */
+export declare function runLogout(store: Store<FlowState>): Promise<void>;
+/**
+ * Derives the user's wallet address from their passkey public key by
+ * computing keccak256(pubkey)[12:] — the standard Ethereum address scheme,
+ * but applied to the WebAuthn P256 key embedded in the passkey credential.
+ *
+ * This means the address is fully derivable from the passkey alone (no
+ * server needed) and stays stable across sessions and devices that share
+ * the credential.
+ */
+export declare function credentialToAddress(credential: FlowCredential): Address;

package/dist/sdk/client/session.js

@@ -0,0 +1,90 @@
+import * as OxAddress from "ox/Address";
+import * as PublicKey from "ox/PublicKey";
+import { idb } from "./idb";
+import { METHODS } from "./methods";
+import { initialFlowState } from "./store";
+const CREDENTIAL_KEY = "flow.activeCredential";
+const LAST_CREDENTIAL_KEY = "flow.lastActiveCredential";
+/**
+ * Reads the active credential from IndexedDB and seeds the in-memory store
+ * with `{ credential, address }`. Run on every page load so signing operations
+ * can derive the address before the JWT is refreshed — the credential is
+ * the durable identity, the JWT is just an access token.
+ *
+ * Idempotent and silent: missing credential is a normal "first visit" state,
+ * not an error.
+ */
+export async function restoreCredential(store) {
+    const credential = await idb.get(CREDENTIAL_KEY);
+    if (!credential)
+        return;
+    const address = credentialToAddress(credential);
+    store.setState({ credential, address });
+}
+/**
+ * Drives the interactive `wallet_connect` flow through the dialog and
+ * commits the result to local state.
+ *
+ * The capabilities bag is built from the call site (signUp/signIn intent +
+ * any extras like accessKeyHash) plus a "last credential" hint pulled from
+ * IDB. The hint lets the dialog pre-fill the username and skip a step when
+ * the user has signed in here before — without it every login looks like a
+ * first-time sign-in.
+ *
+ * Persists the credential under both `activeCredential` (current session)
+ * and `lastActiveCredential` (next-time hint) so the hint survives logout.
+ */
+export async function runLogin(params) {
+    const { dialog, store, options, extraCapabilities } = params;
+    const lastCredential = await idb.get(LAST_CREDENTIAL_KEY);
+    const capabilities = {
+        ...(options?.signUp ? { createAccount: true } : {}),
+        ...(lastCredential && !options?.signUp
+            ? { credentialId: lastCredential.id }
+            : {}),
+        ...(extraCapabilities ?? {}),
+    };
+    const result = (await dialog.request(METHODS.connect, [
+        { capabilities },
+    ]));
+    const { jwt, user, credential, webauthn } = result;
+    const address = credentialToAddress(credential);
+    await idb.set(CREDENTIAL_KEY, credential);
+    await idb.set(LAST_CREDENTIAL_KEY, credential);
+    store.setState({ user, jwt, credential, address });
+    return {
+        session: { user, jwt, credential, address },
+        webauthn,
+    };
+}
+/**
+ * Clears local-only auth state: active credential in IDB, the access key for
+ * the current address (if any), and the in-memory store. Does NOT touch the
+ * server cookie session — the caller (createFlow.logout) handles that
+ * separately via `wallet_signout`.
+ *
+ * The `lastActiveCredential` IDB key is intentionally preserved so the next
+ * login can pre-fill the username.
+ */
+export async function runLogout(store) {
+    const state = store.getSnapshot();
+    if (state.address) {
+        const { clearAccessKey } = await import("./access-key");
+        await clearAccessKey(state.address);
+    }
+    await idb.delete(CREDENTIAL_KEY);
+    store.setState(initialFlowState);
+}
+/**
+ * Derives the user's wallet address from their passkey public key by
+ * computing keccak256(pubkey)[12:] — the standard Ethereum address scheme,
+ * but applied to the WebAuthn P256 key embedded in the passkey credential.
+ *
+ * This means the address is fully derivable from the passkey alone (no
+ * server needed) and stays stable across sessions and devices that share
+ * the credential.
+ */
+export function credentialToAddress(credential) {
+    const pub = PublicKey.from(`0x${credential.publicKey.replace(/^0x/, "")}`);
+    return OxAddress.fromPublicKey(pub);
+}

package/dist/sdk/client/signing.d.ts

@@ -0,0 +1,16 @@
+import { type Hex, type WalletClient } from "viem";
+import type { SendCallsArgs, SendTransactionArgs, SignMessageArgs, SignTypedDataArgs, SigningContext } from "../types";
+/**
+ * Constructs a viem WalletClient bound to the user's Flow account. Wraps the
+ * transport in `walletNamespaceCompat` so Tempo's wallet RPC namespace is
+ * available alongside the standard JSON-RPC methods. Used by every signing
+ * helper below; consumers can also call this directly via `flow.walletClient()`
+ * if they want to drive viem actions themselves.
+ */
+export declare function buildWalletClient(ctx: SigningContext, chainId?: number): Promise<WalletClient>;
+export declare function signMessage(ctx: SigningContext, args: SignMessageArgs): Promise<Hex>;
+export declare function signTypedData(ctx: SigningContext, args: SignTypedDataArgs): Promise<Hex>;
+export declare function sendTransaction(ctx: SigningContext, args: SendTransactionArgs): Promise<Hex>;
+export declare function sendCalls(ctx: SigningContext, args: SendCallsArgs): Promise<{
+    id: string;
+}>;

package/dist/sdk/client/signing.js

@@ -0,0 +1,91 @@
+import { createWalletClient, http, } from "viem";
+import { sendCalls as viemSendCalls, sendTransaction as viemSendTransaction, signMessage as viemSignMessage, signTypedData as viemSignTypedData, } from "viem/actions";
+import { Account, walletNamespaceCompat } from "viem/tempo";
+import { buildAccessKeyAccount, clearAccessKey, isExpired, loadAccessKey, } from "./access-key";
+function requireAuth(state) {
+    if (!state.credential || !state.address) {
+        throw new Error("Not authenticated — call flow.login() first");
+    }
+    return { credential: state.credential, address: state.address };
+}
+/**
+ * Picks the right viem account for signing — access key if one is present
+ * and unexpired, otherwise the root passkey account (which prompts WebAuthn
+ * on every signature).
+ *
+ * `strict: true` flips the expired-access-key case from "silently fall back
+ * to passkey" to "throw" — useful when consumers want to enforce that
+ * background signing only ever uses the access key.
+ */
+async function resolveAccount(params) {
+    const rootAccount = Account.fromWebAuthnP256(params.credential, { ...(params.rpId ? { rpId: params.rpId } : {}) });
+    const stored = await loadAccessKey(params.address);
+    if (!stored)
+        return rootAccount;
+    if (isExpired(stored)) {
+        await clearAccessKey(params.address);
+        if (params.strict)
+            throw new Error("Access key expired");
+        return rootAccount;
+    }
+    return buildAccessKeyAccount(stored, params.credential, params.rpId);
+}
+/**
+ * Constructs a viem WalletClient bound to the user's Flow account. Wraps the
+ * transport in `walletNamespaceCompat` so Tempo's wallet RPC namespace is
+ * available alongside the standard JSON-RPC methods. Used by every signing
+ * helper below; consumers can also call this directly via `flow.walletClient()`
+ * if they want to drive viem actions themselves.
+ */
+export async function buildWalletClient(ctx, chainId) {
+    const { credential, address } = requireAuth(ctx.getState());
+    const chain = ctx.getChain(chainId);
+    if (!chain)
+        throw new Error("Chain not configured — pass chains to createFlow()");
+    const account = await resolveAccount({
+        credential,
+        address,
+        rpId: ctx.rpId,
+        strict: ctx.strict,
+    });
+    const transport = ctx.getTransport(chain.id) ?? http();
+    return createWalletClient({
+        account,
+        chain,
+        transport: walletNamespaceCompat(transport, { account }),
+    });
+}
+export async function signMessage(ctx, args) {
+    const client = await buildWalletClient(ctx, args.chainId);
+    return viemSignMessage(client, {
+        account: client.account,
+        message: args.message,
+    });
+}
+export async function signTypedData(ctx, args) {
+    const { chainId, ...rest } = args;
+    const client = await buildWalletClient(ctx, chainId);
+    return viemSignTypedData(client, {
+        account: client.account,
+        ...rest,
+    });
+}
+export async function sendTransaction(ctx, args) {
+    const { chainId, ...rest } = args;
+    const client = await buildWalletClient(ctx, chainId);
+    return viemSendTransaction(client, {
+        account: client.account,
+        chain: client.chain,
+        ...rest,
+    });
+}
+export async function sendCalls(ctx, args) {
+    const { chainId, ...rest } = args;
+    const client = await buildWalletClient(ctx, chainId);
+    const result = await viemSendCalls(client, {
+        account: client.account,
+        chain: client.chain,
+        ...rest,
+    });
+    return { id: result.id };
+}

package/dist/sdk/client/store.d.ts

@@ -0,0 +1,3 @@
+import type { FlowState, Store } from "../types";
+export declare function createStore<T>(initial: T): Store<T>;
+export declare const initialFlowState: FlowState;