@dynamic-labs/ethereum 0.19.0-alpha.2 → 0.19.0-alpha.20

package/src/legacyEthProviderHelper.js

@@ -0,0 +1,183 @@
+import { __awaiter } from '../_virtual/_tslib.js';
+import { createWalletClient, custom, getAddress } from 'viem';
+import { ProviderLookup, normalizeWalletName, logger } from '@dynamic-labs/wallet-connector-core';
+import { isUnsupportedProviderError } from './utils/isUnsupportedProviderError/isUnsupportedProviderError.js';
+import { eventListenerHandlers } from './utils/eventListenerHandlers.js';
+
+var _a;
+class LegacyEthProviderHelper {
+    static installedProviderLookup(providerFlags) {
+        const allInstalledProviders = this.allInstalledProviders();
+        return ProviderLookup(allInstalledProviders, providerFlags);
+    }
+    static allInstalledProviders() {
+        var _b;
+        const ethereumProviders = [];
+        if (window.ethereum) {
+            if (!window.ethereum.providers) {
+                ethereumProviders.push(window.ethereum);
+            }
+            else {
+                window.ethereum.providers.forEach((provider) => {
+                    ethereumProviders.push(provider);
+                });
+            }
+        }
+        if ((_b = window.phantom) === null || _b === void 0 ? void 0 : _b.ethereum) {
+            ethereumProviders.push(window.phantom.ethereum);
+        }
+        if (window.zerionWallet) {
+            ethereumProviders.push(window.zerionWallet);
+        }
+        if (window.coinbaseWalletExtension) {
+            ethereumProviders.push(window.coinbaseWalletExtension);
+        }
+        if (window.superb) {
+            ethereumProviders.push(window.superb);
+        }
+        return ethereumProviders;
+    }
+    static isInstalledHelper(walletName) {
+        return this.findProvider(walletName) !== undefined;
+    }
+    static findProvider(walletName) {
+        var _b, _c;
+        try {
+            return (_c = (_b = this.providers)[normalizeWalletName(walletName)]) === null || _c === void 0 ? void 0 : _c.call(_b);
+        }
+        catch (err) {
+            if (isUnsupportedProviderError(err)) {
+                logger.error(`ETH Provider is not supported ${err.value}`, err);
+                return;
+            }
+            logger.error(`Could not find provider for ${walletName}`, err);
+            return undefined;
+        }
+    }
+    static findWalletClient(walletName) {
+        const provider = this.findProvider(walletName);
+        if (!provider) {
+            return undefined;
+        }
+        return createWalletClient({
+            transport: custom(provider),
+        });
+    }
+    static fetchPublicAddressWithName(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.findWalletClient(name);
+            if (!client) {
+                return Promise.resolve(undefined);
+            }
+            return this.fetchPublicAddressWithProvider(client);
+        });
+    }
+    static fetchPublicAddressWithProvider(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const [lowercaseAddress] = yield client.requestAddresses();
+                const publicAddress = getAddress(lowercaseAddress);
+                return publicAddress;
+            }
+            catch (err) {
+                logger.error(err);
+                return Promise.reject(err);
+            }
+        });
+    }
+    static signMessageWithName(messageToSign, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletAddress = yield this.fetchPublicAddressWithName(name);
+            if (!walletAddress) {
+                return Promise.resolve(undefined);
+            }
+            const client = this.findWalletClient(name);
+            if (!client) {
+                return Promise.resolve(undefined);
+            }
+            const signedMessage = yield client.signMessage({
+                account: walletAddress,
+                message: messageToSign,
+            });
+            return signedMessage;
+        });
+    }
+    static _setupEventListeners(walletName, walletConnector, publicClient) {
+        const web3Provider = this.findProvider(walletName);
+        if (!web3Provider) {
+            return {
+                tearDownEventListeners: () => { },
+            };
+        }
+        const { handleAccountChange, handleChainChange, handleDisconnect } = eventListenerHandlers(walletConnector, publicClient);
+        web3Provider.on('accountsChanged', handleAccountChange);
+        web3Provider.on('chainChanged', handleChainChange);
+        web3Provider.on('disconnect', handleDisconnect);
+        const tearDownEventListeners = () => {
+            const web3Provider = this.findProvider(walletName);
+            if (!web3Provider) {
+                return;
+            }
+            if (handleAccountChange) {
+                web3Provider.removeListener('accountsChanged', handleAccountChange);
+            }
+            if (handleChainChange) {
+                web3Provider.removeListener('chainChanged', handleChainChange);
+            }
+            if (handleDisconnect) {
+                web3Provider.removeListener('disconnect', handleDisconnect);
+            }
+        };
+        return {
+            tearDownEventListeners,
+        };
+    }
+}
+_a = LegacyEthProviderHelper;
+LegacyEthProviderHelper.BraveProvider = () => _a.installedProviderLookup([{ flag: 'isBraveWallet', value: true }]);
+LegacyEthProviderHelper.DawnProvider = () => _a.installedProviderLookup([{ flag: 'isDawn', value: true }]);
+LegacyEthProviderHelper.FrameProvider = () => _a.installedProviderLookup([{ flag: 'isFrame', value: true }]);
+LegacyEthProviderHelper.CoinbaseProvider = () => _a.installedProviderLookup([{ flag: 'isCoinbaseWallet', value: true }]);
+LegacyEthProviderHelper.OperaProvider = () => _a.installedProviderLookup([{ flag: 'isOpera', value: true }]);
+LegacyEthProviderHelper.GameStopProvider = () => _a.installedProviderLookup([{ flag: 'isGamestop', value: true }]);
+LegacyEthProviderHelper.ExodusProvider = () => _a.installedProviderLookup([{ flag: 'isExodus', value: true }]);
+LegacyEthProviderHelper.BloctoProvider = () => _a.installedProviderLookup([{ flag: 'isBlocto', value: true }]);
+LegacyEthProviderHelper.TrustWalletProvider = () => _a.installedProviderLookup([{ flag: 'isTrustWallet', value: true }]);
+LegacyEthProviderHelper.PhantomProvider = () => _a.installedProviderLookup([{ flag: 'isPhantom', value: true }]);
+LegacyEthProviderHelper.ZerionProvider = () => _a.installedProviderLookup([{ flag: 'isZerion', value: true }]);
+LegacyEthProviderHelper.SuperbProvider = () => _a.installedProviderLookup([{ flag: 'isSuperb', value: true }]);
+LegacyEthProviderHelper.RabbyProvider = () => _a.installedProviderLookup([{ flag: 'isRabby', value: true }]);
+LegacyEthProviderHelper.OKXProvider = () => _a.installedProviderLookup([{ flag: 'isOkxWallet', value: true }]);
+LegacyEthProviderHelper.UnknownInjectedProvider = () => _a.installedProviderLookup([
+    { flag: 'isMetaMask', value: false },
+    { flag: 'isExodus', value: false },
+    { flag: 'isCoinbaseWallet', value: false },
+    { flag: 'isBraveWallet', value: false },
+    { flag: 'isGamestop', value: false },
+    { flag: 'isFrame', value: false },
+    { flag: 'isOpera', value: false },
+    { flag: 'isBlocto', value: false },
+    { flag: 'isTrustWallet', value: false },
+    { flag: 'isPhantom', value: false },
+    { flag: 'isZerion', value: false },
+    { flag: 'isSuperb', value: false },
+    { flag: 'isRabby', value: false },
+]);
+LegacyEthProviderHelper.providers = {
+    bloctoinjected: _a.BloctoProvider,
+    braveevm: _a.BraveProvider,
+    coinbase: _a.CoinbaseProvider,
+    dawn: _a.DawnProvider,
+    exodusevm: _a.ExodusProvider,
+    frame: _a.FrameProvider,
+    gamestop: _a.GameStopProvider,
+    injectedwallet: _a.UnknownInjectedProvider,
+    opera: _a.OperaProvider,
+    phantomevm: _a.PhantomProvider,
+    rabby: _a.RabbyProvider,
+    superb: _a.SuperbProvider,
+    trust: _a.TrustWalletProvider,
+    zerion: _a.ZerionProvider,
+};
+
+export { LegacyEthProviderHelper };

