@etherplay/connect 0.0.9 → 0.0.10

package/src/index.ts

@@ -1,7 +1,7 @@
 import type {AlchemyMechanism, OriginAccount} from '@etherplay/alchemy';
 import {writable} from 'svelte/store';
 import {createPopupLauncher, type PopupPromise} from './popup.js';
-import type {EIP1193WindowWalletProvider} from 'eip-1193';
+import type {EIP1193ChainId, EIP1193WindowWalletProvider} from 'eip-1193';
 import {
 	fromEntropyKeyToMnemonic,
 	fromMnemonicToFirstAccount,
@@ -10,6 +10,7 @@ import {
 	originPublicKeyPublicationMessage,
 } from '@etherplay/alchemy';
 import {hashMessage} from './utils.js';
+import {createProvider} from './provider.js';
 
 export {fromEntropyKeyToMnemonic, originPublicKeyPublicationMessage, originKeyMessage};
 export type {OriginAccount};
@@ -84,6 +85,8 @@ export type Connection = {
 				provider: EIP1193WindowWalletProvider;
 				accountChanged?: `0x${string}`;
 				chainId: string;
+				invalidChainId: boolean;
+				switchingChain: 'addingChain' | 'switchingChain' | false;
 			};
 	  }
 );
@@ -106,7 +109,18 @@ export interface EIP6963AnnounceProviderEvent extends CustomEvent {
 }
 
 const storageAccountKey = '__origin_account';
-export function createConnection(settings: {walletHost: string; autoConnect?: boolean}) {
+export function createConnection(settings: {
+	walletHost: string;
+	autoConnect?: boolean;
+	node: {url: string; chainId: string; prioritizeWalletProvider?: boolean; requestsPerSecond?: number};
+}) {
+	const alwaysOnChainId = settings.node.chainId;
+	const alwaysOnProvider = createProvider({
+		endpoint: settings.node.url,
+		chainId: settings.node.chainId,
+		prioritizeWalletProvider: settings.node.prioritizeWalletProvider,
+		requestsPerSecond: settings.node.requestsPerSecond,
+	});
 	let autoConnect = true;
 	if (typeof settings.autoConnect !== 'undefined') {
 		autoConnect = settings.autoConnect;
@@ -190,6 +204,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 									const chainIdAsHex = await walletProvider.request({method: 'eth_chainId'});
 									const chainId = Number(chainIdAsHex).toString();
 									_wallet = {provider: walletProvider, chainId};
+									alwaysOnProvider.setWalletProvider(walletProvider);
 									watchForChainIdChange(_wallet.provider);
 									set({
 										step: 'SignedIn',
@@ -200,6 +215,8 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 											provider: walletProvider,
 											accountChanged: undefined,
 											chainId,
+											invalidChainId: alwaysOnChainId != chainId,
+											switchingChain: false,
 										},
 									});
 									walletProvider.request({method: 'eth_accounts'}).then(onAccountChanged);
@@ -319,6 +336,8 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 				chainId,
 				provider: provider,
 				accountChanged: undefined, // TODO check account list
+				invalidChainId: alwaysOnChainId != chainId,
+				switchingChain: false,
 			},
 		});
 		if (remember) {
@@ -349,6 +368,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 				wallet: {
 					...$connection.wallet,
 					chainId,
+					invalidChainId: alwaysOnChainId != chainId,
 				},
 			});
 		}
@@ -420,6 +440,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 					const wallet = $connection.wallets.find((v) => v.info.name == walletName || v.info.uuid == walletName);
 					if (wallet) {
 						if (_wallet) {
+							alwaysOnProvider.setWalletProvider(undefined);
 							stopatchingForAccountChange(_wallet.provider);
 							stopatchingForChainIdChange(_wallet.provider);
 						}
@@ -441,6 +462,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 							chainId,
 							provider,
 						};
+						alwaysOnProvider.setWalletProvider(_wallet.provider);
 						watchForChainIdChange(_wallet.provider);
 						let accounts = await provider.request({method: 'eth_accounts'});
 						accounts = accounts.map((v) => v.toLowerCase()) as `0x${string}`[];
@@ -580,6 +602,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 	function disconnect() {
 		deleteOriginAccount();
 		if (_wallet) {
+			alwaysOnProvider.setWalletProvider(undefined);
 			stopatchingForAccountChange(_wallet.provider);
 			stopatchingForChainIdChange(_wallet.provider);
 		}
@@ -693,6 +716,171 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 		throw new Error(`no saved public key publication signature for ${account.address}`);
 	}
 
