@flow-industries/id 0.2.0

package/dist/sdk/client/store.js

@@ -0,0 +1,41 @@
+export function createStore(initial) {
+    let state = initial;
+    const listeners = new Set();
+    return {
+        getSnapshot() {
+            return state;
+        },
+        setState(partial) {
+            const next = { ...state, ...partial };
+            if (shallowEqual(state, next))
+                return;
+            state = next;
+            for (const l of listeners)
+                l(state);
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+export const initialFlowState = {
+    user: null,
+    jwt: null,
+    credential: null,
+    address: null,
+};
+function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+        return false;
+    }
+    const ak = Object.keys(a);
+    if (Object.keys(b).length !== ak.length)
+        return false;
+    for (const k of ak)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}

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

@@ -0,0 +1,35 @@
+import type { Chain } from "viem";
+import type { FlowCredential, FlowUser } from "../types";
+export type { FlowUser, FlowCredential };
+export type Address = `0x${string}`;
+export type AccessKeyOptions = {
+    expiry?: number;
+    strict?: boolean;
+};
+export type CreateFlowOptions = {
+    host?: string;
+    rpId?: string;
+    chains?: readonly Chain[];
+    accessKey?: boolean | AccessKeyOptions;
+    /**
+     * If true (default), createFlow attempts a silent restore on startup —
+     * if the user has a valid Flow cookie session, state populates without UI.
+     */
+    autoRestore?: boolean;
+};
+export type FlowState = {
+    user: FlowUser | null;
+    jwt: string | null;
+    credential: FlowCredential | null;
+    address: Address | null;
+};
+export type LoginOptions = {
+    mode?: "iframe" | "popup";
+    signUp?: boolean;
+};
+export type Session = {
+    user: FlowUser;
+    jwt: string;
+    credential: FlowCredential;
+    address: Address;
+};

package/dist/sdk/dialog/remote/Messenger.d.ts

@@ -0,0 +1,29 @@
+import type { Bridge, BridgeParameters, FromWindowOptions, Messenger } from "../../types";
+export type { Bridge, BridgeParameters, FromWindowOptions, Messenger, Payload, QueuedRequest, ReadyOptions, Schema, Topic, WithReady, } from "../../types";
+export type { MessageResponse as Response } from "../../types";
+export declare function from(messenger: Messenger): Messenger;
+/**
+ * Wraps a Window in the Messenger interface. Reads come from
+ * `addEventListener("message")` on this window; writes go through
+ * `postMessage` to the same (or another) window.
+ *
+ * `targetOrigin` (when set) acts as both an inbound filter (drop messages
+ * not from this origin) and a default for outbound `postMessage` calls —
+ * binding the channel to one origin instead of `*` is the cross-origin
+ * isolation that prevents arbitrary pages from injecting messages.
+ */
+export declare function fromWindow(w: Window, options?: FromWindowOptions): Messenger;
+/**
+ * Combines two Messengers into a bidirectional bridge: `from` is read-side
+ * (inbound messages), `to` is write-side (outbound). Adds a "ready"
+ * handshake — when `waitForReady: true`, sends queue until the peer
+ * announces it's listening, so messages dispatched during page load aren't
+ * dropped against an iframe that hasn't booted yet.
+ */
+export declare function bridge(parameters: BridgeParameters): Bridge;
+/**
+ * No-op bridge used in non-browser environments (SSR, tests, Node) where
+ * `window` doesn't exist. All sends resolve to undefined and never deliver.
+ * Lets the SDK be imported from anywhere without crashing on module load.
+ */
+export declare function noop(): Bridge;

package/dist/sdk/dialog/remote/Messenger.js

@@ -0,0 +1,146 @@
+/**
+ * Recursively strips values that postMessage's structured-clone algorithm
+ * can't carry: functions become `undefined`, plain objects are walked, and
+ * exotic objects (class instances, DOM nodes, etc.) are passed through
+ * structuredClone or dropped if even that fails. Without this, sending an
+ * object with a method on it would throw a DataCloneError at runtime.
+ */
+function normalizeValue(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeValue);
+    if (typeof value === "function")
+        return undefined;
+    if (typeof value !== "object" || value === null)
+        return value;
+    if (Object.getPrototypeOf(value) !== Object.prototype)
+        try {
+            return structuredClone(value);
+        }
+        catch {
+            return undefined;
+        }
+    const normalized = {};
+    for (const [k, v] of Object.entries(value))
+        normalized[k] = normalizeValue(v);
+    return normalized;
+}
+export function from(messenger) {
+    return messenger;
+}
+/**
+ * Wraps a Window in the Messenger interface. Reads come from
+ * `addEventListener("message")` on this window; writes go through
+ * `postMessage` to the same (or another) window.
+ *
+ * `targetOrigin` (when set) acts as both an inbound filter (drop messages
+ * not from this origin) and a default for outbound `postMessage` calls —
+ * binding the channel to one origin instead of `*` is the cross-origin
+ * isolation that prevents arbitrary pages from injecting messages.
+ */
+export function fromWindow(w, options = {}) {
+    const { targetOrigin } = options;
+    const listeners = new Map();
+    return from({
+        destroy() {
+            listeners.forEach((listener) => {
+                w.removeEventListener("message", listener);
+            });
+        },
+        on(topic, listener, id) {
+            function handler(event) {
+                if (event.data.topic !== topic)
+                    return;
+                if (id && event.data.id !== id)
+                    return;
+                if (targetOrigin && event.origin !== targetOrigin)
+                    return;
+                listener(event.data.payload, event);
+            }
+            w.addEventListener("message", handler);
+            listeners.set(`${topic}:${id ?? ""}`, handler);
+            return () => w.removeEventListener("message", handler);
+        },
+        async send(topic, payload, target) {
+            const id = crypto.randomUUID();
+            w.postMessage(normalizeValue({ id, payload, topic }), target ?? targetOrigin ?? "*");
+            return { id, payload, topic };
+        },
+        async sendAsync(topic, payload, target) {
+            const { id } = await this.send(topic, payload, target);
+            return new Promise((resolve) => this.on(topic, resolve, id));
+        },
+    });
+}
+/**
+ * Combines two Messengers into a bidirectional bridge: `from` is read-side
+ * (inbound messages), `to` is write-side (outbound). Adds a "ready"
+ * handshake — when `waitForReady: true`, sends queue until the peer
+ * announces it's listening, so messages dispatched during page load aren't
+ * dropped against an iframe that hasn't booted yet.
+ */
+export function bridge(parameters) {
+    const { from: from_, to, waitForReady = false } = parameters;
+    let pending = false;
+    let resolveReady;
+    let rejectReady;
+    const readyPromise = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    from_.on("ready", resolveReady);
+    const messenger = from({
+        destroy() {
+            from_.destroy();
+            to.destroy();
+            if (pending)
+                rejectReady();
+        },
+        on(topic, listener, id) {
+            return from_.on(topic, listener, id);
+        },
+        async send(topic, payload, targetOrigin) {
+            pending = true;
+            if (waitForReady)
+                await readyPromise.finally(() => (pending = false));
+            return to.send(topic, payload, targetOrigin);
+        },
+        async sendAsync(topic, payload, targetOrigin) {
+            pending = true;
+            if (waitForReady)
+                await readyPromise.finally(() => (pending = false));
+            return to.sendAsync(topic, payload, targetOrigin);
+        },
+    });
+    return {
+        ...messenger,
+        ready(options) {
+            void messenger.send("ready", options);
+        },
+        waitForReady() {
+            return readyPromise;
+        },
+    };
+}
+/**
+ * No-op bridge used in non-browser environments (SSR, tests, Node) where
+ * `window` doesn't exist. All sends resolve to undefined and never deliver.
+ * Lets the SDK be imported from anywhere without crashing on module load.
+ */
+export function noop() {
+    return {
+        destroy() { },
+        on() {
+            return () => { };
+        },
+        ready() { },
+        send() {
+            return Promise.resolve(undefined);
+        },
+        sendAsync() {
+            return Promise.resolve(undefined);
+        },
+        waitForReady() {
+            return Promise.resolve(undefined);
+        },
+    };
+}

