@bootnodedev/canton-connect 0.3.0

package/dist/testing/index.js

@@ -0,0 +1,291 @@
+import { i as connectionMachine, t as CantonConnectContext } from "../CantonConnectProvider-CJ1yWGXz.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { createActor } from "xstate";
+import { CANTON_ANNOUNCE_PROVIDER_EVENT, CANTON_REQUEST_PROVIDER_EVENT, WalletEvent } from "@canton-network/core-types";
+import { jsx } from "react/jsx-runtime";
+//#region src/testing/autoPicker.ts
+/**
+* A `walletPicker` that selects with no UI, for tests and headless dev flows: the entry whose
+* `providerId` matches `pick`, or the first discovered one.
+*
+* @throws when no discovered entry matches `pick`, so a test naming a wallet that never registered
+* fails at the picker rather than at the connect.
+*
+* @example
+* const config = { appName: 'Vesting', walletPicker: createAutoPicker('mock') }
+*
+* @category Utilities
+*/
+const createAutoPicker = (pick) => async (entries) => {
+	const chosen = pick === void 0 ? entries[0] : entries.find((entry) => entry.providerId === pick);
+	if (chosen === void 0) throw new Error(`auto-picker: no wallet matching ${pick ?? "(first)"}`);
+	return chosen;
+};
+//#endregion
+//#region src/testing/connectionInput.ts
+/** A `WalletSdk` method stand-in that returns a promise which never settles. */
+const pending = () => new Promise(() => {});
+/** Every `WalletSdk` method left hanging, so a test only stubs the ones its path reaches. */
+const unstubbed = {
+	connect: pending,
+	disconnect: pending,
+	init: pending,
+	ledgerApi: pending,
+	listAccounts: pending,
+	onAccountsChanged: pending,
+	onStatusChanged: pending,
+	onTxChanged: pending,
+	prepareExecuteAndWait: pending,
+	removeOnAccountsChanged: pending,
+	removeOnStatusChanged: pending,
+	removeOnTxChanged: pending,
+	signMessage: pending,
+	status: pending
+};
+/**
+* Machine input for a test actor, over a double satisfying the `WalletSdk` the machine types.
+* Whatever the double leaves out never settles, and every `createSdk()` hands back a fresh object,
+* as `new DappSDK` does — so a retirement changes `context.sdk` here too.
+*
+* @example
+* const actor = createActor(machine, { input: connectionInput(sdkDouble) })
+*/
+const connectionInput = (sdk = {}, overrides = {}) => ({
+	createSdk: () => ({
+		...unstubbed,
+		...sdk
+	}),
+	initOptions: {},
+	guardPicker: false,
+	networkId: "canton:local",
+	...overrides
+});
+//#endregion
+//#region src/testing/fakeSession.tsx
+const CONFIG = { appName: "fake-session" };
+const NO_SDK = {};
+/** A `sdk` wrapper that throws naming the method for anything the test never stubbed. */
+const refusingSdk = (supplied) => new Proxy({}, { get: (_, key) => {
+	const method = supplied[key];
+	if (method === void 0) throw new Error(`fake session has no sdk.${String(key)} — drive the real provider for that`);
+	return method;
+} });
+/** Turns a `SessionShape` into the state value the real machine would hold for it. */
+const toStateValue = ({ isLocked, readingAccounts, status }) => {
+	if (status !== "connected") return status;
+	if (isLocked) return { session: "unauthenticated" };
+	return { session: { authenticated: readingAccounts ? "reading" : "ready" } };
+};
+/** Starts a real `connectionMachine` actor rehydrated at the given `SessionShape`. */
+const startSession = (shape, party, connectError, sdk) => {
+	const input = connectionInput({}, { createSdk: () => sdk });
+	const snapshot = connectionMachine.resolveState({
+		value: toStateValue(shape),
+		context: {
+			...input,
+			sdk,
+			lastConnectError: connectError,
+			party: shape.status === "connected" ? party : void 0
+		}
+	});
+	return createActor(connectionMachine, {
+		input,
+		snapshot
+	}).start();
+};
+/**
+* Stands in for `CantonConnectProvider` with the session already in a given shape, so a component
+* test asserts on markup without paying the SDK's discovery sleeps or its connect flow. The shape
+* is a real `connectionMachine` actor rehydrated at the state the props ask for, so the hooks
+* select from it exactly as they do in the app. `connect` and `disconnect` move the session, but
+* reach for the real provider plus `createMockAdapter` to test connecting itself — the intermediate
+* states here are not the SDK's.
+*
+* @example
+* render(
+*   <FakeSessionProvider status="connected" party={party}>
+*     <ConnectButton />
+*   </FakeSessionProvider>,
+* )
+*
+* @category Components
+*/
+const FakeSessionProvider = ({ children, connectError, isLocked = false, party, readingAccounts = false, sdk = NO_SDK, status: initialStatus = "disconnected" }) => {
+	const [status, setStatus] = useState(initialStatus);
+	const connection = useMemo(() => startSession({
+		isLocked,
+		readingAccounts,
+		status
+	}, party, connectError, refusingSdk(sdk)), [
+		connectError,
+		isLocked,
+		party,
+		readingAccounts,
+		sdk,
+		status
+	]);
+	useEffect(() => () => connection.stop(), [connection]);
+	const connect = useCallback(async () => {
+		setStatus("connected");
+	}, []);
+	const disconnect = useCallback(async () => {
+		setStatus("disconnected");
+	}, []);
+	const value = useMemo(() => ({
+		config: CONFIG,
+		connection,
+		connect,
+		cancelConnect: () => connection.send({ type: "connect.cancel" }),
+		disconnect,
+		resetConnectError: () => connection.send({ type: "connectError.reset" })
+	}), [
+		connection,
+		connect,
+		disconnect
+	]);
+	return /* @__PURE__ */ jsx(CantonConnectContext.Provider, {
+		value,
+		children
+	});
+};
+//#endregion
+//#region src/testing/fakeWallet.ts
+const JSON_RPC_METHOD_NOT_FOUND = -32601;
+const FAKE_PUBLIC_KEY = "fake-public-key";
+const FAKE_SIGNING_PROVIDER_ID = "fake";
+const FAKE_NETWORK_ID = "canton:local";
+const FAKE_WALLET_STATUS = "allocated";
+/** Shapes one `FakeWalletAccount` into the `Wallet` object `listAccounts` reports. */
+const toWallet = (account) => ({
+	primary: account.primary === true,
+	partyId: account.partyId,
+	status: FAKE_WALLET_STATUS,
+	hint: account.name ?? account.partyId,
+	publicKey: account.publicKey ?? FAKE_PUBLIC_KEY,
+	namespace: account.partyId.split("::")[1] ?? account.partyId,
+	networkId: account.networkId ?? FAKE_NETWORK_ID,
+	signingProviderId: FAKE_SIGNING_PROVIDER_ID
+});
+/**
+* A fake CIP-0103 extension wallet for tests. It speaks the real postMessage protocol, so it
+* exercises the SDK's genuine `ExtensionAdapter` rather than a stub. Answers `connect`, `status`,
+* `listAccounts` and `disconnect`; anything else rejects naming the method. Reach for
+* `createMockAdapter` instead where the transport is not what is under test.
+*
+* @example
+* const wallet = createFakeWallet({ id: 'mock' })
+* wallet.push('statusChanged', { connection: { isConnected: false } })
+* wallet.dispose()
+*
+* @category Utilities
+*/
+const createFakeWallet = (options) => {
+	const target = options.target ?? options.id;
+	const accounts = options.accounts ?? [{
+		partyId: `${options.id}::1220abcd`,
+		primary: true
+	}];
+	let statusCallCount = 0;
+	const announce = () => {
+		window.dispatchEvent(new CustomEvent(CANTON_ANNOUNCE_PROVIDER_EVENT, { detail: {
+			id: options.id,
+			name: options.name ?? options.id,
+			target
+		} }));
+	};
+	const nextStatusIsConnected = () => {
+		const responses = options.statusResponses;
+		if (responses === void 0 || responses.length === 0) return true;
+		const index = Math.min(statusCallCount, responses.length - 1);
+		statusCallCount += 1;
+		return responses[index];
+	};
+	const buildStatus = () => ({
+		provider: {
+			id: options.id,
+			providerType: "browser"
+		},
+		connection: {
+			isConnected: nextStatusIsConnected(),
+			isNetworkConnected: true
+		}
+	});
+	const buildConnect = () => ({
+		isConnected: true,
+		isNetworkConnected: true
+	});
+	const responses = {
+		status: buildStatus,
+		connect: buildConnect,
+		listAccounts: () => accounts.map(toWallet),
+		disconnect: () => ({})
+	};
+	const answer = (method) => {
+		const handler = responses[method];
+		if (handler === void 0) return { error: {
+			code: JSON_RPC_METHOD_NOT_FOUND,
+			message: `createFakeWallet does not implement "${method}"`
+		} };
+		return { result: handler() };
+	};
+	const onMessage = (event) => {
+		const data = event.data;
+		if (data?.type === void 0) return;
+		if (data.target !== void 0 && data.target !== target) return;
+		if (data.type === WalletEvent.SPLICE_WALLET_EXT_READY) {
+			window.postMessage({
+				type: WalletEvent.SPLICE_WALLET_EXT_ACK,
+				target
+			}, "*");
+			return;
+		}
+		const requestId = data.request?.id;
+		if (!(data.type === WalletEvent.SPLICE_WALLET_REQUEST && requestId !== void 0 && requestId !== null)) return;
+		const method = data.request?.method ?? "";
+		window.postMessage({
+			type: WalletEvent.SPLICE_WALLET_RESPONSE,
+			response: {
+				jsonrpc: "2.0",
+				id: requestId,
+				...answer(method)
+			}
+		}, "*");
+	};
+	const push = (method, params) => {
+		window.postMessage({
+			type: WalletEvent.SPLICE_WALLET_REQUEST,
+			request: {
+				jsonrpc: "2.0",
+				method,
+				params
+			},
+			target
+		}, "*");
+	};
+	window.addEventListener("message", onMessage);
+	window.addEventListener(CANTON_REQUEST_PROVIDER_EVENT, announce);
+	queueMicrotask(announce);
+	return {
+		announce,
+		push,
+		dispose: () => {
+			window.removeEventListener("message", onMessage);
+			window.removeEventListener(CANTON_REQUEST_PROVIDER_EVENT, announce);
+		}
+	};
+};
+//#endregion
+//#region src/testing/pause.ts
+/**
+* Real-timer sleep, which is how a suite awaits a promise-settling send; `pause(0)` flushes the
+* pending macrotasks. Reach for it over `waitFor`, whose retry window turns a genuine red into a
+* timeout rather than a failed assertion.
+*
+* @example
+* await pause(0) // one macrotask on, so the send above has settled
+*
+* @category Utilities
+*/
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+//#endregion
+export { FakeSessionProvider, createAutoPicker, createFakeWallet, pause };

