@bootnodedev/canton-connect 0.3.0

package/dist/CantonConnectProvider-CJ1yWGXz.js

@@ -0,0 +1,777 @@
+import { DappSDK, WalletConnectAdapter } from "@canton-network/dapp-sdk";
+import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
+import { assign, enqueueActions, fromCallback, fromPromise, setup, waitFor } from "xstate";
+import { useActorRef } from "@xstate/react";
+import { WALLET_DISABLED_REASON } from "@canton-network/core-types";
+import { jsx } from "react/jsx-runtime";
+//#region src/CantonConnectProvider/adapters.ts
+/** Builds the extra adapters for the SDK: WalletConnect when configured, plus any passed in. */
+const buildAdditionalAdapters = (config, networkId) => {
+	const adapters = [...config.additionalAdapters ?? []];
+	if (config.walletConnectProjectId !== void 0 && config.walletConnectProjectId !== "") adapters.push(WalletConnectAdapter.create({
+		projectId: config.walletConnectProjectId,
+		chainId: networkId,
+		metadata: {
+			name: config.appName,
+			description: config.appDescription ?? config.appName,
+			url: config.appUrl ?? (typeof window === "undefined" ? "" : window.location.origin),
+			icons: []
+		}
+	}));
+	return adapters;
+};
+//#endregion
+//#region src/connectError.ts
+const PICKER_DISMISSED = "User closed the wallet picker";
+/**
+* Raised by `guardedConnect` when it settles a connect the SDK left pending. The SDK's own
+* `connect()` is still running underneath, so whoever catches this retires the `DappSDK`.
+*
+* @example
+* if (err instanceof PickerClosedError) discardSdk()
+*
+* @internal
+*/
+var PickerClosedError = class extends Error {
+	constructor() {
+		super(PICKER_DISMISSED);
+		this.name = "PickerClosedError";
+	}
+};
+/**
+* Raised by the connect actor when its early init rejects, so the machine can tell an init
+* failure from a connect one: the SDK caches the rejection on the instance forever, and only a
+* replacement instance can genuinely retry. The SDK's own error rides in `cause`.
+*
+* @example
+* if (err instanceof InitFailedError) retireSdk()
+*/
+var InitFailedError = class extends Error {
+	constructor(cause) {
+		super("DappSDK.init() failed", { cause });
+		this.name = "InitFailedError";
+	}
+};
+/**
+* A connect the user walked away from: the picker was closed rather than a wallet failing.
+*
+* @example
+* if (error !== undefined && !(error instanceof ConnectCancelledError)) {
+*   toast.error(error.message)
+* }
+*
+* @category Errors
+*/
+var ConnectCancelledError = class extends Error {
+	constructor(cause) {
+		super("Wallet connection cancelled", { cause });
+		this.name = "ConnectCancelledError";
+	}
+};
+/** Whether a rejection carries a string `message`, as a JSON-RPC error object does. */
+const hasMessage = (cause) => typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string";
+/**
+* Hands `cause` back as an `Error`, wrapping what a wallet answered with over JSON-RPC.
+*
+* @example
+* const error = toError(await sdk.signMessage(params).catch((cause: unknown) => cause))
+* error.cause // the wallet's `{ code, message }` when that is what it sent
+*/
+const toError = (cause) => {
+	if (cause instanceof Error) return cause;
+	return new Error(hasMessage(cause) ? cause.message : String(cause), { cause });
+};
+/** Classifies what `sdk.connect()` threw, so the cancel path is decided once. */
+const toConnectError = (cause) => {
+	if (cause instanceof ConnectCancelledError) return cause;
+	return cause instanceof Error && cause.message === PICKER_DISMISSED ? new ConnectCancelledError(cause) : toError(cause);
+};
+//#endregion
+//#region src/CantonConnectProvider/useConnectBridge.ts
+/**
+* Turns the machine's `connect` event into a promise. The machine's own tags say when an attempt
+* has been answered, and its context carries what to raise.
+*/
+const useConnectBridge = (actorRef) => {
+	return useCallback(async () => {
+		actorRef.send({ type: "connect" });
+		const settled = await waitFor(actorRef, (snapshot) => snapshot.hasTag("connect.settled") || snapshot.hasTag("connect.failed") || snapshot.hasTag("connect.cancelled"));
+		if (settled.hasTag("connect.settled")) return;
+		if (settled.hasTag("connect.cancelled")) throw new ConnectCancelledError();
+		throw toConnectError(settled.context.lastConnectError);
+	}, [actorRef]);
+};
+//#endregion
+//#region src/walletAccount.ts
+/** Whether one raw account entry still has ledger rights to act as a party. */
+const isUsable = (account) => {
+	if (account.status === "initialized" || account.status === "removed") return false;
+	if (account.disabled === true) return account.reason === WALLET_DISABLED_REASON.NO_SIGNING_PROVIDER_MATCHED;
+	return true;
+};
+/** Filters a raw account list down to the ones still usable as a party. */
+const selectUsableAccounts = (accounts) => accounts.filter(isUsable);
+/** Picks the account flagged `primary`, falling back to the first if none is. */
+const selectPrimaryAccount = (accounts) => accounts.find((a) => a.primary) ?? accounts[0];
+/** Maps one raw account entry to the public `Party` shape the hooks expose. */
+const toParty = (account, fallbackNetworkId) => ({
+	partyId: account.partyId,
+	networkId: account.networkId ?? fallbackNetworkId,
+	namespace: account.namespace,
+	signingProviderId: account.signingProviderId,
+	...account.hint === void 0 ? {} : { name: account.hint },
+	...account.publicKey === void 0 ? {} : { publicKey: account.publicKey }
+});
+//#endregion
+//#region src/machine/accountsActors.ts
+/** Narrows a raw wallet-account list to the primary usable party, or none. */
+const toWalletAccounts = (accounts, networkId) => {
+	const primary = selectPrimaryAccount(selectUsableAccounts(accounts));
+	return { party: primary === void 0 ? void 0 : toParty(primary, networkId) };
+};
+/** Reads the wallet's account list once and resolves the primary usable party. */
+const readAccounts = fromPromise(async ({ input: { sdk, networkId } }) => toWalletAccounts(await sdk.listAccounts(), networkId));
+/** Forwards the wallet's own account-change pushes into the machine as `accounts.changed`. */
+const accountsEvents = fromCallback(({ sendBack, input: { sdk, networkId } }) => {
+	const listener = (accounts) => {
+		sendBack({
+			type: "accounts.changed",
+			accounts: toWalletAccounts(accounts, networkId)
+		});
+	};
+	sdk.onAccountsChanged(listener).catch(() => {});
+	return () => {
+		sdk.removeOnAccountsChanged(listener).catch(() => {});
+	};
+});
+//#endregion
+//#region src/machine/accountsMachine.ts
+/**
+* Reads the connected party once, then follows the wallet's own `accounts.changed` pushes.
+* Invoked as `connectionMachine`'s `accounts` child while a session is authenticated.
+*/
+const accountsMachine = setup({
+	actors: {
+		readAccounts,
+		accountsEvents
+	},
+	actions: {
+		applyAccounts: assign((_, params) => ({
+			...params.accounts,
+			error: void 0
+		})),
+		assignError: assign((_, params) => ({ error: params.error }))
+	},
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	}
+}).createMachine({
+	context: ({ input }) => ({
+		...input,
+		party: void 0,
+		error: void 0
+	}),
+	id: "accounts",
+	initial: "reading",
+	invoke: {
+		src: "accountsEvents",
+		input: ({ context: { sdk, networkId } }) => ({
+			sdk,
+			networkId
+		})
+	},
+	on: { "accounts.changed": {
+		target: ".ready",
+		actions: {
+			type: "applyAccounts",
+			params: ({ event: { accounts } }) => ({ accounts })
+		}
+	} },
+	states: {
+		reading: { invoke: {
+			src: "readAccounts",
+			input: ({ context: { sdk, networkId } }) => ({
+				sdk,
+				networkId
+			}),
+			onDone: {
+				target: "ready",
+				actions: {
+					type: "applyAccounts",
+					params: ({ event: { output } }) => ({ accounts: output })
+				}
+			},
+			onError: {
+				target: "unavailable",
+				actions: {
+					type: "assignError",
+					params: ({ event: { error } }) => ({ error })
+				}
+			}
+		} },
+		ready: {},
+		unavailable: {}
+	}
+});
+//#endregion
+//#region src/guardedConnect.ts
+const POLL_MS = 400;
+let nativeOpen;
+let inFlight = 0;
+let opened;
+/** Swaps in a `window.open` wrapper that captures the next popup, then restores itself. */
+const borrowOpen = () => {
+	if (nativeOpen !== void 0) return;
+	const native = window.open;
+	nativeOpen = native;
+	window.open = (...args) => {
+		const popup = native.apply(window, args);
+		if (popup) {
+			opened = popup;
+			window.open = native;
+			nativeOpen = void 0;
+		}
+		return popup;
+	};
+};
+/** Restores the native `window.open`, but only once no guarded connect is still in flight. */
+const returnOpen = () => {
+	if (nativeOpen === void 0 || inFlight > 0) return;
+	window.open = nativeOpen;
+	nativeOpen = void 0;
+};
+/** Posts the SDK picker's own result message, so its pending listener resolves as abandoned. */
+const settleAbandonedConnect = () => {
+	window.postMessage({
+		messageType: "SPLICE_WALLET_PICKER_RESULT",
+		providerId: "abandoned",
+		walletType: "browser"
+	}, window.location.origin);
+};
+/** Rejects when the caller abandons the connect, closing the picker window on the way out. */
+const abandonOn = (signal) => new Promise((_, reject) => {
+	if (signal === void 0) return;
+	const abandon = () => {
+		if (opened?.closed === false) opened.close();
+		if (inFlight === 1) settleAbandonedConnect();
+		reject(new ConnectCancelledError());
+	};
+	if (signal.aborted) {
+		abandon();
+		return;
+	}
+	signal.addEventListener("abort", abandon, { once: true });
+});
+/** Reports the wallet type from the picker's result message; call the return value to stop. */
+const watchForPick = (picked) => {
+	const listener = (event) => {
+		if (event.origin === window.location.origin && event.data?.messageType === "SPLICE_WALLET_PICKER_RESULT") picked(event.data.walletType);
+	};
+	window.addEventListener("message", listener);
+	return () => window.removeEventListener("message", listener);
+};
+/**
+* `sdk.connect()` with a watchdog on the popup the SDK opens. Call it only when no
+* `CantonConnectConfig.walletPicker` is set; a consumer's picker owns its own surface.
+*
+* @example
+* const result = await guardedConnect(sdk)
+* if (!result.isConnected) throw new Error(result.reason)
+*/
+const guardedConnect = (sdk, signal) => {
+	if (typeof window === "undefined") return sdk.connect();
+	inFlight += 1;
+	borrowOpen();
+	let seen = opened;
+	let watched = opened?.closed === false ? opened : void 0;
+	let poll;
+	let picked = false;
+	const unwatchPick = watchForPick((walletType) => {
+		picked = walletType === "browser";
+	});
+	const dismissed = new Promise((_resolve, reject) => {
+		poll = setInterval(() => {
+			if (opened !== seen) {
+				seen = opened;
+				watched = opened;
+			}
+			if (!picked && watched?.closed === true) {
+				if (inFlight === 1) settleAbandonedConnect();
+				reject(new PickerClosedError());
+			}
+		}, POLL_MS);
+	});
+	return Promise.race([
+		sdk.connect(),
+		dismissed,
+		abandonOn(signal)
+	]).finally(() => {
+		clearInterval(poll);
+		unwatchPick();
+		inFlight -= 1;
+		returnOpen();
+	});
+};
+//#endregion
+//#region src/machine/connectionActors.ts
+/** The in-flight or settled `init()` per sdk instance. */
+const initializations = /* @__PURE__ */ new WeakMap();
+/** Runs `sdk.init()` once per sdk instance and caches the result for every later caller. */
+const ensureInit = ({ sdk, initOptions }) => {
+	const started = initializations.get(sdk);
+	if (started !== void 0) return started;
+	const initialization = sdk.init({
+		defaultAdapters: [],
+		...initOptions
+	});
+	initializations.set(sdk, initialization);
+	initialization.catch((error) => {
+		console.error("canton-connect: DappSDK.init() failed, so no wallet can be discovered or connected. This is usually a bad adapter config — check `additionalAdapters` and `walletConnectProjectId` on CantonConnectConfig.", error);
+	});
+	return initialization;
+};
+/** Reads the wallet's status and returns it only when a session is standing, else null. */
+const standingSession = async (sdk) => {
+	const status = await sdk.status().catch(() => null);
+	return status?.connection?.isConnected ? { connection: status.connection } : null;
+};
+/** Resolves once the wallet answers, rejecting with the wallet's own error. */
+const connect = fromPromise(async ({ input, signal }) => {
+	const { sdk, guardPicker } = input;
+	try {
+		await ensureInit(input);
+	} catch (error) {
+		throw new InitFailedError(error);
+	}
+	try {
+		const connection = await (guardPicker ? guardedConnect(sdk, signal) : sdk.connect());
+		const walletAnswer = { connection };
+		if (connection.isConnected) return walletAnswer;
+		return await standingSession(sdk) ?? walletAnswer;
+	} catch (error) {
+		if (error instanceof PickerClosedError || error instanceof ConnectCancelledError) throw error;
+		const recovered = await standingSession(sdk);
+		if (recovered !== null) return recovered;
+		throw error;
+	}
+});
+/** Asks the wallet to end the session; resolves once it acknowledges. */
+const disconnect = fromPromise(({ input }) => input.sdk.disconnect());
+/** Boots the sdk through `ensureInit`, so `initializing` and `retiring` share one cache. */
+const init = fromPromise(({ input }) => ensureInit(input));
+/** Reads the wallet's status and recovers a standing session without opening the picker. */
+const restore = fromPromise(async ({ input }) => {
+	try {
+		const { connection } = await input.sdk.status();
+		if (connection === void 0) throw new Error("status answered without a connection");
+		return { connection };
+	} catch (error) {
+		console.debug("canton-connect: no session restored", error);
+		throw error;
+	}
+});
+/** Forwards the wallet's own status pushes into the machine as `wallet.statusChanged`. */
+const walletEvents = fromCallback(({ sendBack, input: { sdk } }) => {
+	const listener = ({ connection }) => {
+		if (connection === void 0) return;
+		sendBack({
+			type: "wallet.statusChanged",
+			status: { connection }
+		});
+	};
+	sdk.onStatusChanged(listener).catch(() => {});
+	return () => {
+		sdk.removeOnStatusChanged(listener).catch(() => {});
+	};
+});
+//#endregion
+//#region src/machine/connectionMachine.ts
+const DISCONNECT_TIMEOUT_MS = 1e4;
+/** Reduces the machine's internal states to the five-value `ConnectionStatus` hooks expose. */
+const toConnectionStatus = (snapshot) => {
+	if (snapshot.matches("connecting")) return "connecting";
+	if (snapshot.matches({ retiring: "changing" }) || snapshot.matches({ restoring: "changing" })) return "connecting";
+	if (snapshot.matches("session")) return "connected";
+	if (snapshot.matches("idle") || snapshot.matches("restoring") || snapshot.matches("initializing")) return "idle";
+	if (snapshot.matches("disconnecting")) return "disconnecting";
+	return "disconnected";
+};
+/** The transition an authenticated wallet answer takes, shared by `connect` and `restore`. */
+const landAuthenticated = {
+	guard: {
+		type: "isAuthenticated",
+		params: ({ event: { output } }) => ({ connection: output.connection })
+	},
+	target: "#connection.session.authenticated"
+};
+/** The exit from `disconnecting`, success and failure alike: nothing overlaps a disconnect. */
+const afterDisconnect = { target: "disconnected" };
+/** The exit `disconnecting` takes when the wallet never answers, on a replacement sdk. */
+const afterSilentDisconnect = {
+	actions: { type: "retireSdk" },
+	target: "disconnected"
+};
+/** The `init` invoke shared by `initializing` and `retiring`. Each caller resumes in a different
+* `restoring` state, so it names the `onDone` target. */
+const bootSdk = (onDone) => ({
+	src: "init",
+	input: ({ context }) => ({
+		sdk: context.sdk,
+		initOptions: context.initOptions
+	}),
+	onDone: { target: onDone },
+	onError: {
+		target: "#connection.failure",
+		actions: [{
+			type: "assignError",
+			params: ({ event: { error } }) => ({ error })
+		}, { type: "retireSdk" }]
+	}
+});
+/** The `connect` invoke. The caller names which `retiring` variant a closed picker lands in, so
+* a wallet change stays one through the retirement. */
+const askWallet = (retiringTarget) => ({
+	src: "connect",
+	input: ({ context }) => ({
+		sdk: context.sdk,
+		initOptions: context.initOptions,
+		guardPicker: context.guardPicker
+	}),
+	onDone: [landAuthenticated, {
+		target: "#connection.failure",
+		actions: {
+			type: "assignDeclined",
+			params: ({ event: { output } }) => ({ connection: output.connection })
+		}
+	}],
+	onError: [
+		{
+			guard: {
+				type: "isPickerClosed",
+				params: ({ event: { error } }) => ({ error })
+			},
+			actions: { type: "retireSdk" },
+			target: retiringTarget
+		},
+		{
+			guard: {
+				type: "isInitFailed",
+				params: ({ event: { error } }) => ({ error })
+			},
+			target: "#connection.failure",
+			actions: [{
+				type: "assignError",
+				params: ({ event: { error } }) => ({ error: error instanceof InitFailedError ? error.cause : error })
+			}, { type: "retireSdk" }]
+		},
+		{
+			target: "#connection.failure",
+			actions: {
+				type: "assignError",
+				params: ({ event: { error } }) => ({ error })
+			}
+		}
+	]
+});
+/** A connect attempt and the two exits that keep no session: the picker closing, and a cancel. */
+const connectAttempt = (retiringTarget) => ({
+	invoke: askWallet(retiringTarget),
+	on: { "connect.cancel": {
+		actions: { type: "retireSdk" },
+		target: retiringTarget
+	} }
+});
+/**
+* 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
+*/
+const connectionMachine = setup({
+	actors: {
+		connect,
+		disconnect,
+		init,
+		restore,
+		walletEvents,
+		accounts: accountsMachine
+	},
+	actions: {
+		assignError: assign((_, params) => ({ lastConnectError: params.error })),
+		assignDeclined: assign((_, params) => ({ lastConnectError: new Error(params.connection.reason ?? params.connection.networkReason ?? "wallet declined connection") })),
+		forgetError: assign({ lastConnectError: void 0 }),
+		retireSdk: enqueueActions(({ enqueue }) => {
+			enqueue(({ context }) => {
+				Object.assign(context.sdk, { walletPicker: () => Promise.reject(new ConnectCancelledError()) });
+			});
+			enqueue.assign({ sdk: ({ context }) => context.createSdk() });
+		})
+	},
+	guards: {
+		isAuthenticated: (_, params) => params.connection?.isConnected === true,
+		isPickerClosed: (_, params) => params.error instanceof PickerClosedError,
+		isInitFailed: (_, params) => params.error instanceof InitFailedError
+	},
+	delays: { disconnectTimeout: DISCONNECT_TIMEOUT_MS },
+	types: {
+		children: {},
+		context: {},
+		input: {},
+		tags: {},
+		events: {}
+	}
+}).createMachine({
+	context: ({ input }) => ({
+		...input,
+		sdk: input.createSdk(),
+		lastConnectError: void 0,
+		party: void 0
+	}),
+	id: "connection",
+	initial: "idle",
+	on: { "connectError.reset": { actions: { type: "forgetError" } } },
+	states: {
+		idle: {
+			tags: ["disconnect.settled"],
+			on: {
+				connect: { target: "connecting" },
+				restore: { target: "initializing" }
+			}
+		},
+		disconnected: {
+			tags: ["connect.cancelled", "disconnect.settled"],
+			entry: { type: "forgetError" },
+			on: {
+				connect: { target: "connecting" },
+				restore: { target: "initializing" }
+			}
+		},
+		connecting: {
+			tags: ["connecting"],
+			entry: { type: "forgetError" },
+			initial: "new",
+			states: {
+				new: connectAttempt("#connection.retiring.new"),
+				changing: connectAttempt("#connection.retiring.changing")
+			},
+			on: { disconnect: { target: "disconnecting" } }
+		},
+		session: {
+			initial: "unauthenticated",
+			invoke: {
+				src: "walletEvents",
+				input: ({ context }) => ({ sdk: context.sdk })
+			},
+			states: {
+				authenticated: {
+					initial: "reading",
+					exit: assign({ party: void 0 }),
+					invoke: {
+						src: "accounts",
+						id: "accounts",
+						input: ({ context }) => ({
+							sdk: context.sdk,
+							networkId: context.networkId
+						}),
+						onSnapshot: [{
+							guard: ({ event }) => event.snapshot.matches("ready"),
+							target: ".ready",
+							actions: assign(({ event }) => ({
+								party: event.snapshot.context.party,
+								lastConnectError: void 0
+							}))
+						}, {
+							guard: ({ event }) => event.snapshot.matches("unavailable"),
+							target: ".unavailable",
+							actions: assign(({ event }) => ({ lastConnectError: event.snapshot.context.error }))
+						}]
+					},
+					states: {
+						reading: {
+							tags: ["connecting"],
+							on: { "connect.cancel": { target: "#connection.disconnecting" } }
+						},
+						ready: { tags: ["connect.settled"] },
+						unavailable: { tags: ["connect.failed"] }
+					},
+					on: { "wallet.statusChanged": [{ guard: {
+						type: "isAuthenticated",
+						params: ({ event: { status } }) => ({ connection: status.connection })
+					} }, { target: "unauthenticated" }] }
+				},
+				unauthenticated: {
+					tags: ["connect.settled", "unauthenticated"],
+					on: { "wallet.statusChanged": {
+						guard: {
+							type: "isAuthenticated",
+							params: ({ event: { status } }) => ({ connection: status.connection })
+						},
+						target: "authenticated"
+					} }
+				}
+			},
+			on: {
+				connect: { target: "connecting.changing" },
+				disconnect: { target: "disconnecting" },
+				restore: { target: "initializing" }
+			}
+		},
+		failure: {
+			tags: ["connect.failed"],
+			on: {
+				connect: { target: "connecting" },
+				disconnect: { target: "disconnecting" },
+				restore: { target: "initializing" }
+			}
+		},
+		retiring: {
+			tags: ["connect.cancelled"],
+			entry: { type: "forgetError" },
+			initial: "new",
+			states: {
+				new: { invoke: bootSdk("#connection.restoring.new") },
+				changing: { invoke: bootSdk("#connection.restoring.changing") }
+			},
+			on: {
+				connect: { target: "connecting" },
+				disconnect: { target: "disconnecting" }
+			}
+		},
+		restoring: {
+			initial: "new",
+			states: {
+				new: {},
+				changing: {}
+			},
+			invoke: {
+				src: "restore",
+				input: ({ context }) => ({ sdk: context.sdk }),
+				onDone: [landAuthenticated, { target: "disconnected" }],
+				onError: { target: "disconnected" }
+			},
+			on: {
+				connect: { target: "connecting" },
+				disconnect: { target: "disconnecting" }
+			}
+		},
+		initializing: {
+			invoke: bootSdk("#connection.restoring.new"),
+			on: {
+				connect: { target: "connecting" },
+				disconnect: { target: "disconnecting" }
+			}
+		},
+		disconnecting: {
+			entry: { type: "forgetError" },
+			invoke: {
+				src: "disconnect",
+				input: ({ context }) => ({ sdk: context.sdk }),
+				onDone: afterDisconnect,
+				onError: afterDisconnect
+			},
+			after: { disconnectTimeout: afterSilentDisconnect }
+		}
+	}
+});
+//#endregion
+//#region src/CantonConnectProvider/useConnectionActor.ts
+/** Creates the connection actor and sends `restore` once it starts, so a prior session resumes. */
+const useConnectionActor = (input) => {
+	const actorRef = useActorRef(connectionMachine, { input });
+	useEffect(() => {
+		actorRef.send({ type: "restore" });
+	}, [actorRef]);
+	return actorRef;
+};
+//#endregion
+//#region src/CantonConnectProvider/useDisconnectBridge.ts
+/** Resolves once the wallet has been asked, whichever state the machine started from. */
+const useDisconnectBridge = (actorRef) => useCallback(async () => {
+	actorRef.send({ type: "disconnect" });
+	await waitFor(actorRef, (snapshot) => snapshot.hasTag("disconnect.settled"));
+}, [actorRef]);
+//#endregion
+//#region src/CantonConnectProvider/index.tsx
+const CantonConnectContext = createContext(void 0);
+/**
+* The whole context in one read, and the escape hatch behind every other hook here. Reach for a
+* narrower hook unless a component needs several slices at once; this one hands back the config,
+* the connection to select off, and the three actions.
+*
+* @throws with no {@link CantonConnectProvider} above it.
+*
+* @example
+* const { config, connection } = useCantonConnectContext()
+* const snapshot = connection.getSnapshot()
+*
+* @category Hooks
+*/
+const useCantonConnectContext = () => {
+	const ctx = useContext(CantonConnectContext);
+	if (ctx === void 0) throw new Error("canton-connect hooks must be used inside a <CantonConnectProvider>");
+	return ctx;
+};
+/**
+* Hands the connection machine what it needs to build its own `DappSDK`, and publishes the actor
+* that goes through the states, plus the two bridges that drive it. Nothing here selects: a
+* provider that pre-selected the whole session re-rendered every consumer on every tick of it.
+* The hooks mirror wagmi's naming, not its TanStack Query result shapes.
+*
+* @example
+* <CantonConnectProvider config={{ appName: 'Vesting', networkId: 'canton:local' }}>
+*   <App />
+* </CantonConnectProvider>
+*
+* @category Components
+*/
+const CantonConnectProvider = ({ config, children }) => {
+	const networkId = config.networkId ?? "canton:local";
+	const additionalAdapters = useMemo(() => buildAdditionalAdapters({
+		appName: config.appName,
+		appDescription: config.appDescription,
+		appUrl: config.appUrl,
+		walletConnectProjectId: config.walletConnectProjectId,
+		additionalAdapters: config.additionalAdapters
+	}, networkId), [
+		config.appName,
+		config.appDescription,
+		config.appUrl,
+		config.walletConnectProjectId,
+		config.additionalAdapters,
+		networkId
+	]);
+	const actorRef = useConnectionActor({
+		createSdk: () => new DappSDK({ walletPicker: config.walletPicker }),
+		initOptions: { additionalAdapters },
+		guardPicker: config.walletPicker === void 0,
+		networkId
+	});
+	const resetConnectError = useCallback(() => actorRef.send({ type: "connectError.reset" }), [actorRef]);
+	const cancelConnect = useCallback(() => actorRef.send({ type: "connect.cancel" }), [actorRef]);
+	const connect = useConnectBridge(actorRef);
+	const disconnect = useDisconnectBridge(actorRef);
+	const value = useMemo(() => ({
+		config,
+		connection: actorRef,
+		connect,
+		cancelConnect,
+		disconnect,
+		resetConnectError
+	}), [
+		config,
+		actorRef,
+		connect,
+		cancelConnect,
+		disconnect,
+		resetConnectError
+	]);
+	return /* @__PURE__ */ jsx(CantonConnectContext.Provider, {
+		value,
+		children
+	});
+};
+//#endregion
+export { toConnectionStatus as a, toError as c, connectionMachine as i, CantonConnectProvider as n, ConnectCancelledError as o, useCantonConnectContext as r, toConnectError as s, CantonConnectContext as t };