package/dist/sdk/react/hooks.d.ts

@@ -0,0 +1,33 @@
+import type { Flow, FlowState } from "../types";
+/**
+ * Returns the Flow instance to use. Resolution order:
+ *  1. The instance from a `<FlowIdProvider>` ancestor (if any)
+ *  2. The singleton set by `createFlow()`
+ *
+ * Throws only if neither is available — i.e., the app forgot to call
+ * `createFlow()` and didn't supply a provider. The singleton fallback
+ * means most apps don't need a provider at all.
+ */
+export declare function useFlow(): Flow;
+/**
+ * Subscribes a component to the full Flow state. Re-renders on any state
+ * change; if you only need one field, prefer reading `useFlowId()` and
+ * destructuring, or memoize a selector around this.
+ */
+export declare function useFlowState(): FlowState;
+/**
+ * Convenience hook that returns the most commonly needed identity data and
+ * actions in one go: user/jwt/address plus `login`, `logout`, `restore`,
+ * and `refreshJwt`. The `isAuthenticated` boolean is derived from `user`
+ * being set so it tracks reactive state.
+ */
+export declare function useFlowId(): {
+    user: import("../types").FlowUser | null;
+    jwt: string | null;
+    address: `0x${string}` | null;
+    isAuthenticated: boolean;
+    login: (options?: import("../types").LoginOptions) => Promise<import("../types").Session>;
+    logout: () => Promise<void>;
+    restore: () => Promise<boolean>;
+    refreshJwt: () => Promise<boolean>;
+};

