@etherplay/connect 0.0.14 → 0.0.16

package/src/index.ts

@@ -30,6 +30,15 @@ export type Mechanism = AlchemyMechanism | WalletMechanism<string | undefined, `
 
 export type FullfilledMechanism = AlchemyMechanism | WalletMechanism<string, `0x${string}`>;
 
+export type WalletState = {
+	provider: EIP1193WindowWalletProvider;
+	accounts: `0x${string}`[];
+	accountChanged?: `0x${string}`;
+	chainId: string;
+	invalidChainId: boolean;
+	switchingChain: 'addingChain' | 'switchingChain' | false;
+} & ({status: 'connected'} | {status: 'locked'; unlocking: boolean} | {status: 'disconnected'; connecting: boolean});
+
 export type Connection = {
 	// The connection can have an error in every state.
 	// a banner or other mechanism to show error should be used.
@@ -68,34 +77,25 @@ export type Connection = {
 			wallet: undefined;
 			mechanism: WalletMechanism<string, undefined>;
 	  }
+	// Once the wallet is connected, if multiple account are connected to the site
+	// the user can choose which one to connect to
+	| {
+			step: 'ChooseWalletAccount';
+			mechanism: WalletMechanism<string, undefined>;
+			wallet: WalletState;
+	  }
 	// Once the wallet is connected, the system will need a signature
 	// this state represent the fact and require another user interaction to request the signature
 	| {
 			step: 'WalletConnected';
 			mechanism: WalletMechanism<string, `0x${string}`>;
-			wallet: {
-				provider: EIP1193WindowWalletProvider;
-				locked: boolean;
-				disconnected: boolean;
-				accountChanged?: `0x${string}`;
-				chainId: string;
-				invalidChainId: boolean;
-				switchingChain: 'addingChain' | 'switchingChain' | false;
-			};
+			wallet: WalletState;
 	  }
 	// This state is triggered once the signature is requested, the user will have to confirm with its wallet
 	| {
 			step: 'WaitingForSignature';
 			mechanism: WalletMechanism<string, `0x${string}`>;
-			wallet: {
-				provider: EIP1193WindowWalletProvider;
-				locked: boolean;
-				disconnected: boolean;
-				accountChanged?: `0x${string}`;
-				chainId: string;
-				invalidChainId: boolean;
-				switchingChain: 'addingChain' | 'switchingChain' | false;
-			};
+			wallet: WalletState;
 	  }
 	// Finally the user is fully signed in
 	// wallet?.accountChanged if set, represent the fact that the user has changed its web3-wallet accounnt.
@@ -112,15 +112,7 @@ export type Connection = {
 			step: 'SignedIn';
 			mechanism: WalletMechanism<string, `0x${string}`>;
 			account: OriginAccount;
-			wallet: {
-				provider: EIP1193WindowWalletProvider;
-				locked: boolean;
-				disconnected: boolean;
-				accountChanged?: `0x${string}`;
-				chainId: string;
-				invalidChainId: boolean;
-				switchingChain: 'addingChain' | 'switchingChain' | false;
-			};
+			wallet: WalletState;
 	  }
 );
 
@@ -250,6 +242,12 @@ export function createConnection(settings: {
 									_wallet = {provider: walletProvider, chainId};
 									alwaysOnProvider.setWalletProvider(walletProvider);
 									watchForChainIdChange(_wallet.provider);
+									let accounts: `0x${string}`[] = [];
+									// try {
+									accounts = await walletProvider.request({method: 'eth_accounts'});
+									accounts = accounts.map((v) => v.toLowerCase() as `0x${string}`);
+									// } catch {}
+									// // TODO try catch ? and use logic of onAccountChanged
 									set({
 										step: 'SignedIn',
 										account: existingAccount,
@@ -257,15 +255,17 @@ export function createConnection(settings: {
 										wallets: $connection.wallets,
 										wallet: {
 											provider: walletProvider,
-											locked: false, // TODO should fetch eth_account first
-											disconnected: false, // TODO should fetch eth_account first
+											accounts,
+											status: 'connected',
 											accountChanged: undefined,
 											chainId,
 											invalidChainId: alwaysOnChainId != chainId,
 											switchingChain: false,
 										},
 									});
-									walletProvider.request({method: 'eth_accounts'}).then(onAccountChanged);
+									alwaysOnProvider.setWalletStatus('connected');
+									// TODO use the same logic before hand
+									onAccountChanged(accounts);
 									watchForAccountChange(walletProvider);
 								})
 								.catch((err) => {
@@ -295,21 +295,30 @@ export function createConnection(settings: {
 									_wallet = {provider: walletProvider, chainId};
 									alwaysOnProvider.setWalletProvider(walletProvider);
 									watchForChainIdChange(_wallet.provider);
+
+									let accounts: `0x${string}`[] = [];
+									// try {
+									accounts = await walletProvider.request({method: 'eth_accounts'});
+									accounts = accounts.map((v) => v.toLowerCase() as `0x${string}`);
+									// } catch {}
+									// // TODO try catch ? and use logic of onAccountChanged
 									set({
 										step: 'WalletConnected',
 										mechanism: lastWallet,
 										wallets: $connection.wallets,
 										wallet: {
 											provider: walletProvider,
-											locked: false, // TODO should fetch eth_account first
-											disconnected: false, // TODO should fetch eth_account first
+											accounts,
+											status: 'connected',
 											accountChanged: undefined,
 											chainId,
 											invalidChainId: alwaysOnChainId != chainId,
 											switchingChain: false,
 										},
 									});
-									walletProvider.request({method: 'eth_accounts'}).then(onAccountChanged);
+									alwaysOnProvider.setWalletStatus('connected');
+									// TODO use the same logic before hand
+									onAccountChanged(accounts);
 									watchForAccountChange(walletProvider);
 								})
 								.catch((err) => {
@@ -368,12 +377,7 @@ export function createConnection(settings: {
 			throw new Error(`invalid step: ${$connection.step}, needs to be WalletConnected`);
 		}
 
-		if (!_wallet) {
-			// TODO error ?
-			throw new Error(`no wallet provided initialised`);
-		}
-		const provider = _wallet.provider;
-		const chainId = _wallet.chainId;
+		const provider = $connection.wallet.provider;
 		const message = originKeyMessage(origin);
 		const msg = hashMessage(message);
 
@@ -424,36 +428,28 @@ export function createConnection(settings: {
 		set({
 			...$connection,
 			step: 'SignedIn',
-			mechanism: {
-				type: 'wallet',
-				name: $connection.mechanism.name,
-				address: $connection.mechanism.address,
-			},
 			account,
-			wallet: {
-				chainId,
-				provider: provider,
-				locked: false,
-				disconnected: false,
-				accountChanged: undefined, // TODO check account list
-				invalidChainId: alwaysOnChainId != chainId,
-				switchingChain: false,
-			},
+			wallet: $connection.wallet,
 		});
 		if (remember) {
 			saveOriginAccount(account);
 		}
 	}
 
-	function connectOnCurrentWalletAccount(address: `0x${string}`) {
-		if ($connection.step === 'SignedIn' && $connection.mechanism.type === 'wallet') {
-			connect({
-				type: 'wallet',
-				address,
-				name: $connection.mechanism.name,
-			});
+	function connecToAddress(address: `0x${string}`, options?: {requireUserConfirmationBeforeSignatureRequest: boolean}) {
+		if ($connection.wallet) {
+			connect(
+				{
+					type: 'wallet',
+					address,
+					name: $connection.mechanism.name,
+				},
+				{
+					requireUserConfirmationBeforeSignatureRequest: options?.requireUserConfirmationBeforeSignatureRequest,
+				},
+			);
 		} else {
-			throw new Error(`need to be using a mechanism of type wallet and be SignedIN`);
+			throw new Error(`need to be using a wallet`);
 		}
 	}
 
@@ -487,23 +483,34 @@ export function createConnection(settings: {
 					...$connection,
 					wallet: {
 						...$connection.wallet,
-						locked: true,
+						status: 'locked',
+						unlocking: false,
 					},
 				});
+				alwaysOnProvider.setWalletStatus('locked');
 			} else {
 				const disconnected = accountsFormated.find((v) => v == addressSignedIn) ? false : true;
 
-				if ($connection.wallet.locked) {
+				if (disconnected) {
+					set({
+						...$connection,
+						wallet: {
+							...$connection.wallet,
+							status: 'disconnected',
+							connecting: false,
+						},
+					});
+					alwaysOnProvider.setWalletStatus('disconnected');
+				} else {
 					set({
 						...$connection,
 						wallet: {
 							...$connection.wallet,
-							locked: false,
-							disconnected,
+							status: 'connected',
 						},
 					});
+					alwaysOnProvider.setWalletStatus('connected');
 				}
-				// TODO disconnected ?
 			}
 
 			if (accountsFormated.length > 0 && accountsFormated[0] != $connection.mechanism.address) {
@@ -552,7 +559,9 @@ export function createConnection(settings: {
 		remember = !(options?.doNotStoreLocally || false);
 		if (mechanism) {
 			if (mechanism.type === 'wallet') {
-				const walletName = mechanism.name;
+				const specificAddress = mechanism.address;
+				const walletName =
+					mechanism.name || ($connection.wallets.length == 1 ? $connection.wallets[0].info.name : undefined);
 				if (walletName) {
 					const wallet = $connection.wallets.find((v) => v.info.name == walletName || v.info.uuid == walletName);
 					if (wallet) {
@@ -562,14 +571,14 @@ export function createConnection(settings: {
 							stopatchingForChainIdChange(_wallet.provider);
 						}
 
-						const mechanism: WalletMechanism<string, undefined> = {
+						const mechanismToSave: WalletMechanism<string, undefined> = {
 							type: 'wallet',
 							name: walletName,
 						};
 
 						set({
 							step: 'WaitingForWalletConnection', // TODO FetchingAccounts
-							mechanism,
+							mechanism: mechanismToSave,
 							wallets: $connection.wallets,
 							wallet: undefined,
 						});
@@ -587,52 +596,72 @@ export function createConnection(settings: {
 						if (accounts.length === 0) {
 							set({
 								step: 'WaitingForWalletConnection', // TODO add another step to unlock ?
-								mechanism,
+								mechanism: mechanismToSave,
 								wallets: $connection.wallets,
 								wallet: undefined,
 							});
 							accounts = await provider.request({method: 'eth_requestAccounts'});
 							accounts = accounts.map((v) => v.toLowerCase()) as `0x${string}`[];
 							if (accounts.length > 0) {
-								const walletMechanism = {
-									...mechanism,
-									address: accounts[0],
-								};
-								if (options?.requestSignatureRightAway) {
+								const nextStep = !specificAddress && accounts.length > 1 ? 'ChooseWalletAccount' : 'WalletConnected';
+								let account = accounts[0];
+								if (specificAddress) {
+									if (accounts.find((v) => v === specificAddress)) {
+										account = specificAddress;
+									} else {
+										// TODO error
+										throw new Error(`could not find address ${specificAddress}`);
+									}
+								}
+
+								const newState: Connection =
+									nextStep === 'ChooseWalletAccount'
+										? {
+												step: nextStep,
+												mechanism: mechanismToSave,
+												wallets: $connection.wallets,
+
+												wallet: {
+													provider: _wallet.provider,
+													accounts,
+													status: 'connected',
+													accountChanged: undefined,
+													chainId,
+													invalidChainId: alwaysOnChainId != chainId,
+													switchingChain: false,
+												},
+											}
+										: {
+												step: nextStep,
+												mechanism: {
+													...mechanismToSave,
+													address: account,
+												},
+												wallets: $connection.wallets,
+												wallet: {
+													provider: _wallet.provider,
+													accounts,
+													status: 'connected',
+													accountChanged: undefined,
+													chainId,
+													invalidChainId: alwaysOnChainId != chainId,
+													switchingChain: false,
+												},
+											};
+								if (newState.step === 'WalletConnected' && options?.requestSignatureRightAway) {
 									watchForAccountChange(_wallet.provider);
 
-									set({
-										step: 'WalletConnected',
-										mechanism: walletMechanism,
-										wallets: $connection.wallets,
-										wallet: {
-											provider: _wallet.provider,
-											locked: false,
-											disconnected: false,
-											accountChanged: undefined,
-											chainId,
-											invalidChainId: alwaysOnChainId != chainId,
-											switchingChain: false,
-										},
-									});
-									saveLastWallet(walletMechanism);
+									set(newState);
+									alwaysOnProvider.setWalletStatus('connected');
+									saveLastWallet(newState.mechanism);
 									await requestSignature();
 								} else {
-									set({
-										step: 'WalletConnected',
-										mechanism: walletMechanism,
-										wallets: $connection.wallets,
-										wallet: {
-											provider: _wallet.provider,
-											locked: false,
-											disconnected: false,
-											accountChanged: undefined,
-											chainId,
-											invalidChainId: alwaysOnChainId != chainId,
-											switchingChain: false,
-										},
-									});
-									saveLastWallet(walletMechanism);
+									set(newState);
+									alwaysOnProvider.setWalletStatus('connected');
+									if (newState.step === 'WalletConnected') {
+										saveLastWallet(newState.mechanism);
+									}
+
 									watchForAccountChange(_wallet.provider);
 								}
 							} else {
@@ -644,45 +673,66 @@ export function createConnection(settings: {
 								});
 							}
 						} else {
-							const walletMechanism = {
-								...mechanism,
-								address: accounts[0],
-							};
-							if (!requestSignatureAutomaticallyIfPossible || options?.requireUserConfirmationBeforeSignatureRequest) {
-								set({
-									step: 'WalletConnected',
-									mechanism: walletMechanism,
-									wallets: $connection.wallets,
-									wallet: {
-										provider: _wallet.provider,
-										locked: false,
-										disconnected: false,
-										accountChanged: undefined,
-										chainId,
-										invalidChainId: alwaysOnChainId != chainId,
-										switchingChain: false,
-									},
-								});
-								saveLastWallet(walletMechanism);
+							let account = accounts[0];
+							if (specificAddress) {
+								if (accounts.find((v) => v === specificAddress)) {
+									account = specificAddress;
+								} else {
+									// TODO error
+									throw new Error(`could not find address ${specificAddress}`);
+								}
+							}
+							const nextStep = !specificAddress && accounts.length > 1 ? 'ChooseWalletAccount' : 'WalletConnected';
+							const newState: Connection =
+								nextStep === 'ChooseWalletAccount'
+									? {
+											step: nextStep,
+											mechanism: mechanismToSave,
+											wallets: $connection.wallets,
+											wallet: {
+												provider: _wallet.provider,
+												accounts,
+												status: 'connected',
+												accountChanged: undefined,
+												chainId,
+												invalidChainId: alwaysOnChainId != chainId,
+												switchingChain: false,
+											},
+										}
+									: {
+											step: nextStep,
+											mechanism: {
+												...mechanismToSave,
+												address: account,
+											},
+											wallets: $connection.wallets,
+											wallet: {
+												provider: _wallet.provider,
+												accounts,
+												status: 'connected',
+												accountChanged: undefined,
+												chainId,
+												invalidChainId: alwaysOnChainId != chainId,
+												switchingChain: false,
+											},
+										};
+							if (
+								newState.step === 'WalletConnected' &&
+								requestSignatureAutomaticallyIfPossible &&
+								!options?.requireUserConfirmationBeforeSignatureRequest
+							) {
+								set(newState);
+								alwaysOnProvider.setWalletStatus('connected');
+								saveLastWallet(newState.mechanism);
 								watchForAccountChange(_wallet.provider);
+								await requestSignature();
 							} else {
 								watchForAccountChange(_wallet.provider);
-								set({
-									step: 'WalletConnected',
-									mechanism: walletMechanism,
-									wallets: $connection.wallets,
-									wallet: {
-										provider: _wallet.provider,
-										locked: false,
-										disconnected: false,
-										accountChanged: undefined,
-										chainId,
-										invalidChainId: alwaysOnChainId != chainId,
-										switchingChain: false,
-									},
-								});
-								saveLastWallet(walletMechanism);
-								await requestSignature();
+								set(newState);
+								alwaysOnProvider.setWalletStatus('connected');
+								if (newState.step === 'WalletConnected') {
+									saveLastWallet(newState.mechanism);
+								}
 							}
 						}
 					} else {
@@ -880,14 +930,30 @@ export function createConnection(settings: {
 	}
 
 	async function unlock() {
-		if (!$connection.wallet) {
+		const wallet = $connection.wallet;
+		if (!wallet || wallet.status !== 'locked') {
 			throw new Error(`invalid state`);
 		}
 
-		const wallet = $connection.wallet;
+		set({
+			...$connection,
+			wallet: {
+				...wallet,
+				unlocking: true,
+			},
+		});
 
-		// TODO unlocking state
-		await wallet.provider.request({method: 'eth_requestAccounts'}).then(onAccountChanged);
+		try {
+			await wallet.provider.request({method: 'eth_requestAccounts'}).then(onAccountChanged);
+		} catch {
+			set({
+				...$connection,
+				wallet: {
+					...wallet,
+					unlocking: false,
+				},
+			});
+		}
 	}
 
 	async function switchWalletChain(
@@ -1061,7 +1127,7 @@ export function createConnection(settings: {
 		cancel,
 		back,
 		requestSignature,
-		connectOnCurrentWalletAccount,
+		connecToAddress,
 		disconnect,
 		getSignatureForPublicKeyPublication,
 		switchWalletChain,

package/src/provider.ts

@@ -19,39 +19,51 @@ export function createProvider(params: {
 	chainId: string;
 	prioritizeWalletProvider?: boolean;
 	requestsPerSecond?: number;
-}): CurriedRPC<Methods> & {setWalletProvider: (walletProvider: EIP1193WindowWalletProvider | undefined) => void} & {
+}): CurriedRPC<Methods> & {
+	setWalletProvider: (walletProvider: EIP1193WindowWalletProvider | undefined) => void;
+	setWalletStatus: (newStatus: 'connected' | 'locked' | 'disconnected') => void;
+} & {
 	chainId: string;
 } {
 	const {endpoint, chainId, prioritizeWalletProvider, requestsPerSecond} = params;
 	const jsonRPC = createCurriedJSONRPC(endpoint);
 
 	let walletProvider: EIP1193WindowWalletProvider | undefined;
+	let status: 'connected' | 'locked' | 'disconnected' = 'disconnected';
 
 	function setWalletProvider(newWalletProvider: EIP1193WindowWalletProvider | undefined) {
 		walletProvider = newWalletProvider;
 	}
+	function setWalletStatus(newStatus: 'connected' | 'locked' | 'disconnected') {
+		status = newStatus;
+	}
 
 	const provider = {
 		async request(req: {method: string; params?: any[]}) {
-			if (walletProvider) {
-				const signingMethod =
-					signerMethods.includes(req.method) ||
-					connectedAccountMethods.includes(req.method) ||
-					walletOnlyMethods.includes(req.method) ||
-					req.method.indexOf('sign') != -1;
+			const signingMethod =
+				signerMethods.includes(req.method) ||
+				connectedAccountMethods.includes(req.method) ||
+				walletOnlyMethods.includes(req.method) ||
+				req.method.indexOf('sign') != -1;
 
+			if (walletProvider) {
 				if (prioritizeWalletProvider || signingMethod) {
+					if (signingMethod) {
+						if (status !== 'connected') {
+							return Promise.reject({message: 'wallet provider is not connected', code: 4001});
+						}
+					}
+
 					const currentChainIdAsHex = await walletProvider.request({
 						method: 'eth_chainId',
 					});
 					const currentChainId = Number(currentChainIdAsHex).toString();
 					if (chainId !== currentChainId) {
 						if (signingMethod) {
-							return Promise.reject(
-								new Error(
-									`wallet provider is connected to a different chain, expected ${chainId} but got ${currentChainId}`,
-								),
-							);
+							return Promise.reject({
+								message: `wallet provider is connected to a different chain, expected ${chainId} but got ${currentChainId}`,
+								code: 4001,
+							});
 						} else {
 							// we fallback on jsonRPc if invalid chain and not a signing method
 							return jsonRPC.request(req);
@@ -61,10 +73,14 @@ export function createProvider(params: {
 				}
 			}
 
+			// if (signingMethod) {
+			// 	return Promise.reject(new Error('wallet provider is not connected'));
+			// }
+
 			return jsonRPC.request(req);
 		},
 	} as unknown as EIP1193WalletProvider;
 
 	const curriedRPC = createCurriedJSONRPC<Methods>(provider as any, {requestsPerSecond});
-	return {...curriedRPC, setWalletProvider, chainId};
+	return {...curriedRPC, setWalletProvider, setWalletStatus, chainId};
 }