@mysten-incubation/dev-wallet 0.0.0

package/src/wallet/initializer.ts

@@ -0,0 +1,124 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ClientWithCoreApi } from '@mysten/sui/client';
+import type { WalletIcon } from '@mysten/wallet-standard';
+
+import type { SignerAdapter } from '../types.js';
+import { DevWallet, type AutoApprovePolicy } from './dev-wallet.js';
+
+/**
+ * Configuration for the dev wallet initializer.
+ * Unlike {@link DevWalletConfig}, `networks` and `clientFactory` are omitted — they come
+ * from the dApp Kit context at initialization time.
+ */
+export interface DevWalletInitializerConfig {
+	adapters: SignerAdapter[];
+	name?: string;
+	icon?: WalletIcon;
+	autoApprove?: AutoApprovePolicy;
+	autoConnect?: boolean;
+	/** Call `adapter.initialize()` automatically. Defaults to true. */
+	autoInitialize?: boolean;
+	/** Create an initial account after initialization if no accounts exist. Defaults to true. */
+	createInitialAccount?: boolean;
+	/** Mount the floating wallet drawer UI. Defaults to false. */
+	mountUI?: boolean;
+	/** Container element for the UI drawer. Defaults to document.body. */
+	container?: HTMLElement;
+	/** Called with the DevWallet instance after creation. */
+	onWalletCreated?: (wallet: DevWallet) => void;
+}
+
+/**
+ * Creates a wallet initializer for `createDAppKit({ walletInitializers: [...] })`.
+ * The wallet uses dApp Kit's networks and client factory and is unregistered when dApp Kit tears down.
+ *
+ * @example
+ * ```ts
+ * import { createDAppKit } from '@mysten/dapp-kit-react';
+ * import { devWalletInitializer } from '@mysten-incubation/dev-wallet';
+ * import { WebCryptoSignerAdapter } from '@mysten-incubation/dev-wallet/adapters';
+ *
+ * const dAppKit = createDAppKit({
+ *   networks: ['devnet', 'testnet'],
+ *   createClient(network) { ... },
+ *   walletInitializers: [
+ *     devWalletInitializer({
+ *       adapters: [new WebCryptoSignerAdapter()],
+ *       autoConnect: true,
+ *       mountUI: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function devWalletInitializer(config: DevWalletInitializerConfig): {
+	id: string;
+	initialize(input: {
+		networks: readonly string[];
+		getClient: (network?: string) => ClientWithCoreApi;
+	}): Promise<{ unregister: () => void }>;
+} {
+	return {
+		id: 'dev-wallet-initializer',
+		async initialize({ networks, getClient }) {
+			const { autoInitialize = true, createInitialAccount = true, mountUI = false } = config;
+
+			// Initialize adapters
+			if (autoInitialize) {
+				await Promise.all(config.adapters.map((a) => a.initialize()));
+			}
+
+			// Create initial account if needed
+			if (createInitialAccount) {
+				const hasAccounts = config.adapters.some((a) => a.getAccounts().length > 0);
+				if (!hasAccounts) {
+					const creatableAdapter = config.adapters.find(
+						(a) => a.createAccount && a.getAccounts().length === 0,
+					);
+					if (creatableAdapter?.createAccount) {
+						await creatableAdapter.createAccount({ label: 'Dev Account' });
+					}
+				}
+			}
+
+			// Map dApp Kit networks to DevWallet format.
+			// DevWallet needs a Record<string, string> of network name → URL, but
+			// the clientFactory we provide delegates to getClient, so the URLs are
+			// never actually used. We use placeholder values.
+			const networkUrls: Record<string, string> = {};
+			for (const network of networks) {
+				networkUrls[network] = `dapp-kit://${network}`;
+			}
+
+			const wallet = new DevWallet({
+				adapters: config.adapters,
+				networks: networkUrls,
+				name: config.name,
+				icon: config.icon,
+				autoApprove: config.autoApprove,
+				autoConnect: config.autoConnect,
+				clientFactory: (network) => getClient(network),
+			});
+
+			config.onWalletCreated?.(wallet);
+
+			// Mount UI if requested
+			let unmountUI: (() => void) | undefined;
+			if (mountUI && typeof document !== 'undefined') {
+				const { mountDevWallet } = await import('../ui/mount.js');
+				unmountUI = mountDevWallet(wallet, { container: config.container });
+			}
+
+			const unregister = wallet.register();
+			return {
+				unregister() {
+					unmountUI?.();
+					unregister();
+					wallet.destroy();
+				},
+			};
+		},
+	};
+}

package/src/wallet/signing.ts

@@ -0,0 +1,85 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ClientWithCoreApi } from '@mysten/sui/client';
+import type { Signer } from '@mysten/sui/cryptography';
+import { Transaction } from '@mysten/sui/transactions';
+import { fromBase64, toBase64 } from '@mysten/sui/utils';
+
+type SigningRequestType =
+	| 'sign-personal-message'
+	| 'sign-transaction'
+	| 'sign-and-execute-transaction';
+
+interface ExecuteSigningOptions {
+	type: SigningRequestType;
+	signer: Signer;
+	data: string | Uint8Array;
+	client?: ClientWithCoreApi;
+}
+
+export type SigningResult =
+	| { type: 'sign-personal-message'; bytes: string; signature: string }
+	| { type: 'sign-transaction'; bytes: string; signature: string }
+	| {
+			type: 'sign-and-execute-transaction';
+			bytes: string;
+			signature: string;
+			digest: string;
+			effects: string;
+	  };
+
+// Shared between the embedded DevWallet and the standalone popup request-handler.
+export async function executeSigning({
+	type,
+	signer,
+	data,
+	client,
+}: ExecuteSigningOptions): Promise<SigningResult> {
+	switch (type) {
+		case 'sign-personal-message': {
+			if (!(data instanceof Uint8Array)) {
+				throw new Error('sign-personal-message expects data to be a Uint8Array');
+			}
+			const { bytes, signature } = await signer.signPersonalMessage(data);
+			return { type, bytes, signature };
+		}
+		case 'sign-transaction': {
+			if (!client) throw new Error('No client provided for sign-transaction');
+			if (typeof data !== 'string') {
+				throw new Error('sign-transaction expects data to be a JSON string');
+			}
+			const tx = Transaction.from(data);
+			const { bytes, signature } = await tx.sign({ client, signer });
+			return { type, bytes, signature };
+		}
+		case 'sign-and-execute-transaction': {
+			if (!client) throw new Error('No client provided for sign-and-execute-transaction');
+			if (typeof data !== 'string') {
+				throw new Error('sign-and-execute-transaction expects data to be a JSON string');
+			}
+			const tx = Transaction.from(data);
+			const { bytes, signature } = await tx.sign({ client, signer });
+			const result = await client.core.executeTransaction({
+				transaction: fromBase64(bytes),
+				signatures: [signature],
+				include: { effects: true },
+			});
+			const txResult = result.Transaction ?? result.FailedTransaction;
+			if (!txResult) {
+				throw new Error('Transaction execution returned empty result');
+			}
+			if (!txResult.status.success) {
+				throw new Error(txResult.status.error?.message ?? 'Transaction execution failed');
+			}
+			return {
+				type,
+				bytes,
+				signature,
+				digest: txResult.digest,
+				// Empty string when effects BCS is unavailable — the wallet-standard protocol requires a string
+				effects: txResult.effects?.bcs ? toBase64(txResult.effects.bcs) : '',
+			};
+		}
+	}
+}