package/dist/sdk/react/hooks.js

@@ -0,0 +1,51 @@
+import { useContext, useSyncExternalStore } from "react";
+import { getFlow as getSingletonFlow } from "../client/create-flow";
+import { FlowContext } from "./provider";
+/**
+ * Returns the Flow instance to use. Resolution order:
+ *  1. The instance from a `<FlowIdProvider>` ancestor (if any)
+ *  2. The singleton set by `createFlow()`
+ *
+ * Throws only if neither is available — i.e., the app forgot to call
+ * `createFlow()` and didn't supply a provider. The singleton fallback
+ * means most apps don't need a provider at all.
+ */
+export function useFlow() {
+    const fromContext = useContext(FlowContext);
+    if (fromContext)
+        return fromContext;
+    const singleton = getSingletonFlow();
+    if (singleton)
+        return singleton;
+    throw new Error("useFlow could not find a Flow instance. Call createFlow() at app start, " +
+        "or wrap your tree in <FlowIdProvider flow={...}>.");
+}
+/**
+ * Subscribes a component to the full Flow state. Re-renders on any state
+ * change; if you only need one field, prefer reading `useFlowId()` and
+ * destructuring, or memoize a selector around this.
+ */
+export function useFlowState() {
+    const flow = useFlow();
+    return useSyncExternalStore(flow.subscribe, flow.getState, flow.getState);
+}
+/**
+ * Convenience hook that returns the most commonly needed identity data and
+ * actions in one go: user/jwt/address plus `login`, `logout`, `restore`,
+ * and `refreshJwt`. The `isAuthenticated` boolean is derived from `user`
+ * being set so it tracks reactive state.
+ */
+export function useFlowId() {
+    const flow = useFlow();
+    const state = useFlowState();
+    return {
+        user: state.user,
+        jwt: state.jwt,
+        address: state.address,
+        isAuthenticated: state.user !== null,
+        login: flow.login,
+        logout: flow.logout,
+        restore: flow.restore,
+        refreshJwt: flow.refreshJwt,
+    };
+}

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