package/dist/types-Deu_03jh.d.ts

@@ -0,0 +1,385 @@
+import { DappSDK, ProviderAdapter, StatusEvent, TxChangedEvent, WalletPickerFn } from "@canton-network/dapp-sdk";
+import { ActorRefFrom } from "xstate";
+//#region src/machine/connectionActors.d.ts
+/**
+ * What `DappSDK.init` accepts, read off the SDK rather than restated. The init actor defaults
+ * `defaultAdapters` to empty, dropping the SDK's bundled dev gateway, and whatever is set here
+ * wins over that default.
+ *
+ * @example
+ * const initOptions: InitOptions = { additionalAdapters: [createMockAdapter()] }
+ *
+ * @category Types
+ */
+type InitOptions = NonNullable<Parameters<DappSDK['init']>[0]>;
+/** Input for the `init` actor: the sdk slice and options `ensureInit` needs to boot it. */
+type InitInput = {
+  sdk: Pick<DappSDK, 'init'>;
+  initOptions: InitOptions;
+};
+/** Input for the `connect` actor: enough sdk to init, connect, and recover a session. */
+type ConnectInput = {
+  sdk: Pick<DappSDK, 'connect' | 'init' | 'status'>;
+  initOptions: InitOptions;
+  guardPicker: boolean;
+};
+/** Input for the `restore` actor: just enough sdk to read the wallet's status. */
+type RestoreInput = {
+  sdk: Pick<DappSDK, 'status'>;
+};
+/** Input for the `disconnect` actor: the sdk slice it calls to end the session. */
+type DisconnectInput = {
+  sdk: Pick<DappSDK, 'disconnect'>;
+};
+/** Input for the `walletEvents` actor: the sdk slice it subscribes to and unsubscribes from. */
+type WalletEventsInput = {
+  sdk: Pick<DappSDK, 'onStatusChanged' | 'removeOnStatusChanged'>;
+};
+//#endregion
+//#region src/machine/accountsMachine.d.ts
+/** The result of an account read, initial or pushed: the party found, or none. */
+type WalletAccounts = {
+  party: Party | undefined;
+};
+//#endregion
+//#region src/machine/accountsActors.d.ts
+/** Input shared by `readAccounts` and `accountsEvents`: the sdk slice plus the network id. */
+type AccountsInput = {
+  sdk: Pick<DappSDK, 'listAccounts' | 'onAccountsChanged' | 'removeOnAccountsChanged'>;
+  networkId: string;
+};
+//#endregion
+//#region src/machine/connectionMachine.d.ts
+/** The wallet's connection status, narrowed from the SDK's `StatusEvent`. */
+type WalletStatusUpdate = Pick<StatusEvent, 'connection'>;
+/**
+ * What the machine needs to build and drive its own `DappSDK`. Read once, at actor creation: as in
+ * wagmi, a config swapped afterwards reaches the hooks but not the connection lifecycle.
+ *
+ * @example
+ * import { DappSDK } from '@canton-network/dapp-sdk'
+ * import { createActor } from 'xstate'
+ * import { connectionMachine } from '#src/machine/connectionMachine'
+ *
+ * const createSdk = () => new DappSDK({})
+ * const input = { createSdk, initOptions: {}, guardPicker: true, networkId: 'canton:local' }
+ * createActor(connectionMachine, { input })
+ *
+ * @category Types
+ */
+type ConnectionInput = {
+  createSdk: () => WalletSdk;
+  initOptions: InitOptions;
+  guardPicker: boolean;
+  networkId: string;
+};
+/** What the machine carries beyond its input: the sdk it drives, the last failure, the party. */
+type ConnectionContext = ConnectionInput & {
+  sdk: WalletSdk;
+  lastConnectError: unknown;
+  party: Party | undefined;
+};
+/**
+ * The lifecycle itself: what a connect, a restore, a lock and a disconnect mean, and the tags the
+ * bridges and hooks read off them. `CantonConnectProvider` runs it; reach for it directly only to
+ * drive a session in a test.
+ *
+ * @category Types
+ */
+declare const connectionMachine: import("xstate").StateMachine<ConnectionContext, {
+  type: "connect";
+} | {
+  type: "connect.cancel";
+} | {
+  type: "connectError.reset";
+} | {
+  type: "disconnect";
+} | {
+  type: "restore";
+} | {
+  type: "wallet.statusChanged";
+  status: WalletStatusUpdate;
+}, {
+  [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<WalletStatusUpdate, ConnectInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<null, DisconnectInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<void, InitInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<WalletStatusUpdate, RestoreInput, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, WalletEventsInput, import("xstate").EventObject>> | undefined;
+  accounts?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<AccountsInput & WalletAccounts & {
+    error: unknown;
+  }, {
+    type: "accounts.changed";
+    accounts: WalletAccounts;
+  }, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<WalletAccounts, AccountsInput, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, AccountsInput, import("xstate").EventObject>> | undefined;
+  }, {
+    src: "readAccounts";
+    logic: import("xstate").PromiseActorLogic<WalletAccounts, AccountsInput, import("xstate").EventObject>;
+    id: string | undefined;
+  } | {
+    src: "accountsEvents";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, AccountsInput, import("xstate").EventObject>;
+    id: string | undefined;
+  }, {
+    type: "applyAccounts";
+    params: {
+      accounts: WalletAccounts;
+    };
+  } | {
+    type: "assignError";
+    params: {
+      error: unknown;
+    };
+  }, never, never, "reading" | "ready" | "unavailable", string, AccountsInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "accounts";
+    states: {
+      readonly reading: {};
+      readonly ready: {};
+      readonly unavailable: {};
+    };
+  }>> | undefined;
+}, {
+  src: "init";
+  logic: import("xstate").PromiseActorLogic<void, InitInput, import("xstate").EventObject>;
+  id: string | undefined;
+} | {
+  src: "connect";
+  logic: import("xstate").PromiseActorLogic<WalletStatusUpdate, ConnectInput, import("xstate").EventObject>;
+  id: string | undefined;
+} | {
+  src: "disconnect";
+  logic: import("xstate").PromiseActorLogic<null, DisconnectInput, import("xstate").EventObject>;
+  id: string | undefined;
+} | {
+  src: "restore";
+  logic: import("xstate").PromiseActorLogic<WalletStatusUpdate, RestoreInput, import("xstate").EventObject>;
+  id: string | undefined;
+} | {
+  src: "walletEvents";
+  logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, WalletEventsInput, import("xstate").EventObject>;
+  id: string | undefined;
+} | {
+  src: "accounts";
+  logic: import("xstate").StateMachine<AccountsInput & WalletAccounts & {
+    error: unknown;
+  }, {
+    type: "accounts.changed";
+    accounts: WalletAccounts;
+  }, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<WalletAccounts, AccountsInput, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, AccountsInput, import("xstate").EventObject>> | undefined;
+  }, {
+    src: "readAccounts";
+    logic: import("xstate").PromiseActorLogic<WalletAccounts, AccountsInput, import("xstate").EventObject>;
+    id: string | undefined;
+  } | {
+    src: "accountsEvents";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, AccountsInput, import("xstate").EventObject>;
+    id: string | undefined;
+  }, {
+    type: "applyAccounts";
+    params: {
+      accounts: WalletAccounts;
+    };
+  } | {
+    type: "assignError";
+    params: {
+      error: unknown;
+    };
+  }, never, never, "reading" | "ready" | "unavailable", string, AccountsInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "accounts";
+    states: {
+      readonly reading: {};
+      readonly ready: {};
+      readonly unavailable: {};
+    };
+  }>;
+  id: "accounts";
+}, {
+  type: "assignError";
+  params: {
+    error: unknown;
+  };
+} | {
+  type: "assignDeclined";
+  params: {
+    connection: WalletStatusUpdate["connection"];
+  };
+} | {
+  type: "forgetError";
+  params: import("xstate").NonReducibleUnknown;
+} | {
+  type: "retireSdk";
+  params: import("xstate").NonReducibleUnknown;
+}, {
+  type: "isAuthenticated";
+  params: {
+    connection: WalletStatusUpdate["connection"] | undefined;
+  };
+} | {
+  type: "isPickerClosed";
+  params: {
+    error: unknown;
+  };
+} | {
+  type: "isInitFailed";
+  params: {
+    error: unknown;
+  };
+}, "disconnectTimeout", "idle" | "disconnecting" | "disconnected" | "initializing" | "failure" | {
+  connecting: "new" | "changing";
+} | {
+  session: "unauthenticated" | {
+    authenticated: "reading" | "ready" | "unavailable";
+  };
+} | {
+  retiring: "new" | "changing";
+} | {
+  restoring: "new" | "changing";
+}, "connecting" | "connect.settled" | "connect.failed" | "connect.cancelled" | "unauthenticated" | "disconnect.settled", ConnectionInput, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+  id: "connection";
+  states: {
+    readonly idle: {};
+    readonly disconnected: {};
+    readonly connecting: {
+      states: {
+        readonly new: {};
+        readonly changing: {};
+      };
+    };
+    readonly session: {
+      states: {
+        readonly authenticated: {
+          states: {
+            readonly reading: {};
+            readonly ready: {};
+            readonly unavailable: {};
+          };
+        };
+        readonly unauthenticated: {};
+      };
+    };
+    readonly failure: {};
+    readonly retiring: {
+      states: {
+        readonly new: {};
+        readonly changing: {};
+      };
+    };
+    readonly restoring: {
+      states: {
+        readonly new: {};
+        readonly changing: {};
+      };
+    };
+    readonly initializing: {};
+    readonly disconnecting: {};
+  };
+}>;
+/**
+ * The running connection machine. Consumers reach it narrowed to {@link ConnectionSubscription},
+ * so `send` stays inside this package.
+ *
+ * @category Types
+ */
+type ConnectionActorRef = ActorRefFrom<typeof connectionMachine>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * The slice of `DappSDK` this package calls. Deliberately narrower than the class: it states
+ * which methods the wrapper supports, and a real `DappSDK` satisfies it structurally.
+ *
+ * @category Types
+ */
+type WalletSdk = Pick<DappSDK, 'init' | 'connect' | 'disconnect' | 'status' | 'listAccounts' | 'onStatusChanged' | 'removeOnStatusChanged' | 'onAccountsChanged' | 'removeOnAccountsChanged' | 'onTxChanged' | 'removeOnTxChanged' | 'ledgerApi' | 'signMessage' | 'prepareExecuteAndWait'>;
+/**
+ * `'idle'` is "not determined yet", not "disconnected": gate a connect button on `'disconnected'`,
+ * or a returning user is turned away before the boot restore runs. `'disconnecting'` is the session
+ * tearing down; keep connect disabled until it settles, so a new connect never overlaps it.
+ *
+ * @example
+ * const { status } = useParty()
+ * if (status === 'idle') return null
+ * return status === 'disconnected' ? <ConnectButton /> : <App />
+ *
+ * @category Types
+ */
+type ConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected';
+/**
+ * Canton's terms: a local party lives under the hosting participant's namespace and the participant
+ * signs for it; an external party lives under its own key's and signs for itself.
+ *
+ * @category Types
+ */
+type PartyType = 'local' | 'external';
+/**
+ * The connected account, normalized from the wallet's CIP-0103 account entry. `networkId` falls
+ * back to `CantonConnectConfig.networkId` where the wallet reports none. `namespace` and
+ * `signingProviderId` come through as reported; CIP-0103 names no `signingProviderId` values.
+ *
+ * @category Types
+ */
+interface Party {
+  partyId: string;
+  networkId: string;
+  namespace: string;
+  signingProviderId: string;
+  name?: string;
+  publicKey?: string;
+}
+/**
+ * Wiring for `CantonConnectProvider`. From `appName` alone a local dev app works: `canton:local` as
+ * the network id and the WalletConnect chain id, `appName` as the description, the page origin as
+ * the url, and the SDK's popup as the picker, guarded so closing it rejects — pass a `walletPicker`
+ * and that surface is yours. The app fields stay inert until `walletConnectProjectId` (Reown) is set.
+ *
+ * @example
+ * const config: CantonConnectConfig = { appName: 'Vesting', networkId: 'canton:devnet' }
+ *
+ * @category Configuration
+ */
+interface CantonConnectConfig {
+  appName: string;
+  appDescription?: string;
+  appUrl?: string;
+  networkId?: string;
+  walletConnectProjectId?: string;
+  walletPicker?: WalletPickerFn;
+  additionalAdapters?: ProviderAdapter[];
+}
+/**
+ * Mirrored from the SDK's `txChanged` event as a command moves through
+ * pending, signed, executed or failed.
+ *
+ * @category Types
+ */
+interface TxStatusSnapshot {
+  status: TxChangedEvent['status'];
+  commandId: TxChangedEvent['commandId'];
+  payload?: unknown;
+}
+/**
+ * The connection machine as `useSelector` sees it: subscribe and read, never send. Narrowed from
+ * the actor ref so `connect` and `disconnect` stay the only senders — a transition asked for
+ * anywhere else is a lifecycle rule living outside the machine.
+ *
+ * @example
+ * import type { ConnectionSubscription } from '#src/types'
+ *
+ * const partyOf = (connection: ConnectionSubscription) => connection.getSnapshot().context.party
+ *
+ * @category Types
+ */
+type ConnectionSubscription = Pick<ConnectionActorRef, 'getSnapshot' | 'subscribe'>;
+/**
+ * One connection and the actions on it, published once. Every hook selects its slice off
+ * `connection`: prefer the narrower hooks and reach for this only when none exposes the slice.
+ * The four actions are `useConnect`'s own, documented there.
+ *
+ * @category Types
+ */
+interface CantonConnectContextValue {
+  config: CantonConnectConfig;
+  connection: ConnectionSubscription;
+  connect: () => Promise<void>;
+  cancelConnect: () => void;
+  disconnect: () => Promise<void>;
+  resetConnectError: () => void;
+}
+//#endregion
+export { Party as a, WalletSdk as c, ConnectionSubscription as i, ConnectionInput as l, CantonConnectContextValue as n, PartyType as o, ConnectionStatus as r, TxStatusSnapshot as s, CantonConnectConfig as t, InitOptions as u };