package/src/polyfills.cjs

@@ -2,15 +2,15 @@
 
 var _ = require('buffer/');
 
-/* eslint-disable */
-/**
- * @walletconnect/client and @walletconnect/qrcode-modal use `global` and `Buffer`, respectively.
- * This issue is captured here: https://github.com/WalletConnect/walletconnect-monorepo/issues/341
- * Here are some GH issues of others facing the same problem:
- *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/734
- *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/748
- */
-if (typeof window !== 'undefined') {
-    window.global = globalThis;
-    Object.assign(window, { Buffer: _.Buffer });
+/* eslint-disable */
+/**
+ * @walletconnect/client and @walletconnect/qrcode-modal use `global` and `Buffer`, respectively.
+ * This issue is captured here: https://github.com/WalletConnect/walletconnect-monorepo/issues/341
+ * Here are some GH issues of others facing the same problem:
+ *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/734
+ *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/748
+ */
+if (typeof window !== 'undefined') {
+    window.global = globalThis;
+    Object.assign(window, { Buffer: _.Buffer });
 }

package/src/polyfills.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/src/polyfills.js

@@ -1,14 +1,14 @@
 import { Buffer } from 'buffer/index.js';
 
-/* eslint-disable */
-/**
- * @walletconnect/client and @walletconnect/qrcode-modal use `global` and `Buffer`, respectively.
- * This issue is captured here: https://github.com/WalletConnect/walletconnect-monorepo/issues/341
- * Here are some GH issues of others facing the same problem:
- *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/734
- *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/748
- */
-if (typeof window !== 'undefined') {
-    window.global = globalThis;
-    Object.assign(window, { Buffer });
+/* eslint-disable */
+/**
+ * @walletconnect/client and @walletconnect/qrcode-modal use `global` and `Buffer`, respectively.
+ * This issue is captured here: https://github.com/WalletConnect/walletconnect-monorepo/issues/341
+ * Here are some GH issues of others facing the same problem:
+ *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/734
+ *   * https://github.com/WalletConnect/walletconnect-monorepo/issues/748
+ */
+if (typeof window !== 'undefined') {
+    window.global = globalThis;
+    Object.assign(window, { Buffer });
 }

package/src/types.d.ts

@@ -1,24 +1,37 @@
-import { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
-declare global {
-    interface IWindowPhantom {
-        ethereum: IEthereum;
-    }
-    interface Window {
-        ethereum?: IEthereum;
-        phantom?: IWindowPhantom;
-        zerionWallet?: IEthereum;
-        coinbaseWalletExtension?: IEthereum;
-        superb?: IEthereum;
-        okxwallet?: IEthereum;
-    }
-}
-export type IEthereum = {
-    [key in ProviderFlag]: boolean;
-} & {
-    providers?: object[];
-    request: <T extends string>(params: {
-        method: T;
-    } | object) => Promise<T extends 'eth_requestAccounts' ? [string] : object>;
-};
-export type ProviderFlag = 'isDawn' | 'isBraveWallet' | 'isCoinbaseWallet' | 'isFrame' | 'isGamestop' | 'isMetaMask' | 'isExodus' | 'isOpera' | 'isBlocto' | 'isTrustWallet' | 'isZerion' | 'isPhantom' | 'isSuperb' | 'isRabby' | 'isOkxWallet';
-export type EthProviderCondition = ProviderCondition<ProviderFlag>;
+/// <reference types="node" />
+import { EventEmitter } from 'stream';
+import { PublicClient } from 'viem';
+import { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
+declare global {
+    interface IWindowPhantom {
+        ethereum: IEthereum;
+    }
+    interface Window {
+        ethereum?: IEthereum;
+        phantom?: IWindowPhantom;
+        zerionWallet?: IEthereum;
+        coinbaseWalletExtension?: IEthereum;
+        superb?: IEthereum;
+        okxwallet?: IEthereum;
+    }
+}
+export type IEthereum = {
+    [key in ProviderFlag]: boolean;
+} & {
+    providers?: object[];
+    request: <T extends string>(params: {
+        method: T;
+    } | object) => Promise<T extends 'eth_requestAccounts' ? [string] : object>;
+} & EventEmitter;
+export type ProviderFlag = 'isDawn' | 'isBraveWallet' | 'isCoinbaseWallet' | 'isFrame' | 'isGamestop' | 'isMetaMask' | 'isExodus' | 'isOpera' | 'isBlocto' | 'isTrustWallet' | 'isZerion' | 'isPhantom' | 'isSuperb' | 'isRabby' | 'isOkxWallet';
+export type EthProviderCondition = ProviderCondition<ProviderFlag>;
+export type Provider = () => PublicClient | undefined;
+export type AccountChangeEventHandler = (accounts: string[]) => Promise<void>;
+export type ChainChangeEventHandler = (chainId: string | number) => Promise<void>;
+export type DisconnectEventHandler = (error?: {
+    code: number;
+}) => Promise<void>;
+export type ExternalProviderEventEmitter = PublicClient & {
+    on: (event: string, listener: (...args: Array<any>) => unknown) => void;
+    removeListener: (event: string, listener: (...args: Array<any>) => unknown) => void;
+};

package/src/utils/eventListenerHandlers.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+
+const eventListenerHandlers = (walletConnector, publicClient) => {
+    const handleAccountChange = (accounts) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        if (accounts.length === 0) {
+            walletConnector.emit('disconnect');
+            return;
+        }
+        walletConnector.emit('accountChange', { accounts });
+    });
+    const handleChainChange = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const chainId = yield publicClient.getChainId();
+        walletConnector.emit('chainChange', {
+            chain: chainId.toString(),
+        });
+    });
+    const handleDisconnect = (error) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 1013) {
+            return;
+        }
+        walletConnector.emit('disconnect');
+    });
+    return {
+        handleAccountChange,
+        handleChainChange,
+        handleDisconnect,
+    };
+};
+
+exports.eventListenerHandlers = eventListenerHandlers;