@@ -0,0 +1,3 @@
+export { FlowIdProvider } from "./provider";
+export { useFlow, useFlowId, useFlowState } from "./hooks";
+export type { FlowIdProviderProps } from "../types";

package/dist/sdk/react/index.js

@@ -0,0 +1,2 @@
+export { FlowIdProvider } from "./provider";
+export { useFlow, useFlowId, useFlowState } from "./hooks";

package/dist/sdk/react/provider.d.ts

@@ -0,0 +1,12 @@
+import type { Flow, FlowIdProviderProps } from "../types";
+export declare const FlowContext: import("react").Context<Flow | null>;
+/**
+ * Optional context provider for scoping a specific Flow instance to a
+ * subtree. Most apps don't need it: the React hooks fall back to the
+ * singleton set by `createFlow()`, so just calling `createFlow()` once at
+ * app start is enough.
+ *
+ * Wrap when you need multiple instances (tests, storybook) or want to make
+ * the dependency explicit at a particular boundary.
+ */
+export declare function FlowIdProvider({ flow, children }: FlowIdProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/sdk/react/provider.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext } from "react";
+export const FlowContext = createContext(null);
+/**
+ * Optional context provider for scoping a specific Flow instance to a
+ * subtree. Most apps don't need it: the React hooks fall back to the
+ * singleton set by `createFlow()`, so just calling `createFlow()` once at
+ * app start is enough.
+ *
+ * Wrap when you need multiple instances (tests, storybook) or want to make
+ * the dependency explicit at a particular boundary.
+ */
+export function FlowIdProvider({ flow, children }) {
+    return _jsx(FlowContext.Provider, { value: flow ?? null, children: children });
+}

package/dist/sdk/types/auth.d.ts

@@ -0,0 +1,45 @@
+import type { JWTPayload } from "jose";
+export type FlowUser = {
+    id: string;
+    username: string;
+};
+export type FlowCredential = {
+    id: string;
+    publicKey: string;
+};
+export type AuthResponse = {
+    jwt: string;
+    user: FlowUser;
+    credential: FlowCredential;
+};
+export type AuthConfig = {
+    rpId: string;
+    rpName: string;
+};
+export type WebAuthnSignature = {
+    signature: {
+        r: string;
+        s: string;
+    };
+    metadata: {
+        authenticatorData: string;
+        clientDataJSON: string;
+        challengeIndex: number;
+        typeIndex: number;
+    };
+};
+export type AuthResponseWithWebAuthn = AuthResponse & {
+    webauthn?: WebAuthnSignature;
+};
+export type PasskeyPluginOptions = {
+    rpId: string;
+    rpName?: string;
+};
+export type VerifyOptions = {
+    audience: string;
+    issuerUrl?: string;
+};
+export type VerifiedFlowJWT = JWTPayload & {
+    sub: string;
+    username?: string;
+};

package/dist/sdk/types/dialog.d.ts

@@ -0,0 +1,55 @@
+export type DialogReferrer = {
+    icon?: string | {
+        light: string;
+        dark: string;
+    };
+    title: string;
+    origin: string;
+    url?: URL;
+};
+export type DialogError = {
+    action: "close" | "retry-in-popup";
+    title: string;
+    message: string;
+    name: string;
+    secondaryMessage?: string;
+};
+export type BoundaryError = {
+    type: "runtime" | "call";
+    title: string;
+    message: string;
+};
+export type DialogCustomFeatures = {
+    bugReporting?: boolean;
+    emailInput?: boolean;
+    signUpLink?: boolean;
+    createAccount?: boolean;
+};
+export type DialogCustomLabels = {
+    signInPrompt?: string;
+    signIn?: string;
+    signUp?: string;
+    createAccount?: string;
+    signInAlt?: string;
+    dialogTitle?: string;
+    exampleEmail?: string;
+    bugReportEmail?: string;
+    switchAccount?: string;
+    signUpLink?: string;
+};
+export type DialogState = {
+    mode: string;
+    display: "floating" | "drawer" | "full";
+    colorScheme: "light" | "dark" | "light dark";
+    referrer: DialogReferrer | null;
+    initialized: boolean;
+    origin: string | null;
+    trusted: boolean;
+    error: DialogError | null;
+    accountMetadata: Record<string, {
+        username?: string;
+        email?: string;
+    }>;
+    customFeatures?: DialogCustomFeatures;
+    customLabels?: DialogCustomLabels;
+};

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

