@getpara/evm-wallet-connectors 2.0.0-alpha.7 → 2.0.0-alpha.71

package/README.md

@@ -0,0 +1,20 @@
+https://www.npmjs.com/package/@getpara/evm-wallet-connectors
+
+The package is used with Para's React SDK Lite to enable external EVM wallet connections. Para automatically manages the Wagmi provider internally when you configure external wallet support.
+
+###Key Features
+
+- Wagmi Integration: Powered by Wagmi, the popular React hooks library for Ethereum
+- Automatic Setup: Para handles all Wagmi provider configuration internally
+- Unified Configuration: Configure chains and settings through Para's `externalWalletConfig`
+- All Wagmi Hooks Available: Use any Wagmi hook alongside Para hooks
+
+###Prerequisites
+
+To use Para, you need an API key. This key authenticates your requests to Para services and is essential for integration.
+
+Don't have an API key yet? Request access to the [Developer Portal](https://developer.getpara.com/) to create API keys, manage billing, teams, and more.
+
+###Learn more
+
+For more information on Para’s EVM Wallet Connectors visit the [Para Docs](https://docs.getpara.com/v2/react/guides/external-wallets/evm-lite#evm-wallets-with-react-sdk-lite)

package/dist/connectors/walletConnect.d.ts

@@ -0,0 +1,63 @@
+import type { Compute, ExactPartial, Omit } from '@wagmi/core/internal';
+import type { EthereumProvider } from '@walletconnect/ethereum-provider';
+import { type Address, type ProviderConnectInfo } from 'viem';
+type EthereumProviderOptions = Parameters<(typeof EthereumProvider)['init']>[0];
+export type WalletConnectParameters = Compute<{
+    /**
+     * If a new chain is added to a previously existing configured connector `chains`, this flag
+     * will determine if that chain should be considered as stale. A stale chain is a chain that
+     * WalletConnect has yet to establish a relationship with (e.g. the user has not approved or
+     * rejected the chain).
+     *
+     * This flag mainly affects the behavior when a wallet does not support dynamic chain authorization
+     * with WalletConnect v2.
+     *
+     * If `true` (default), the new chain will be treated as a stale chain. If the user
+     * has yet to establish a relationship (approved/rejected) with this chain in their WalletConnect
+     * session, the connector will disconnect upon the dapp auto-connecting, and the user will have to
+     * reconnect to the dapp (revalidate the chain) in order to approve the newly added chain.
+     * This is the default behavior to avoid an unexpected error upon switching chains which may
+     * be a confusing user experience (e.g. the user will not know they have to reconnect
+     * unless the dapp handles these types of errors).
+     *
+     * If `false`, the new chain will be treated as a potentially valid chain. This means that if the user
+     * has yet to establish a relationship with the chain in their WalletConnect session, wagmi will successfully
+     * auto-connect the user. This comes with the trade-off that the connector will throw an error
+     * when attempting to switch to the unapproved chain if the wallet does not support dynamic session updates.
+     * This may be useful in cases where a dapp constantly
+     * modifies their configured chains, and they do not want to disconnect the user upon
+     * auto-connecting. If the user decides to switch to the unapproved chain, it is important that the
+     * dapp handles this error and prompts the user to reconnect to the dapp in order to approve
+     * the newly added chain.
+     *
+     * @default true
+     */
+    isNewChainsStale?: boolean;
+} & Omit<EthereumProviderOptions, 'chains' | 'events' | 'optionalChains' | 'optionalEvents' | 'optionalMethods' | 'methods' | 'rpcMap' | 'showQrModal'> & ExactPartial<Pick<EthereumProviderOptions, 'showQrModal'>>>;
+type ConnectParams = {
+    chainId?: number | undefined;
+    isReconnecting?: boolean | undefined;
+    pairingTopic?: string | undefined;
+};
+export declare function walletConnect(parameters: WalletConnectParameters): import("@wagmi/core").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, {
+    connect(parameters: ConnectParams): Promise<{
+        accounts: readonly Address[];
+        chainId: number;
+    }>;
+    getNamespaceChainsIds(): number[];
+    getRequestedChainsIds(): Promise<number[]>;
+    isChainsStale(): Promise<boolean>;
+    onConnect(connectInfo: ProviderConnectInfo): void;
+    onDisplayUri(uri: string): void;
+    onSessionDelete(data: {
+        topic: string;
+    }): void;
+    setRequestedChainsIds(chains: number[]): void;
+    requestedChainsStorageKey: `${string}.requestedChains`;
+}, {
+    [x: `${string}.requestedChains`]: number[];
+}>;
+export declare namespace walletConnect {
+    var type: "walletConnect";
+}
+export {};

package/dist/connectors/walletConnect.js

@@ -0,0 +1,366 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-MMUBH76A.js";
+import {
+  ChainNotConfiguredError,
+  ProviderNotFoundError,
+  createConnector,
+  extractRpcUrls
+} from "@wagmi/core";
+import {
+  SwitchChainError,
+  UserRejectedRequestError,
+  getAddress,
+  numberToHex
+} from "viem";
+walletConnect.type = "walletConnect";
+function walletConnect(parameters) {
+  var _a;
+  const isNewChainsStale = (_a = parameters.isNewChainsStale) != null ? _a : true;
+  let provider_;
+  let providerPromise;
+  const NAMESPACE = "eip155";
+  let accountsChanged;
+  let chainChanged;
+  let connect;
+  let displayUri;
+  let sessionDelete;
+  let disconnect;
+  return createConnector((config) => ({
+    id: "walletConnect",
+    name: "WalletConnect",
+    type: walletConnect.type,
+    setup() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider().catch(() => null);
+        if (!provider) return;
+        if (!connect) {
+          connect = this.onConnect.bind(this);
+          provider.on("connect", connect);
+        }
+        if (!sessionDelete) {
+          sessionDelete = this.onSessionDelete.bind(this);
+          provider.on("session_delete", sessionDelete);
+        }
+      });
+    },
+    connect() {
+      return __async(this, arguments, function* (_b = {}) {
+        var _c = _b, { chainId } = _c, rest = __objRest(_c, ["chainId"]);
+        var _a3, _b2, _c2;
+        try {
+          const provider = yield this.getProvider();
+          if (!provider) throw new ProviderNotFoundError();
+          if (!displayUri) {
+            displayUri = this.onDisplayUri;
+            provider.on("display_uri", displayUri);
+          }
+          let targetChainId = chainId;
+          if (!targetChainId) {
+            const state = (_b2 = yield (_a3 = config.storage) == null ? void 0 : _a3.getItem("state")) != null ? _b2 : {};
+            const isChainSupported = config.chains.some((x) => x.id === state.chainId);
+            if (isChainSupported) targetChainId = state.chainId;
+            else targetChainId = (_c2 = config.chains[0]) == null ? void 0 : _c2.id;
+          }
+          if (!targetChainId) throw new Error("No chains found on connector.");
+          const isChainsStale = yield this.isChainsStale();
+          if (provider.session && isChainsStale) yield provider.disconnect();
+          if (!provider.session || isChainsStale) {
+            const optionalChains = config.chains.filter((chain) => chain.id !== targetChainId).map((optionalChain) => optionalChain.id);
+            yield provider.connect(__spreadValues({
+              optionalChains: [targetChainId, ...optionalChains]
+            }, "pairingTopic" in rest ? { pairingTopic: rest.pairingTopic } : {}));
+            this.setRequestedChainsIds(config.chains.map((x) => x.id));
+          }
+          const accounts = (yield provider.enable()).map((x) => getAddress(x));
+          const currentChainId = yield this.getChainId();
+          if (displayUri) {
+            provider.removeListener("display_uri", displayUri);
+            displayUri = void 0;
+          }
+          if (connect) {
+            provider.removeListener("connect", connect);
+            connect = void 0;
+          }
+          if (!accountsChanged) {
+            accountsChanged = this.onAccountsChanged.bind(this);
+            provider.on("accountsChanged", accountsChanged);
+          }
+          if (!chainChanged) {
+            chainChanged = this.onChainChanged.bind(this);
+            provider.on("chainChanged", chainChanged);
+          }
+          if (!disconnect) {
+            disconnect = this.onDisconnect.bind(this);
+            provider.on("disconnect", disconnect);
+          }
+          if (!sessionDelete) {
+            sessionDelete = this.onSessionDelete.bind(this);
+            provider.on("session_delete", sessionDelete);
+          }
+          return { accounts, chainId: currentChainId };
+        } catch (error) {
+          if (/(user rejected|connection request reset)/i.test(error == null ? void 0 : error.message)) {
+            throw new UserRejectedRequestError(error);
+          }
+          throw error;
+        }
+      });
+    },
+    disconnect() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider();
+        try {
+          yield provider == null ? void 0 : provider.disconnect();
+        } catch (error) {
+          if (!/No matching key/i.test(error.message)) throw error;
+        } finally {
+          if (chainChanged) {
+            provider == null ? void 0 : provider.removeListener("chainChanged", chainChanged);
+            chainChanged = void 0;
+          }
+          if (disconnect) {
+            provider == null ? void 0 : provider.removeListener("disconnect", disconnect);
+            disconnect = void 0;
+          }
+          if (!connect) {
+            connect = this.onConnect.bind(this);
+            provider == null ? void 0 : provider.on("connect", connect);
+          }
+          if (accountsChanged) {
+            provider == null ? void 0 : provider.removeListener("accountsChanged", accountsChanged);
+            accountsChanged = void 0;
+          }
+          if (sessionDelete) {
+            provider == null ? void 0 : provider.removeListener("session_delete", sessionDelete);
+            sessionDelete = void 0;
+          }
+          this.setRequestedChainsIds([]);
+        }
+      });
+    },
+    getAccounts() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider();
+        return provider.accounts.map((x) => getAddress(x));
+      });
+    },
+    getProvider() {
+      return __async(this, arguments, function* ({ chainId } = {}) {
+        var _a3;
+        function initProvider() {
+          return __async(this, null, function* () {
+            var _a4;
+            const optionalChains = config.chains.map((x) => x.id);
+            if (!optionalChains.length) return;
+            const { EthereumProvider } = yield import("@walletconnect/ethereum-provider");
+            return yield EthereumProvider.init(__spreadProps(__spreadValues({}, parameters), {
+              disableProviderPing: true,
+              optionalChains,
+              projectId: parameters.projectId,
+              rpcMap: Object.fromEntries(
+                config.chains.map((chain) => {
+                  const [url] = extractRpcUrls({
+                    chain,
+                    transports: config.transports
+                  });
+                  return [chain.id, url];
+                })
+              ),
+              showQrModal: (_a4 = parameters.showQrModal) != null ? _a4 : true
+            }));
+          });
+        }
+        if (!provider_) {
+          if (!providerPromise) providerPromise = initProvider();
+          provider_ = yield providerPromise;
+          provider_ == null ? void 0 : provider_.events.setMaxListeners(Number.POSITIVE_INFINITY);
+        }
+        if (chainId) yield (_a3 = this.switchChain) == null ? void 0 : _a3.call(this, { chainId });
+        return provider_;
+      });
+    },
+    getChainId() {
+      return __async(this, null, function* () {
+        const provider = yield this.getProvider();
+        return provider.chainId;
+      });
+    },
+    isAuthorized() {
+      return __async(this, null, function* () {
+        try {
+          const [accounts, provider] = yield Promise.all([this.getAccounts(), this.getProvider()]);
+          if (!accounts.length) return false;
+          const isChainsStale = yield this.isChainsStale();
+          if (isChainsStale && provider.session) {
+            yield provider.disconnect().catch(() => {
+            });
+            return false;
+          }
+          return true;
+        } catch (e) {
+          return false;
+        }
+      });
+    },
+    switchChain(_0) {
+      return __async(this, arguments, function* ({ addEthereumChainParameter, chainId }) {
+        var _a3, _b, _c, _d, _e;
+        const provider = yield this.getProvider();
+        if (!provider) throw new ProviderNotFoundError();
+        const chain = config.chains.find((x) => x.id === chainId);
+        if (!chain) throw new SwitchChainError(new ChainNotConfiguredError());
+        try {
+          yield Promise.all([
+            new Promise((resolve) => {
+              const listener = ({ chainId: currentChainId }) => {
+                if (currentChainId === chainId) {
+                  config.emitter.off("change", listener);
+                  resolve();
+                }
+              };
+              config.emitter.on("change", listener);
+            }),
+            provider.request({
+              method: "wallet_switchEthereumChain",
+              params: [{ chainId: numberToHex(chainId) }]
+            })
+          ]);
+          const requestedChains = yield this.getRequestedChainsIds();
+          this.setRequestedChainsIds([...requestedChains, chainId]);
+          return chain;
+        } catch (err) {
+          const error = err;
+          if (/(user rejected)/i.test(error.message)) throw new UserRejectedRequestError(error);
+          try {
+            let blockExplorerUrls;
+            if (addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.blockExplorerUrls) blockExplorerUrls = addEthereumChainParameter.blockExplorerUrls;
+            else blockExplorerUrls = ((_a3 = chain.blockExplorers) == null ? void 0 : _a3.default.url) ? [(_b = chain.blockExplorers) == null ? void 0 : _b.default.url] : [];
+            let rpcUrls;
+            if ((_c = addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.rpcUrls) == null ? void 0 : _c.length) rpcUrls = addEthereumChainParameter.rpcUrls;
+            else rpcUrls = [...chain.rpcUrls.default.http];
+            const addEthereumChain = {
+              blockExplorerUrls,
+              chainId: numberToHex(chainId),
+              chainName: (_d = addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.chainName) != null ? _d : chain.name,
+              iconUrls: addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.iconUrls,
+              nativeCurrency: (_e = addEthereumChainParameter == null ? void 0 : addEthereumChainParameter.nativeCurrency) != null ? _e : chain.nativeCurrency,
+              rpcUrls
+            };
+            yield provider.request({
+              method: "wallet_addEthereumChain",
+              params: [addEthereumChain]
+            });
+            const requestedChains = yield this.getRequestedChainsIds();
+            this.setRequestedChainsIds([...requestedChains, chainId]);
+            return chain;
+          } catch (error2) {
+            throw new UserRejectedRequestError(error2);
+          }
+        }
+      });
+    },
+    onAccountsChanged(accounts) {
+      if (accounts.length === 0) this.onDisconnect();
+      else
+        config.emitter.emit("change", {
+          accounts: accounts.map((x) => getAddress(x))
+        });
+    },
+    onChainChanged(chain) {
+      const chainId = Number(chain);
+      config.emitter.emit("change", { chainId });
+    },
+    onConnect(connectInfo) {
+      return __async(this, null, function* () {
+        const chainId = Number(connectInfo.chainId);
+        const accounts = yield this.getAccounts();
+        config.emitter.emit("connect", { accounts, chainId });
+      });
+    },
+    onDisconnect(_error) {
+      return __async(this, null, function* () {
+        this.setRequestedChainsIds([]);
+        config.emitter.emit("disconnect");
+        const provider = yield this.getProvider();
+        if (accountsChanged) {
+          provider.removeListener("accountsChanged", accountsChanged);
+          accountsChanged = void 0;
+        }
+        if (chainChanged) {
+          provider.removeListener("chainChanged", chainChanged);
+          chainChanged = void 0;
+        }
+        if (disconnect) {
+          provider.removeListener("disconnect", disconnect);
+          disconnect = void 0;
+        }
+        if (sessionDelete) {
+          provider.removeListener("session_delete", sessionDelete);
+          sessionDelete = void 0;
+        }
+        if (!connect) {
+          connect = this.onConnect.bind(this);
+          provider.on("connect", connect);
+        }
+      });
+    },
+    onDisplayUri(uri) {
+      config.emitter.emit("message", { type: "display_uri", data: uri });
+    },
+    onSessionDelete() {
+      this.onDisconnect();
+    },
+    getNamespaceChainsIds() {
+      var _a3, _b, _c;
+      if (!provider_) return [];
+      const chainIds = (_c = (_b = (_a3 = provider_.session) == null ? void 0 : _a3.namespaces[NAMESPACE]) == null ? void 0 : _b.accounts) == null ? void 0 : _c.map(
+        (account) => Number.parseInt(account.split(":")[1] || "")
+      );
+      return chainIds != null ? chainIds : [];
+    },
+    getRequestedChainsIds() {
+      return __async(this, null, function* () {
+        var _a3, _b;
+        return (_b = yield (_a3 = config.storage) == null ? void 0 : _a3.getItem(this.requestedChainsStorageKey)) != null ? _b : [];
+      });
+    },
+    /**
+     * Checks if the target chains match the chains that were
+     * initially requested by the connector for the WalletConnect session.
+     * If there is a mismatch, this means that the chains on the connector
+     * are considered stale, and need to be revalidated at a later point (via
+     * connection).
+     *
+     * There may be a scenario where a dapp adds a chain to the
+     * connector later on, however, this chain will not have been approved or rejected
+     * by the wallet. In this case, the chain is considered stale.
+     */
+    isChainsStale() {
+      return __async(this, null, function* () {
+        if (!isNewChainsStale) return false;
+        const connectorChains = config.chains.map((x) => x.id);
+        const namespaceChains = this.getNamespaceChainsIds();
+        if (namespaceChains.length && !namespaceChains.some((id) => connectorChains.includes(id))) return false;
+        const requestedChains = yield this.getRequestedChainsIds();
+        return !connectorChains.every((id) => requestedChains.includes(id));
+      });
+    },
+    setRequestedChainsIds(chains) {
+      return __async(this, null, function* () {
+        var _a3;
+        yield (_a3 = config.storage) == null ? void 0 : _a3.setItem(this.requestedChainsStorageKey, chains);
+      });
+    },
+    get requestedChainsStorageKey() {
+      return `${this.id}.requestedChains`;
+    }
+  }));
+}
+export {
+  walletConnect
+};