package/src/utils/eventListenerHandlers.d.ts

@@ -0,0 +1,8 @@
+import { PublicClient } from 'viem';
+import { WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { AccountChangeEventHandler, ChainChangeEventHandler, DisconnectEventHandler } from '../types';
+export declare const eventListenerHandlers: (walletConnector: WalletConnector, publicClient: PublicClient) => {
+    handleAccountChange: AccountChangeEventHandler;
+    handleChainChange: ChainChangeEventHandler;
+    handleDisconnect: DisconnectEventHandler;
+};

package/src/utils/eventListenerHandlers.js

@@ -0,0 +1,30 @@
+import { __awaiter } from '../../_virtual/_tslib.js';
+
+const eventListenerHandlers = (walletConnector, publicClient) => {
+    const handleAccountChange = (accounts) => __awaiter(void 0, void 0, void 0, function* () {
+        if (accounts.length === 0) {
+            walletConnector.emit('disconnect');
+            return;
+        }
+        walletConnector.emit('accountChange', { accounts });
+    });
+    const handleChainChange = () => __awaiter(void 0, void 0, void 0, function* () {
+        const chainId = yield publicClient.getChainId();
+        walletConnector.emit('chainChange', {
+            chain: chainId.toString(),
+        });
+    });
+    const handleDisconnect = (error) => __awaiter(void 0, void 0, void 0, function* () {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 1013) {
+            return;
+        }
+        walletConnector.emit('disconnect');
+    });
+    return {
+        handleAccountChange,
+        handleChainChange,
+        handleDisconnect,
+    };
+};
+
+export { eventListenerHandlers };