@@ -0,0 +1,7 @@
+export type { AuthConfig, AuthResponse, AuthResponseWithWebAuthn, FlowCredential, FlowUser, PasskeyPluginOptions, VerifiedFlowJWT, VerifyOptions, WebAuthnSignature, } from "./auth";
+export type { AccessKeyOptions, AccessKeyPreparation, Address, CreateDialogHostOptions, CreateFlowOptions, DialogHost, DialogOpenOptions, FinalizeAccessKeyParams, Flow, FlowIdProviderProps, FlowConnectorParameters, FlowState, Listener, LoginOptions, ResolveAccountParams, ResolvedAccessKeyOptions, RootCredential, RunLoginParams, RunLoginResult, SendCallsArgs, SendTransactionArgs, Session, SignMessageArgs, SignTypedDataArgs, SigningContext, StoredAccessKey, Store, } from "./sdk";
+export { isPersonalSignParams, isSendCallsParams, isSendTransactionParams, } from "./protocol";
+export type { Call, ConnectCapabilities, ConnectRequest, ConnectResponse, MethodName, MethodParams, MethodResult, RestoreRequest, RestoreResponse, RpcRequest, SendCallsParams, SendCallsRequest, SendCallsResponse, SendTransactionParams, SendTransactionRequest, SendTransactionResponse, SignMessageRequest, SignMessageResponse, SignOutRequest, SignOutResponse, SignTypedDataRequest, SignTypedDataResponse, TransactionArgs, TypedData, TypedDataDomain, TypedDataField, } from "./protocol";
+export type { Bridge, BridgeParameters, FlowAccount, FlowRemote, FlowRemoteConfig, FromWindowOptions, MessageResponse, Messenger, OneOf, Payload, QueuedRequest, ReadyOptions, RemoteFlowState, RemoteState, Schema, Storage, Topic, WithReady, } from "./messenger";
+export type { BoundaryError, DialogCustomFeatures, DialogCustomLabels, DialogError, DialogReferrer, DialogState, } from "./dialog";
+export type { CoinAsset, IdentifiedTx, TxApprove, TxConvert, TxSend, TxSwap, } from "./tx";

package/dist/sdk/types/index.js

@@ -0,0 +1 @@
+export { isPersonalSignParams, isSendCallsParams, isSendTransactionParams, } from "./protocol";

package/dist/sdk/types/messenger.d.ts