package/dist/index.d.ts

@@ -1,6 +1,8 @@
+export { createParaWagmiConfig } from './providers/createParaWagmiConfig.js';
 export { EvmExternalWalletContext } from './providers/EvmExternalWalletContext.js';
-export type { EvmExternalWalletContextType } from './providers/EvmExternalWalletContext.js';
+export { type EvmExternalWalletContextType } from './providers/EvmExternalWalletContext.js';
 export { ParaEvmProvider } from './providers/ParaEvmContext.js';
 export type { ParaEvmProviderProps, ParaEvmProviderConfig, ParaWagmiProviderProps } from './providers/ParaEvmContext.js';
-export * from './wallets/connectors/index.js';
+export { getWagmiConfig } from './stores/wagmiConfigStore.js';
 export type { WalletList } from './types/Wallet.js';
+export * from './wallets/connectors/index.js';

package/dist/index.js

@@ -1,9 +1,13 @@
 "use client";
 import "./chunk-MMUBH76A.js";
+import { createParaWagmiConfig } from "./providers/createParaWagmiConfig.js";
 import { EvmExternalWalletContext } from "./providers/EvmExternalWalletContext.js";
 import { ParaEvmProvider } from "./providers/ParaEvmContext.js";
+import { getWagmiConfig } from "./stores/wagmiConfigStore.js";
 export * from "./wallets/connectors/index.js";
 export {
   EvmExternalWalletContext,
-  ParaEvmProvider
+  ParaEvmProvider,
+  createParaWagmiConfig,
+  getWagmiConfig
 };