+	async function switchWalletChain(
+		chainId: string,
+		config?: {
+			readonly rpcUrls?: readonly string[];
+			readonly blockExplorerUrls?: readonly string[];
+			readonly chainName?: string;
+			readonly iconUrls?: readonly string[];
+			readonly nativeCurrency?: {
+				name: string;
+				symbol: string;
+				decimals: number;
+			};
+		},
+	) {
+		if ($connection.step !== 'SignedIn' || !$connection.wallet) {
+			throw new Error(`invali state`);
+		}
+
+		const wallet = $connection.wallet;
+		// if (!wallet) {
+		// 	throw new Error(`no wallet`);
+		// }
+
+		try {
+			// attempt to switch...
+			set({
+				...$connection,
+				wallet: {...$connection.wallet, switchingChain: 'switchingChain'},
+			});
+			const result = await wallet.provider.request({
+				method: 'wallet_switchEthereumChain',
+				params: [
+					{
+						chainId: ('0x' + parseInt(chainId).toString(16)) as EIP1193ChainId,
+					},
+				],
+			});
+			if (!result) {
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+					});
+				}
+
+				// logger.info(`wallet_switchEthereumChain: complete`);
+				// this will be taken care with `chainChanged` (but maybe it should be done there ?)
+				// handleNetwork(chainId);
+			} else {
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+						error: {
+							message: `Failed to switch to ${config?.chainName || `chain with id = ${chainId}`}`,
+							cause: result,
+						},
+					});
+				}
+				throw result;
+			}
+		} catch (err) {
+			if ((err as any).code === 4001) {
+				// logger.info(`wallet_addEthereumChain: failed but error code === 4001, we ignore as user rejected it`, err);
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+					});
+				}
+				return;
+			}
+			// if ((err as any).code === 4902) {
+			else if (config && config.rpcUrls && config.rpcUrls.length > 0) {
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: 'addingChain'},
+					});
+				}
+				// logger.info(`wallet_switchEthereumChain: could not switch, try adding the chain via "wallet_addEthereumChain"`);
+				try {
+					const result = await wallet.provider.request({
+						method: 'wallet_addEthereumChain',
+						params: [
+							{
+								chainId: ('0x' + parseInt(chainId).toString(16)) as EIP1193ChainId,
+								rpcUrls: config.rpcUrls,
+								chainName: config.chainName,
+								blockExplorerUrls: config.blockExplorerUrls,
+								iconUrls: config.iconUrls,
+								nativeCurrency: config.nativeCurrency,
+							},
+						],
+					});
+					if (!result) {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+							});
+						}
+						// this will be taken care with `chainChanged` (but maybe it should be done there ?)
+						// handleNetwork(chainId);
+					} else {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+								error: {
+									message: `Failed to add new chain: ${config?.chainName || `chain with id = ${chainId}`}`,
+									cause: result,
+								},
+							});
+						}
+						// logger.info(`wallet_addEthereumChain: a non-undefinded result means an error`, result);
+						throw result;
+					}
+				} catch (err) {
+					if ((err as any).code !== 4001) {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+								error: {
+									message: `Failed to add new chain: ${config?.chainName || `chain with id = ${chainId}`}`,
+									cause: err,
+								},
+							});
+						}
+						// logger.info(`wallet_addEthereumChain: failed`, err);
+						// TODO ?
+						// set({
+						// 	error: {message: `Failed to add new chain`, cause: err},
+						// });
+						// for now:
+						throw err;
+					} else {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+							});
+						}
+						// logger.info(`wallet_addEthereumChain: failed but error code === 4001, we ignore as user rejected it`, err);
+						return;
+					}
+				}
+			} else {
+				const errorMessage = `Chain "${config?.chainName || `with chainId = ${chainId}`} " is not available on your wallet`;
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+						error: {
+							message: errorMessage,
+						},
+					});
+				}
+
+				throw new Error(errorMessage);
+			}
+		}
+	}
+
 	return {
 		subscribe: _store.subscribe,
 		connect,
@@ -702,5 +890,9 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 		connectOnCurrentWalletAccount,
 		disconnect,
 		getSignatureForPublicKeyPublication,
+		switchWalletChain,
+		provider: alwaysOnProvider,
 	};
 }
+
+export type ConnectionStore = ReturnType<typeof createConnection>;

package/src/provider.ts

@@ -0,0 +1,68 @@
+import type {EIP1193WalletProvider, EIP1193WindowWalletProvider, Methods} from 'eip-1193';
+import {createCurriedJSONRPC, CurriedRPC} from 'remote-procedure-call';
+
+const signerMethods = [
+	'eth_accounts',
+	'eth_sign',
+	'eth_signTransaction',
+	'personal_sign',
+	'eth_signTypedData_v4',
+	'eth_signTypedData',
+];
+
+const connectedAccountMethods = ['eth_sendTransaction'];
+
+const walletOnlyMethods = ['eth_requestAccounts', 'wallet_switchEthereumChain', 'wallet_addEthereumChain'];
+
+export function createProvider(params: {
+	endpoint: string;
+	chainId: string;
+	prioritizeWalletProvider?: boolean;
+	requestsPerSecond?: number;
+}): CurriedRPC<Methods> & {setWalletProvider: (walletProvider: EIP1193WindowWalletProvider | undefined) => void} & {
+	chainId: string;
+} {
+	const {endpoint, chainId, prioritizeWalletProvider, requestsPerSecond} = params;
+	const jsonRPC = createCurriedJSONRPC(endpoint);
+
+	let walletProvider: EIP1193WindowWalletProvider | undefined;
+
+	function setWalletProvider(walletProvider: EIP1193WindowWalletProvider | undefined) {
+		walletProvider = walletProvider;
+	}
+
+	const provider = {
+		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;
+				if (prioritizeWalletProvider || signingMethod) {
+					const currentChainIdAsHex = 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}`,
+								),
+							);
+						} else {
+							// we fallback on jsonRPc if invalid chain and not a signing method
+							return jsonRPC.request(req);
+						}
+					}
+					return walletProvider.request(req as any);
+				}
+			}
+
+			return jsonRPC.request(req);
+		},
+	} as unknown as EIP1193WalletProvider;
+
+	return {...createCurriedJSONRPC<Methods>(provider as any, {requestsPerSecond}), setWalletProvider, chainId};
+}