@bootnodedev/canton-connect 0.4.0 → 0.5.0

package/README.md

@@ -61,7 +61,7 @@ be present whether or not you set `walletConnectProjectId`. Only the session is
 import {
   CantonConnectProvider,
   useConnect,
-  useParty,
+  useAccount,
   useWalletStatus,
   useSignMessage,
   useExecute,
@@ -78,7 +78,7 @@ function App() {
 
 function Dapp() {
   const { connect, isPending, isConnected, error } = useConnect()
-  const { party } = useParty()
+  const { account } = useAccount()
   const { isLocked } = useWalletStatus()
   const { signMessage } = useSignMessage()
   const { execute } = useExecute()
@@ -99,7 +99,7 @@ function Dapp() {
     return <p>Wallet locked. Unlock it to continue.</p>
   }
 
-  // ... your dApp: party.partyId, signMessage(text), execute(params), ledgerApi(params)
+  // ... your dApp: account.partyId, signMessage(text), execute(params), ledgerApi(params)
 }
 ```
 
@@ -114,7 +114,7 @@ reports it is not authenticated; that is `isLocked`, and it happens after a succ
 reference gateway also refuses `signMessage` for a local party; `usePartyType().readPartyType()`
 tells local from external when you ask. The SDK's status carries one `isConnected` flag, so a lock
 and a wallet-side disconnect look the same
-here. `useLedger().isReady` covers both, and `useParty().party` is `undefined` for the duration:
+here. `useLedger().isReady` covers both, and `useAccount().account` is `undefined` for the duration:
 gate session content on the party, and use `isLocked` only to explain why it went away.
 
 ### Connecting through a Wallet Gateway

package/dist/{CantonConnectProvider-CJ1yWGXz.js → CantonConnectProvider-M9GvvKOx.js}

@@ -2,7 +2,6 @@ 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. */
@@ -68,10 +67,18 @@ var ConnectCancelledError = class extends Error {
 		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";
+/** Reads the text off a rejection: `message` as JSON-RPC sends it, `details` as the SDK does. */
+const textOf = (cause) => {
+	if (typeof cause !== "object" || cause === null) return;
+	for (const key of ["message", "details"]) {
+		const value = cause[key];
+		if (typeof value === "string" && value !== "") return value;
+	}
+};
 /**
-* Hands `cause` back as an `Error`, wrapping what a wallet answered with over JSON-RPC.
+* Hands `cause` back as an `Error`, wrapping what a wallet answered with. Nothing a wallet refuses
+* arrives as an `Error`: the window transport rejects with the bare JSON-RPC object, and the SDK's
+* own controller with a `{ status, error, details }` of its own, so both are read here.
 *
 * @example
 * const error = toError(await sdk.signMessage(params).catch((cause: unknown) => cause))
@@ -79,7 +86,7 @@ const hasMessage = (cause) => typeof cause === "object" && cause !== null && "me
 */
 const toError = (cause) => {
 	if (cause instanceof Error) return cause;
-	return new Error(hasMessage(cause) ? cause.message : String(cause), { cause });
+	return new Error(textOf(cause) ?? String(cause), { cause });
 };
 /** Classifies what `sdk.connect()` threw, so the cancel path is decided once. */
 const toConnectError = (cause) => {
@@ -102,41 +109,15 @@ const useConnectBridge = (actorRef) => {
 	}, [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));
+/** Reads the wallet's account list once and resolves the one it flags primary. */
+const readPrimaryAccount = fromPromise(async ({ input: { sdk } }) => (await sdk.listAccounts()).find((account) => account.primary));
 /** Forwards the wallet's own account-change pushes into the machine as `accounts.changed`. */
-const accountsEvents = fromCallback(({ sendBack, input: { sdk, networkId } }) => {
+const accountsEvents = fromCallback(({ sendBack, input: { sdk } }) => {
 	const listener = (accounts) => {
 		sendBack({
 			type: "accounts.changed",
-			accounts: toWalletAccounts(accounts, networkId)
+			account: accounts.find((one) => one.primary)
 		});
 	};
 	sdk.onAccountsChanged(listener).catch(() => {});
@@ -147,17 +128,17 @@ const accountsEvents = fromCallback(({ sendBack, input: { sdk, networkId } }) =>
 //#endregion
 //#region src/machine/accountsMachine.ts
 /**
-* Reads the connected party once, then follows the wallet's own `accounts.changed` pushes.
+* Reads the connected account 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,
+		readPrimaryAccount,
 		accountsEvents
 	},
 	actions: {
-		applyAccounts: assign((_, params) => ({
-			...params.accounts,
+		applyAccount: assign((_, params) => ({
+			account: params.account,
 			error: void 0
 		})),
 		assignError: assign((_, params) => ({ error: params.error }))
@@ -170,37 +151,31 @@ const accountsMachine = setup({
 }).createMachine({
 	context: ({ input }) => ({
 		...input,
-		party: void 0,
+		account: void 0,
 		error: void 0
 	}),
 	id: "accounts",
 	initial: "reading",
 	invoke: {
 		src: "accountsEvents",
-		input: ({ context: { sdk, networkId } }) => ({
-			sdk,
-			networkId
-		})
+		input: ({ context: { sdk } }) => ({ sdk })
 	},
 	on: { "accounts.changed": {
 		target: ".ready",
 		actions: {
-			type: "applyAccounts",
-			params: ({ event: { accounts } }) => ({ accounts })
+			type: "applyAccount",
+			params: ({ event: { account } }) => ({ account })
 		}
 	} },
 	states: {
 		reading: { invoke: {
-			src: "readAccounts",
-			input: ({ context: { sdk, networkId } }) => ({
-				sdk,
-				networkId
-			}),
+			src: "readPrimaryAccount",
+			input: ({ context: { sdk } }) => ({ sdk }),
 			onDone: {
 				target: "ready",
 				actions: {
-					type: "applyAccounts",
-					params: ({ event: { output } }) => ({ accounts: output })
+					type: "applyAccount",
+					params: ({ event: { output } }) => ({ account: output })
 				}
 			},
 			onError: {
@@ -528,7 +503,7 @@ const connectionMachine = setup({
 		...input,
 		sdk: input.createSdk(),
 		lastConnectError: void 0,
-		party: void 0
+		account: void 0
 	}),
 	id: "connection",
 	initial: "idle",
@@ -568,19 +543,16 @@ const connectionMachine = setup({
 			states: {
 				authenticated: {
 					initial: "reading",
-					exit: assign({ party: void 0 }),
+					exit: assign({ account: void 0 }),
 					invoke: {
 						src: "accounts",
 						id: "accounts",
-						input: ({ context }) => ({
-							sdk: context.sdk,
-							networkId: context.networkId
-						}),
+						input: ({ context }) => ({ sdk: context.sdk }),
 						onSnapshot: [{
 							guard: ({ event }) => event.snapshot.matches("ready"),
 							target: ".ready",
 							actions: assign(({ event }) => ({
-								party: event.snapshot.context.party,
+								account: event.snapshot.context.account,
 								lastConnectError: void 0
 							}))
 						}, {
@@ -746,8 +718,7 @@ const CantonConnectProvider = ({ config, children }) => {
 	const actorRef = useConnectionActor({
 		createSdk: () => new DappSDK({ walletPicker: config.walletPicker }),
 		initOptions: { additionalAdapters },
-		guardPicker: config.walletPicker === void 0,
-		networkId
+		guardPicker: config.walletPicker === void 0
 	});
 	const resetConnectError = useCallback(() => actorRef.send({ type: "connectError.reset" }), [actorRef]);
 	const cancelConnect = useCallback(() => actorRef.send({ type: "connect.cancel" }), [actorRef]);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as Party, c as WalletSdk, i as ConnectionSubscription, l as ConnectionInput, n as CantonConnectContextValue, o as PartyType, r as ConnectionStatus, s as TxStatusSnapshot, t as CantonConnectConfig, u as InitOptions } from "./types-CmnMRMoG.js";
+import { a as ConnectionSubscription, c as TxStatusSnapshot, i as ConnectionStatus, l as ConnectionInput, n as CantonConnectConfig, o as DappSdkMethods, r as CantonConnectContextValue, s as PartyType, t as Account, u as InitOptions } from "./types-BgMSHglV.js";
 import { LedgerApiParams, PrepareExecuteParams, ProviderAdapter } from "@canton-network/dapp-sdk";
 import { JSX, ReactNode } from "react";
 //#region src/CantonConnectProvider/index.d.ts
@@ -60,6 +60,32 @@ export declare class ConnectCancelledError extends Error {
   constructor(cause?: unknown);
 }
 //#endregion
+//#region src/hooks/useAccount.d.ts
+/**
+ * Return shape of {@link useAccount}. `account` is the one the wallet flags primary, never
+ * substituted, and it changes under a live session.
+ *
+ * @category Hooks
+ */
+interface UseAccountResult {
+  account: Account | undefined;
+  status: ConnectionStatus;
+  isConnected: boolean;
+}
+/**
+ * The connected account and status, as the wallet reports it. `account` is `undefined` until a
+ * connect succeeds, and again whenever a restored session is locked.
+ *
+ * @throws with no {@link CantonConnectProvider} above it.
+ *
+ * @example
+ * const { account, isConnected } = useAccount()
+ * isConnected && <span>{account?.hint}</span>
+ *
+ * @category Hooks
+ */
+export declare const useAccount: () => UseAccountResult;
+//#endregion
 //#region src/hooks/useConnect.d.ts
 /**
  * Return shape of {@link useConnect}.
@@ -80,7 +106,7 @@ interface UseConnectResult {
 /**
  * Connects the wallet and reports that transition. `connect` takes no argument: the picker chooses
  * the wallet, so there is no mode to pass. Gate a pending face on `isPending` and
- * session-dependent content on `useParty().party`, not on `isConnected`.
+ * session-dependent content on `useAccount().account`, not on `isConnected`.
  *
  * @throws with no {@link CantonConnectProvider} above it, as every hook here does.
  *
@@ -137,7 +163,7 @@ interface UseExecuteResult {
 }
 /**
  * Submits ledger commands and tracks the transaction in `lastTx`, fed by the SDK's `txChanged`
- * event. `actAs` defaults to the party `useParty` reports, so a submit acts as the party the UI
+ * event. `actAs` defaults to the party `useAccount` reports, so a submit acts as the party the UI
  * shows rather than the wallet's own primary.
  *
  * @throws with no {@link CantonConnectProvider} above it, and from `execute` where nothing is
@@ -182,32 +208,6 @@ interface UseLedgerResult {
  */
 export declare const useLedger: () => UseLedgerResult;
 //#endregion
-//#region src/hooks/useParty.d.ts
-/**
- * Return shape of {@link useParty}. `party` is the primary among the accounts that can act on the
- * ledger, so it need not be the one the wallet flags primary, and it changes under a live session.
- *
- * @category Hooks
- */
-interface UsePartyResult {
-  party: Party | undefined;
-  status: ConnectionStatus;
-  isConnected: boolean;
-}
-/**
- * The connected account and status. `party` is `undefined` until a connect succeeds, and again
- * whenever a restored session is locked.
- *
- * @throws with no {@link CantonConnectProvider} above it.
- *
- * @example
- * const { party, isConnected } = useParty()
- * isConnected && <span>{party?.partyId}</span>
- *
- * @category Hooks
- */
-export declare const useParty: () => UsePartyResult;
-//#endregion
 //#region src/hooks/usePartyType.d.ts
 /**
  * Return shape of {@link usePartyType}. `readPartyType` throws when nothing is connected or no
@@ -309,7 +309,7 @@ interface MockAccount {
 /**
  * Wiring for {@link createMockAdapter}. `id` defaults to `'mock'`, which is the provider id
  * `createAutoPicker('mock')` matches; `accounts` defaults to one generated account and treats the
- * first entry as primary; omitting `networkId` lets `CantonConnectConfig.networkId` apply instead.
+ * first entry as primary; `networkId` defaults to `canton:local`.
  *
  * @example
  * const options: CreateMockAdapterOptions = { id: 'mock', accounts: [{ partyId }] }
@@ -343,4 +343,4 @@ interface MockAdapter extends ProviderAdapter {
  */
 export declare const createMockAdapter: (options?: CreateMockAdapterOptions) => MockAdapter;
 //#endregion
-export type { CantonConnectConfig, CantonConnectContextValue, CantonConnectProviderProps, ConnectionInput, ConnectionStatus, ConnectionSubscription, CreateMockAdapterOptions, InitOptions, LedgerApiParams, MockAccount, MockAdapter, Party, PartyType, PrepareExecuteParams, TxStatusSnapshot, UseConnectResult, UseDisconnectResult, UseExecuteResult, UseLedgerResult, UsePartyResult, UsePartyTypeResult, UseSignMessageResult, UseWalletStatusResult, WalletSdk };
+export type { Account, CantonConnectConfig, CantonConnectContextValue, CantonConnectProviderProps, ConnectionInput, ConnectionStatus, ConnectionSubscription, CreateMockAdapterOptions, DappSdkMethods, InitOptions, LedgerApiParams, MockAccount, MockAdapter, PartyType, PrepareExecuteParams, TxStatusSnapshot, UseAccountResult, UseConnectResult, UseDisconnectResult, UseExecuteResult, UseLedgerResult, UsePartyTypeResult, UseSignMessageResult, UseWalletStatusResult };

package/dist/index.js

@@ -1,11 +1,35 @@
-import { a as toConnectionStatus, c as toError, n as CantonConnectProvider, o as ConnectCancelledError, r as useCantonConnectContext, s as toConnectError } from "./CantonConnectProvider-CJ1yWGXz.js";
+import { a as toConnectionStatus, c as toError, n as CantonConnectProvider, o as ConnectCancelledError, r as useCantonConnectContext, s as toConnectError } from "./CantonConnectProvider-M9GvvKOx.js";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { useSelector } from "@xstate/react";
+//#region src/hooks/useAccount.ts
+/**
+* The connected account and status, as the wallet reports it. `account` is `undefined` until a
+* connect succeeds, and again whenever a restored session is locked.
+*
+* @throws with no {@link CantonConnectProvider} above it.
+*
+* @example
+* const { account, isConnected } = useAccount()
+* isConnected && <span>{account?.hint}</span>
+*
+* @category Hooks
+*/
+const useAccount = () => {
+	const { connection } = useCantonConnectContext();
+	const account = useSelector(connection, (snapshot) => snapshot.context.account);
+	const status = useSelector(connection, toConnectionStatus);
+	return {
+		account,
+		status,
+		isConnected: status === "connected"
+	};
+};
+//#endregion
 //#region src/hooks/useConnect.ts
 /**
 * Connects the wallet and reports that transition. `connect` takes no argument: the picker chooses
 * the wallet, so there is no mode to pass. Gate a pending face on `isPending` and
-* session-dependent content on `useParty().party`, not on `isConnected`.
+* session-dependent content on `useAccount().account`, not on `isConnected`.
 *
 * @throws with no {@link CantonConnectProvider} above it, as every hook here does.
 *
@@ -92,9 +116,9 @@ const assertUsable = (status, isLocked) => {
 	if (status !== "connected") throw new Error("wallet is not connected - call useConnect().connect() first");
 	if (isLocked) throw new Error("wallet is locked - unlock it in the wallet");
 };
-/** Throws when the session reports no party, which a connected one can. */
+/** Throws when the session reports no account, which a connected one can. */
 function assertPartyId(partyId) {
-	if (partyId === void 0) throw new Error("wallet reports no usable party - allocate one in the wallet");
+	if (partyId === void 0) throw new Error("wallet reports no primary account - select or add one in the wallet");
 }
 /**
 * Selects the session and wraps one SDK call with the connect, lock and party guards plus the
@@ -103,7 +127,7 @@ function assertPartyId(partyId) {
 const useWalletCall = () => {
 	const { connection } = useCantonConnectContext();
 	const sdk = useSelector(connection, (snapshot) => snapshot.context.sdk);
-	const partyId = useSelector(connection, (snapshot) => snapshot.context.party?.partyId);
+	const partyId = useSelector(connection, (snapshot) => snapshot.context.account?.partyId);
 	const status = useSelector(connection, toConnectionStatus);
 	const isLocked = useSelector(connection, (snapshot) => snapshot.hasTag("unauthenticated"));
 	const [state, setState] = useState(IDLE);
@@ -153,7 +177,7 @@ const withActAs = (params, partyId) => params.actAs === void 0 ? {
 } : params;
 /**
 * Submits ledger commands and tracks the transaction in `lastTx`, fed by the SDK's `txChanged`
-* event. `actAs` defaults to the party `useParty` reports, so a submit acts as the party the UI
+* event. `actAs` defaults to the party `useAccount` reports, so a submit acts as the party the UI
 * shows rather than the wallet's own primary.
 *
 * @throws with no {@link CantonConnectProvider} above it, and from `execute` where nothing is
@@ -211,30 +235,6 @@ const useLedger = () => {
 	};
 };
 //#endregion
-//#region src/hooks/useParty.ts
-/**
-* The connected account and status. `party` is `undefined` until a connect succeeds, and again
-* whenever a restored session is locked.
-*
-* @throws with no {@link CantonConnectProvider} above it.
-*
-* @example
-* const { party, isConnected } = useParty()
-* isConnected && <span>{party?.partyId}</span>
-*
-* @category Hooks
-*/
-const useParty = () => {
-	const { connection } = useCantonConnectContext();
-	const party = useSelector(connection, (snapshot) => snapshot.context.party);
-	const status = useSelector(connection, toConnectionStatus);
-	return {
-		party,
-		status,
-		isConnected: status === "connected"
-	};
-};
-//#endregion
 //#region src/hooks/usePartyType.ts
 const namespaceOf = (id) => /::(.+)$/.exec(id)?.[1];
 const readParticipantNamespace = async (sdk) => {
@@ -265,20 +265,20 @@ const readParticipantNamespace = async (sdk) => {
 */
 const usePartyType = () => {
 	const { connection, sdk, status, isLocked } = useWalletCall();
-	const party = useSelector(connection, (snapshot) => snapshot.context.party);
+	const account = useSelector(connection, (snapshot) => snapshot.context.account);
 	return {
 		readPartyType: useCallback(async () => {
 			assertUsable(status, isLocked);
-			if (party === void 0) throw new Error("wallet reports no usable party - allocate one in the wallet");
+			if (account === void 0) throw new Error("wallet reports no primary account - select or add one in the wallet");
 			const participantNamespace = await readParticipantNamespace(sdk);
-			return party.namespace === participantNamespace ? "local" : "external";
+			return account.namespace === participantNamespace ? "local" : "external";
 		}, [
+			account,
 			isLocked,
-			party,
 			sdk,
 			status
 		]),
-		isReady: status === "connected" && !isLocked && party !== void 0
+		isReady: status === "connected" && !isLocked && account !== void 0
 	};
 };
 //#endregion
@@ -341,21 +341,22 @@ const useWalletStatus = () => {
 const DEFAULT_PROVIDER_ID = "mock";
 const DEFAULT_NAME = "Mock Wallet";
 const DEFAULT_DESCRIPTION = "Mock wallet for dev and tests — no real signing, never a live wallet";
-const MOCK_WALLET_STATUS = "allocated";
+const MOCK_ACCOUNT_STATUS = "allocated";
 const MOCK_SIGNING_PROVIDER_ID = "mock";
 const MOCK_PUBLIC_KEY = "mock-public-key";
+const MOCK_NETWORK_ID = "canton:local";
 /** The single mock account `createMockAdapter` reports when the caller supplies none. */
 const defaultAccounts = (providerId) => [{ partyId: `${providerId}::1220abcd` }];
-/** Shapes one `MockAccount` into the `Wallet` the mock adapter's `listAccounts` returns. */
-const toWallet = (account, primary, networkId) => ({
+/** Shapes one `MockAccount` into the `Account` the mock adapter's `listAccounts` returns. */
+const toAccount = (account, primary, networkId) => ({
 	primary,
 	partyId: account.partyId,
-	status: MOCK_WALLET_STATUS,
+	status: MOCK_ACCOUNT_STATUS,
 	hint: account.name ?? account.partyId,
 	publicKey: account.publicKey ?? MOCK_PUBLIC_KEY,
 	namespace: account.partyId.split("::")[1] ?? account.partyId,
-	signingProviderId: MOCK_SIGNING_PROVIDER_ID,
-	...networkId === void 0 ? {} : { networkId }
+	networkId: networkId ?? MOCK_NETWORK_ID,
+	signingProviderId: MOCK_SIGNING_PROVIDER_ID
 });
 /**
 * The adapter `createMockAdapter` returns: it announces itself like an installed wallet and
@@ -365,13 +366,13 @@ var MockProviderAdapter = class {
 	providerId;
 	name = DEFAULT_NAME;
 	type = "browser";
-	wallets;
+	accounts;
 	connected = false;
 	listenerMap = {};
 	constructor(options) {
 		this.providerId = options.id ?? DEFAULT_PROVIDER_ID;
 		const accounts = options.accounts ?? defaultAccounts(this.providerId);
-		this.wallets = accounts.map((account, index) => toWallet(account, index === 0, options.networkId));
+		this.accounts = accounts.map((account, index) => toAccount(account, index === 0, options.networkId));
 	}
 	getInfo() {
 		return {
@@ -410,7 +411,7 @@ var MockProviderAdapter = class {
 				isNetworkConnected: true
 			}
 		}),
-		listAccounts: () => this.wallets
+		listAccounts: () => this.accounts
 	};
 	async request(args) {
 		const handler = this.handlers[args.method];
@@ -445,4 +446,4 @@ var MockProviderAdapter = class {
 */
 const createMockAdapter = (options = {}) => new MockProviderAdapter(options);
 //#endregion
-export { CantonConnectProvider, ConnectCancelledError, createMockAdapter, useCantonConnectContext, useConnect, useDisconnect, useExecute, useLedger, useParty, usePartyType, useSignMessage, useWalletStatus };
+export { CantonConnectProvider, ConnectCancelledError, createMockAdapter, useAccount, useCantonConnectContext, useConnect, useDisconnect, useExecute, useLedger, usePartyType, useSignMessage, useWalletStatus };

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { a as Party, c as WalletSdk, r as ConnectionStatus } from "../types-CmnMRMoG.js";
+import { i as ConnectionStatus, o as DappSdkMethods, t as Account } from "../types-BgMSHglV.js";
 import { WalletPickerFn } from "@canton-network/dapp-sdk";
 import { JSX, ReactNode } from "react";
 //#region src/testing/autoPicker.d.ts
@@ -18,19 +18,19 @@ export declare const createAutoPicker: (pick?: string) => WalletPickerFn;
 //#endregion
 //#region src/testing/fakeSession.d.ts
 /**
- * Props for {@link FakeSessionProvider}. `status` starts the session mid-flight and `party` is
+ * Props for {@link FakeSessionProvider}. `status` starts the session mid-flight and `account` is
  * what a connect resolves to; `readingAccounts` reaches the pending face over a live session, and
  * `sdk` drives a hook's own pending, error and `reset()`, never what a wallet returns.
  *
  * @category Components
  */
 interface FakeSessionProviderProps {
+  account?: Account;
   children: ReactNode;
   connectError?: Error;
   isLocked?: boolean;
-  party?: Party;
   readingAccounts?: boolean;
-  sdk?: Partial<WalletSdk>;
+  sdk?: Partial<DappSdkMethods>;
   status?: ConnectionStatus;
 }
 /**
@@ -43,19 +43,19 @@ interface FakeSessionProviderProps {
  *
  * @example
  * render(
- *   <FakeSessionProvider status="connected" party={party}>
+ *   <FakeSessionProvider status="connected" account={account}>
  *     <ConnectButton />
  *   </FakeSessionProvider>,
  * )
  *
  * @category Components
  */
-export declare const FakeSessionProvider: ({ children, connectError, isLocked, party, readingAccounts, sdk, status: initialStatus }: FakeSessionProviderProps) => JSX.Element;
+export declare const FakeSessionProvider: ({ account, children, connectError, isLocked, readingAccounts, sdk, status: initialStatus }: FakeSessionProviderProps) => JSX.Element;
 //#endregion
 //#region src/testing/fakeWallet.d.ts
 /**
  * One account the fake wallet reports from `listAccounts`. Mark exactly one `primary`: that is the
- * entry `selectPrimaryAccount` resolves to `Party`.
+ * entry the session reports.
  *
  * @category Utilities
  */

package/dist/testing/index.js

@@ -1,8 +1,8 @@
-import { i as connectionMachine, t as CantonConnectContext } from "../CantonConnectProvider-CJ1yWGXz.js";
+import { i as connectionMachine, t as CantonConnectContext } from "../CantonConnectProvider-M9GvvKOx.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";
+import { CANTON_ANNOUNCE_PROVIDER_EVENT, CANTON_REQUEST_PROVIDER_EVENT, WalletEvent } from "@canton-network/core-types";
 //#region src/testing/autoPicker.ts
 /**
 * A `walletPicker` that selects with no UI, for tests and headless dev flows: the entry whose
@@ -23,9 +23,9 @@ const createAutoPicker = (pick) => async (entries) => {
 };
 //#endregion
 //#region src/testing/connectionInput.ts
-/** A `WalletSdk` method stand-in that returns a promise which never settles. */
+/** A `DappSdkMethods` 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. */
+/** Every `DappSdkMethods` method left hanging, so a test only stubs the ones its path reaches. */
 const unstubbed = {
 	connect: pending,
 	disconnect: pending,
@@ -43,7 +43,7 @@ const unstubbed = {
 	status: pending
 };
 /**
-* Machine input for a test actor, over a double satisfying the `WalletSdk` the machine types.
+* Machine input for a test actor, over a double satisfying the `DappSdkMethods` 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.
 *
@@ -57,7 +57,6 @@ const connectionInput = (sdk = {}, overrides = {}) => ({
 	}),
 	initOptions: {},
 	guardPicker: false,
-	networkId: "canton:local",
 	...overrides
 });
 //#endregion
@@ -77,7 +76,7 @@ const toStateValue = ({ isLocked, readingAccounts, status }) => {
 	return { session: { authenticated: readingAccounts ? "reading" : "ready" } };
 };
 /** Starts a real `connectionMachine` actor rehydrated at the given `SessionShape`. */
-const startSession = (shape, party, connectError, sdk) => {
+const startSession = (shape, account, connectError, sdk) => {
 	const input = connectionInput({}, { createSdk: () => sdk });
 	const snapshot = connectionMachine.resolveState({
 		value: toStateValue(shape),
@@ -85,7 +84,7 @@ const startSession = (shape, party, connectError, sdk) => {
 			...input,
 			sdk,
 			lastConnectError: connectError,
-			party: shape.status === "connected" ? party : void 0
+			account: shape.status === "connected" ? account : void 0
 		}
 	});
 	return createActor(connectionMachine, {
@@ -103,23 +102,23 @@ const startSession = (shape, party, connectError, sdk) => {
 *
 * @example
 * render(
-*   <FakeSessionProvider status="connected" party={party}>
+*   <FakeSessionProvider status="connected" account={account}>
 *     <ConnectButton />
 *   </FakeSessionProvider>,
 * )
 *
 * @category Components
 */
-const FakeSessionProvider = ({ children, connectError, isLocked = false, party, readingAccounts = false, sdk = NO_SDK, status: initialStatus = "disconnected" }) => {
+const FakeSessionProvider = ({ account, children, connectError, isLocked = false, readingAccounts = false, sdk = NO_SDK, status: initialStatus = "disconnected" }) => {
 	const [status, setStatus] = useState(initialStatus);
 	const connection = useMemo(() => startSession({
 		isLocked,
 		readingAccounts,
 		status
-	}, party, connectError, refusingSdk(sdk)), [
+	}, account, connectError, refusingSdk(sdk)), [
+		account,
 		connectError,
 		isLocked,
-		party,
 		readingAccounts,
 		sdk,
 		status

package/dist/{types-CmnMRMoG.d.ts → types-BgMSHglV.d.ts}

@@ -1,4 +1,4 @@
-import { DappSDK, ProviderAdapter, StatusEvent, TxChangedEvent, WalletPickerFn } from "@canton-network/dapp-sdk";
+import { DappSDK, ProviderAdapter, StatusEvent, TxChangedEvent, Wallet, WalletPickerFn } from "@canton-network/dapp-sdk";
 import { ActorRefFrom } from "xstate";
 //#region src/machine/connectionActors.d.ts
 /**
@@ -36,17 +36,10 @@ 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. */
+/** Input shared by `readPrimaryAccount` and `accountsEvents`: the sdk slice they call. */
 type AccountsInput = {
   sdk: Pick<DappSDK, 'listAccounts' | 'onAccountsChanged' | 'removeOnAccountsChanged'>;
-  networkId: string;
 };
 //#endregion
 //#region src/machine/connectionMachine.d.ts
@@ -62,22 +55,21 @@ type WalletStatusUpdate = Pick<StatusEvent, 'connection'>;
  * import { connectionMachine } from '#src/machine/connectionMachine'
  *
  * const createSdk = () => new DappSDK({})
- * const input = { createSdk, initOptions: {}, guardPicker: true, networkId: 'canton:local' }
+ * const input = { createSdk, initOptions: {}, guardPicker: true }
  * createActor(connectionMachine, { input })
  *
  * @category Types
  */
 type ConnectionInput = {
-  createSdk: () => WalletSdk;
+  createSdk: () => DappSdkMethods;
   initOptions: InitOptions;
   guardPicker: boolean;
-  networkId: string;
 };
-/** What the machine carries beyond its input: the sdk it drives, the last failure, the party. */
+/** What the machine carries beyond its input: the sdk it drives, the last failure, the account. */
 type ConnectionContext = ConnectionInput & {
-  sdk: WalletSdk;
+  sdk: DappSdkMethods;
   lastConnectError: unknown;
-  party: Party | undefined;
+  account: Account | undefined;
 };
 /**
  * The lifecycle itself: what a connect, a restore, a lock and a disconnect mean, and the tags the
@@ -101,25 +93,26 @@ declare const connectionMachine: import("xstate").StateMachine<ConnectionContext
   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 & {
+  accounts?: import("xstate").ActorRefFromLogic<import("xstate").StateMachine<AccountsInput & {
+    account: Account | undefined;
     error: unknown;
   }, {
     type: "accounts.changed";
-    accounts: WalletAccounts;
+    account: Account | undefined;
   }, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<WalletAccounts, AccountsInput, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, AccountsInput, import("xstate").EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("@canton-network/dapp-sdk").Wallet | undefined, 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>;
+    src: "readPrimaryAccount";
+    logic: import("xstate").PromiseActorLogic<import("@canton-network/dapp-sdk").Wallet | undefined, 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";
+    type: "applyAccount";
     params: {
-      accounts: WalletAccounts;
+      account: Account | undefined;
     };
   } | {
     type: "assignError";
@@ -133,7 +126,7 @@ declare const connectionMachine: import("xstate").StateMachine<ConnectionContext
       readonly ready: {};
       readonly unavailable: {};
     };
-  }>> | undefined;
+  }, import("xstate").MetaObject>> | undefined;
 }, {
   src: "init";
   logic: import("xstate").PromiseActorLogic<void, InitInput, import("xstate").EventObject>;
@@ -156,25 +149,26 @@ declare const connectionMachine: import("xstate").StateMachine<ConnectionContext
   id: string | undefined;
 } | {
   src: "accounts";
-  logic: import("xstate").StateMachine<AccountsInput & WalletAccounts & {
+  logic: import("xstate").StateMachine<AccountsInput & {
+    account: Account | undefined;
     error: unknown;
   }, {
     type: "accounts.changed";
-    accounts: WalletAccounts;
+    account: Account | undefined;
   }, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<WalletAccounts, AccountsInput, import("xstate").EventObject> | import("xstate").CallbackActorLogic<import("xstate").EventObject, AccountsInput, import("xstate").EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("@canton-network/dapp-sdk").Wallet | undefined, 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>;
+    src: "readPrimaryAccount";
+    logic: import("xstate").PromiseActorLogic<import("@canton-network/dapp-sdk").Wallet | undefined, 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";
+    type: "applyAccount";
     params: {
-      accounts: WalletAccounts;
+      account: Account | undefined;
     };
   } | {
     type: "assignError";
@@ -188,7 +182,7 @@ declare const connectionMachine: import("xstate").StateMachine<ConnectionContext
       readonly ready: {};
       readonly unavailable: {};
     };
-  }>;
+  }, import("xstate").MetaObject>;
   id: "accounts";
 }, {
   type: "assignError";
@@ -270,7 +264,7 @@ declare const connectionMachine: import("xstate").StateMachine<ConnectionContext
     readonly initializing: {};
     readonly disconnecting: {};
   };
-}>;
+}, import("xstate").MetaObject>;
 /**
  * The running connection machine. Consumers reach it narrowed to {@link ConnectionSubscription},
  * so `send` stays inside this package.
@@ -286,14 +280,14 @@ type ConnectionActorRef = ActorRefFrom<typeof connectionMachine>;
  *
  * @category Types
  */
-type WalletSdk = Pick<DappSDK, 'init' | 'connect' | 'disconnect' | 'status' | 'listAccounts' | 'onStatusChanged' | 'removeOnStatusChanged' | 'onAccountsChanged' | 'removeOnAccountsChanged' | 'onTxChanged' | 'removeOnTxChanged' | 'ledgerApi' | 'signMessage' | 'prepareExecuteAndWait'>;
+type DappSdkMethods = 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()
+ * const { status } = useAccount()
  * if (status === 'idle') return null
  * return status === 'disconnected' ? <ConnectButton /> : <App />
  *
@@ -307,21 +301,30 @@ type ConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnecting' |
  * @category Types
  */
 type PartyType = 'local' | 'external';
+type PinnedAccount = {
+  primary: boolean;
+  partyId: string;
+  status: 'initialized' | 'allocated' | 'removed';
+  hint: string;
+  publicKey: string;
+  namespace: string;
+  networkId: string;
+  signingProviderId: string;
+  externalTxId?: string;
+  topologyTransactions?: string;
+  disabled?: boolean;
+  reason?: string;
+};
+type Exact<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type Assert<T extends true> = T;
+type AccountPinned = Assert<Exact<Wallet, PinnedAccount>>;
 /**
- * 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.
+ * One account the connected wallet reports: a party plus its key, signing provider and network.
+ * `dapp-sdk` calls this type `Wallet`; CIP-0103's own text says account.
  *
  * @category Types
  */
-interface Party {
-  partyId: string;
-  networkId: string;
-  namespace: string;
-  signingProviderId: string;
-  name?: string;
-  publicKey?: string;
-}
+type Account = AccountPinned extends true ? Wallet : never;
 /**
  * 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
@@ -376,7 +379,7 @@ interface TxStatusSnapshot {
  * @example
  * import type { ConnectionSubscription } from '#src/types'
  *
- * const partyOf = (connection: ConnectionSubscription) => connection.getSnapshot().context.party
+ * const accountOf = (connection: ConnectionSubscription) => connection.getSnapshot().context.account
  *
  * @category Types
  */
@@ -397,4 +400,4 @@ interface CantonConnectContextValue {
   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 };
+export { ConnectionSubscription as a, TxStatusSnapshot as c, ConnectionStatus as i, ConnectionInput as l, CantonConnectConfig as n, DappSdkMethods as o, CantonConnectContextValue as r, PartyType as s, Account as t, InitOptions as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bootnodedev/canton-connect",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "wagmi-style React hooks for connecting Canton dApps to CIP-0103 wallets",
   "repository": {
     "type": "git",