package/dist/providers/EvmExternalWalletContext.d.ts

@@ -1,40 +1,12 @@
 import { PropsWithChildren } from 'react';
-import type { CommonChain, CommonWallet, TExternalWallet } from '@getpara/react-common';
-import ParaWeb, { Wallet } from '@getpara/web-sdk';
-export type EvmExternalWalletContextType = {
-    wallets: CommonWallet[];
-    chains: CommonChain[];
-    chainId?: number;
+import { FarcasterMiniAppManagement, type BalanceManagement, type ChainManagement, type ConnectParaEmbedded, type ExternalWalletContextType, type ExternalWalletProviderConfigBase } from '@getpara/react-common';
+import { TExternalHooks } from './externalHooks.js';
+export type EvmExternalWalletContextType = ExternalWalletContextType & ChainManagement<number> & BalanceManagement & ConnectParaEmbedded & TExternalHooks & {
     username?: string;
     avatar?: string;
-    balance?: string;
-    disconnect: () => Promise<void>;
-    switchChain: (chainId: number) => Promise<{
-        error?: string[];
-    }>;
-    connectParaEmbedded: () => Promise<{
-        result?: unknown;
-        error?: string;
-    }>;
-    signMessage: (message: string) => Promise<{
-        signature?: string;
-        error?: string;
-    }>;
-    signVerificationMessage: () => Promise<{
-        address?: string;
-        signature?: string;
-        error?: string;
-    }>;
-    getWalletBalance: () => Promise<string | undefined>;
+} & FarcasterMiniAppManagement & {
+    verificationStage: 'verifying' | 'switchingChain';
 };
 export declare const EvmExternalWalletContext: import("react").Context<EvmExternalWalletContextType>;
-export type EvmExternalWalletProviderConfig = {
-    onSwitchWallet?: (args: {
-        address?: string;
-        error?: string;
-    }) => void;
-    para: ParaWeb;
-    walletsWithFullAuth: TExternalWallet[];
-    connectedWallet?: Omit<Wallet, 'signer'> | null;
-};
-export declare function EvmExternalWalletProvider({ children, onSwitchWallet, para, walletsWithFullAuth, connectedWallet, }: EvmExternalWalletProviderConfig & PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export type EvmExternalWalletProviderConfig = ExternalWalletProviderConfigBase;
+export declare function EvmExternalWalletProvider({ children, onSwitchWallet, para, walletsWithFullAuth, connectedWallet: connectedWalletProp, includeWalletVerification, connectionOnly, }: EvmExternalWalletProviderConfig & PropsWithChildren): import("react/jsx-runtime").JSX.Element;