@@ -0,0 +1,162 @@
+import type * as RpcRequestOx from "ox/RpcRequest";
+import type * as RpcResponseOx from "ox/RpcResponse";
+import type { StoreApi } from "zustand/vanilla";
+export type ReadyOptions = {
+    chainIds?: readonly number[] | undefined;
+};
+export type QueuedRequest = {
+    request: RpcRequestOx.RpcRequest;
+    status?: "pending" | "fulfilled" | "rejected";
+    account?: {
+        address: string;
+        key?: {
+            credentialId?: string;
+            publicKey: string;
+        };
+    };
+};
+export type Schema = [
+    {
+        topic: "close";
+        payload: undefined;
+        response: undefined;
+    },
+    {
+        topic: "ready";
+        payload: ReadyOptions;
+        response: undefined;
+    },
+    {
+        topic: "rpc-requests";
+        payload: readonly QueuedRequest[];
+        response: undefined;
+    },
+    {
+        topic: "rpc-response";
+        payload: RpcResponseOx.RpcResponse & {
+            _request: RpcRequestOx.RpcRequest;
+        };
+        response: undefined;
+    },
+    {
+        topic: "account";
+        payload: {
+            account: {
+                address: string;
+                username?: string;
+            };
+        };
+        response: undefined;
+    },
+    {
+        topic: "__internal";
+        payload: {
+            type: "init";
+            mode: "iframe" | "popup" | "popup-standalone" | "page";
+            referrer: {
+                icon?: string | {
+                    light: string;
+                    dark: string;
+                };
+                title: string;
+            };
+            theme?: {
+                colorScheme?: string;
+            };
+            features?: Record<string, boolean>;
+            labels?: Record<string, string>;
+        } | {
+            type: "switch";
+            mode: "iframe" | "popup" | "popup-standalone" | "page";
+        } | {
+            type: "resize";
+            height?: number;
+            width?: number;
+        } | {
+            type: "set-theme";
+            theme: {
+                colorScheme?: string;
+            };
+        };
+        response: undefined;
+    }
+];
+export type Topic = Schema[number]["topic"];
+export type Payload<topic extends Topic> = Extract<Schema[number], {
+    topic: topic;
+}>["payload"];
+export type MessageResponse<topic extends Topic> = Extract<Schema[number], {
+    topic: topic;
+}>["response"];
+export type Messenger = {
+    destroy: () => void;
+    on: <const topic extends Topic>(topic: topic | Topic, listener: (payload: Payload<topic>, event: MessageEvent) => void, id?: string | undefined) => () => void;
+    send: <const topic extends Topic>(topic: topic | Topic, payload: Payload<topic>, targetOrigin?: string | undefined) => Promise<{
+        id: string;
+        topic: topic;
+        payload: Payload<topic>;
+    }>;
+    sendAsync: <const topic extends Topic>(topic: topic | Topic, payload: Payload<topic>, targetOrigin?: string | undefined) => Promise<MessageResponse<topic>>;
+};
+export type WithReady = Messenger & {
+    ready: (options: ReadyOptions) => void;
+};
+export type Bridge = WithReady & {
+    waitForReady: () => Promise<ReadyOptions>;
+};
+export type FromWindowOptions = {
+    targetOrigin?: string;
+};
+export type BridgeParameters = {
+    from: Messenger;
+    to: Messenger;
+    waitForReady?: boolean;
+};
+export type FlowAccount = {
+    address: string;
+    username?: string;
+    key?: {
+        credentialId?: string;
+        publicKey: string;
+    };
+};
+export type RemoteFlowState = {
+    accounts: FlowAccount[];
+};
+export type RemoteState = {
+    requests: readonly QueuedRequest[];
+};
+export type Storage = {
+    getItem: <value>(name: string) => Promise<value | null> | value | null;
+    removeItem: (name: string) => Promise<void> | void;
+    setItem: (name: string, value: unknown) => Promise<void> | void;
+    sizeLimit: number;
+    storages?: readonly Storage[];
+};
+export type FlowRemoteConfig = {
+    messenger?: Bridge | Messenger;
+    storage?: Storage;
+    storageKey?: string;
+};
+export type FlowRemote = {
+    messenger: OneOf<WithReady | Messenger>;
+    ready: () => Promise<void>;
+    _internal: {
+        store: StoreApi<RemoteFlowState> & {
+            persist: {
+                rehydrate: () => Promise<void>;
+            };
+        };
+        remoteStore: StoreApi<RemoteState>;
+        storage: Storage;
+    };
+};
+export type OneOf<union extends object, fallback extends object | undefined = undefined, keys extends keyof union = union extends union ? keyof union : never> = union extends infer item ? Pretty<{
+    [_key in keys as _key extends keyof item ? _key : never]: item[_key & keyof item];
+} & {
+    [_key in Exclude<keys, keyof item>]?: never;
+} & (fallback extends undefined ? {} : fallback)> : never;
+type Pretty<type> = {
+    [key in keyof type]: type[key];
+} & unknown;
+export {};