package/src/utils/findEvmNetwork.cjs

@@ -2,19 +2,19 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const findEvmNetwork = ({ chainId, name, networks, }) => {
-    if (!chainId && !name) {
-        return undefined;
-    }
-    if (chainId && name) {
-        return networks.find((network) => network.chainId === chainId && network.name === name);
-    }
-    else if (chainId) {
-        return networks.find((network) => network.chainId === chainId);
-    }
-    else {
-        return networks.find((network) => network.name === name);
-    }
+const findEvmNetwork = ({ chainId, name, networks, }) => {
+    if (!chainId && !name) {
+        return undefined;
+    }
+    if (chainId && name) {
+        return networks.find((network) => network.chainId === chainId && network.name === name);
+    }
+    else if (chainId) {
+        return networks.find((network) => network.chainId === chainId);
+    }
+    else {
+        return networks.find((network) => network.name === name);
+    }
 };
 
 exports.findEvmNetwork = findEvmNetwork;

package/src/utils/findEvmNetwork.d.ts

@@ -1,6 +1,6 @@
-import { EvmNetwork } from '@dynamic-labs/types';
-export declare const findEvmNetwork: ({ chainId, name, networks, }: {
-    chainId?: number | undefined;
-    name?: string | undefined;
-    networks: EvmNetwork[];
-}) => EvmNetwork | undefined;
+import { EvmNetwork } from '@dynamic-labs/types';
+export declare const findEvmNetwork: ({ chainId, name, networks, }: {
+    chainId?: number | undefined;
+    name?: string | undefined;
+    networks: EvmNetwork[];
+}) => EvmNetwork | undefined;

package/src/utils/findEvmNetwork.js

@@ -1,16 +1,16 @@
-const findEvmNetwork = ({ chainId, name, networks, }) => {
-    if (!chainId && !name) {
-        return undefined;
-    }
-    if (chainId && name) {
-        return networks.find((network) => network.chainId === chainId && network.name === name);
-    }
-    else if (chainId) {
-        return networks.find((network) => network.chainId === chainId);
-    }
-    else {
-        return networks.find((network) => network.name === name);
-    }
+const findEvmNetwork = ({ chainId, name, networks, }) => {
+    if (!chainId && !name) {
+        return undefined;
+    }
+    if (chainId && name) {
+        return networks.find((network) => network.chainId === chainId && network.name === name);
+    }
+    else if (chainId) {
+        return networks.find((network) => network.chainId === chainId);
+    }
+    else {
+        return networks.find((network) => network.name === name);
+    }
 };
 
 export { findEvmNetwork };

package/src/utils/isString.d.ts

@@ -1 +1 @@
-export declare const isString: (value: unknown) => value is string;
+export declare const isString: (value: unknown) => value is string;

package/src/utils/isUnsupportedProviderError/index.d.ts

@@ -1 +1 @@
-export { isUnsupportedProviderError } from './isUnsupportedProviderError';
+export { isUnsupportedProviderError } from './isUnsupportedProviderError';

package/src/utils/isUnsupportedProviderError/isUnsupportedProviderError.cjs

@@ -2,12 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const isUnsupportedProviderError = (error) => {
-    const isObject = typeof error === 'object';
-    if (!isObject)
-        return false;
-    const isUnsupportedProviderErrorReason = error['reason'] === 'unsupported provider';
-    return isUnsupportedProviderErrorReason;
+const isUnsupportedProviderError = (error) => {
+    const isObject = typeof error === 'object';
+    if (!isObject)
+        return false;
+    const isUnsupportedProviderErrorReason = error['reason'] === 'unsupported provider';
+    return isUnsupportedProviderErrorReason;
 };
 
 exports.isUnsupportedProviderError = isUnsupportedProviderError;

package/src/utils/isUnsupportedProviderError/isUnsupportedProviderError.d.ts

@@ -1,6 +1,6 @@
-type UnsupportedProviderError = {
-    reason: string;
-    value: unknown;
-};
-export declare const isUnsupportedProviderError: (error: UnsupportedProviderError | unknown) => error is UnsupportedProviderError;
-export {};
+type UnsupportedProviderError = {
+    reason: string;
+    value: unknown;
+};
+export declare const isUnsupportedProviderError: (error: UnsupportedProviderError | unknown) => error is UnsupportedProviderError;
+export {};

package/src/utils/isUnsupportedProviderError/isUnsupportedProviderError.js

@@ -1,9 +1,9 @@
-const isUnsupportedProviderError = (error) => {
-    const isObject = typeof error === 'object';
-    if (!isObject)
-        return false;
-    const isUnsupportedProviderErrorReason = error['reason'] === 'unsupported provider';
-    return isUnsupportedProviderErrorReason;
+const isUnsupportedProviderError = (error) => {
+    const isObject = typeof error === 'object';
+    if (!isObject)
+        return false;
+    const isUnsupportedProviderErrorReason = error['reason'] === 'unsupported provider';
+    return isUnsupportedProviderErrorReason;
 };
 
 export { isUnsupportedProviderError };

package/src/utils/last.d.ts

@@ -1 +1 @@
-export declare const last: <T = unknown>(array: T[]) => T | undefined;
+export declare const last: <T = unknown>(array: T[]) => T | undefined;

package/src/utils/parseIntSafe.cjs

@@ -4,19 +4,19 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 
-const parseIntSafe = (value, radix = 10) => {
-    try {
-        const int = parseInt(String(value), radix);
-        if (isNaN(int)) {
-            walletConnectorCore.logger.error(`Error parsing ${value}`);
-            return undefined;
-        }
-        return int;
-    }
-    catch (e) {
-        walletConnectorCore.logger.error(`Error parsing ${value} to int: ${e}`);
-    }
-    return undefined;
+const parseIntSafe = (value, radix = 10) => {
+    try {
+        const int = parseInt(String(value), radix);
+        if (isNaN(int)) {
+            walletConnectorCore.logger.error(`Error parsing ${value}`);
+            return undefined;
+        }
+        return int;
+    }
+    catch (e) {
+        walletConnectorCore.logger.error(`Error parsing ${value} to int: ${e}`);
+    }
+    return undefined;
 };
 
 exports.parseIntSafe = parseIntSafe;

package/src/utils/parseIntSafe.d.ts

@@ -1 +1 @@
-export declare const parseIntSafe: (value: string | number, radix?: number) => number | undefined;
+export declare const parseIntSafe: (value: string | number, radix?: number) => number | undefined;

package/src/utils/parseIntSafe.js

@@ -1,18 +1,18 @@
 import { logger } from '@dynamic-labs/wallet-connector-core';
 
-const parseIntSafe = (value, radix = 10) => {
-    try {
-        const int = parseInt(String(value), radix);
-        if (isNaN(int)) {
-            logger.error(`Error parsing ${value}`);
-            return undefined;
-        }
-        return int;
-    }
-    catch (e) {
-        logger.error(`Error parsing ${value} to int: ${e}`);
-    }
-    return undefined;
+const parseIntSafe = (value, radix = 10) => {
+    try {
+        const int = parseInt(String(value), radix);
+        if (isNaN(int)) {
+            logger.error(`Error parsing ${value}`);
+            return undefined;
+        }
+        return int;
+    }
+    catch (e) {
+        logger.error(`Error parsing ${value} to int: ${e}`);
+    }
+    return undefined;
 };
 
 export { parseIntSafe };