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

package/src/injected/Trust.cjs

@@ -2,14 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var InjectedWalletBase = require('./InjectedWalletBase.cjs');
-
-class Trust extends InjectedWalletBase {
-    constructor() {
-        super(...arguments);
-        this.name = 'Trust';
-        this.walletConnectorFallback = true;
-    }
+var LegacyInjectedWalletBase = require('./LegacyInjectedWalletBase.cjs');
+
+class Trust extends LegacyInjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'Trust';
+        this.walletConnectorFallback = true;
+    }
 }
 
 exports.Trust = Trust;

package/src/injected/Trust.d.ts

@@ -1,5 +1,5 @@
-import InjectedWalletBase from './InjectedWalletBase';
-export declare class Trust extends InjectedWalletBase {
-    name: string;
-    walletConnectorFallback: boolean;
-}
+import LegacyInjectedWalletBase from './LegacyInjectedWalletBase';
+export declare class Trust extends LegacyInjectedWalletBase {
+    name: string;
+    walletConnectorFallback: boolean;
+}

package/src/injected/Trust.js

@@ -1,11 +1,11 @@
-import InjectedWalletBase from './InjectedWalletBase.js';
+import LegacyInjectedWalletBase from './LegacyInjectedWalletBase.js';
 
-class Trust extends InjectedWalletBase {
-    constructor() {
-        super(...arguments);
-        this.name = 'Trust';
-        this.walletConnectorFallback = true;
-    }
+class Trust extends LegacyInjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'Trust';
+        this.walletConnectorFallback = true;
+    }
 }
 
 export { Trust };

package/src/injected/Zerion.cjs

@@ -2,14 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var InjectedWalletBase = require('./InjectedWalletBase.cjs');
-
-class Zerion extends InjectedWalletBase {
-    constructor() {
-        super(...arguments);
-        this.name = 'Zerion';
-        this.walletConnectorFallback = true;
-    }
+var LegacyInjectedWalletBase = require('./LegacyInjectedWalletBase.cjs');
+
+class Zerion extends LegacyInjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'Zerion';
+        this.walletConnectorFallback = true;
+    }
 }
 
 exports.Zerion = Zerion;

package/src/injected/Zerion.d.ts

@@ -1,5 +1,5 @@
-import InjectedWalletBase from './InjectedWalletBase';
-export declare class Zerion extends InjectedWalletBase {
-    name: string;
-    walletConnectorFallback: boolean;
-}
+import LegacyInjectedWalletBase from './LegacyInjectedWalletBase';
+export declare class Zerion extends LegacyInjectedWalletBase {
+    name: string;
+    walletConnectorFallback: boolean;
+}

package/src/injected/Zerion.js

@@ -1,11 +1,11 @@
-import InjectedWalletBase from './InjectedWalletBase.js';
+import LegacyInjectedWalletBase from './LegacyInjectedWalletBase.js';
 
-class Zerion extends InjectedWalletBase {
-    constructor() {
-        super(...arguments);
-        this.name = 'Zerion';
-        this.walletConnectorFallback = true;
-    }
+class Zerion extends LegacyInjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'Zerion';
+        this.walletConnectorFallback = true;
+    }
 }
 
 export { Zerion };

package/src/injected/fetchInjectedWalletConnectors.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+var legacyInjectedWallets = require('./legacyInjectedWallets.cjs');
+
+const fetchInjectedWalletConnector = ({ walletBook, }) => {
+    var _a;
+    return Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        .filter(([key, wallet]) => {
+        var _a;
+        return ((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => config.chain === 'evm')) &&
+            !legacyInjectedWallets.filteredLegacyInjectedWalletKeys.includes(key);
+    })
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        const walletConnectorFallback = Boolean(wallet.walletConnect);
+        return class extends InjectedWalletBase {
+            constructor(props) {
+                super(Object.assign({}, props));
+                this.name = name;
+                this.wallet = wallet;
+                this.walletConnectorFallback = walletConnectorFallback;
+                // this is the key from the wallet book entry so that we don't purely rely on the normalized name
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+exports.fetchInjectedWalletConnector = fetchInjectedWalletConnector;

package/src/injected/fetchInjectedWalletConnectors.d.ts

@@ -0,0 +1,6 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+export declare const fetchInjectedWalletConnector: ({ walletBook, }: {
+    isWalletConnectV2Enabled: boolean;
+    walletBook: WalletBookSchema;
+}) => WalletConnectorConstructor[];

package/src/injected/fetchInjectedWalletConnectors.js

@@ -0,0 +1,29 @@
+import InjectedWalletBase from './InjectedWalletBase.js';
+import { filteredLegacyInjectedWalletKeys } from './legacyInjectedWallets.js';
+
+const fetchInjectedWalletConnector = ({ walletBook, }) => {
+    var _a;
+    return Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        .filter(([key, wallet]) => {
+        var _a;
+        return ((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => config.chain === 'evm')) &&
+            !filteredLegacyInjectedWalletKeys.includes(key);
+    })
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        const walletConnectorFallback = Boolean(wallet.walletConnect);
+        return class extends InjectedWalletBase {
+            constructor(props) {
+                super(Object.assign({}, props));
+                this.name = name;
+                this.wallet = wallet;
+                this.walletConnectorFallback = walletConnectorFallback;
+                // this is the key from the wallet book entry so that we don't purely rely on the normalized name
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+export { fetchInjectedWalletConnector };

package/src/injected/index.d.ts

@@ -1,16 +1,13 @@
-import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
-export * from './BloctoInjected';
-export * from './BraveEvm';
-export * from './Dawn';
-export * from './ExodusEvm';
-export * from './Frame';
-export * from './GameStop';
-export * from './MetaMask';
-export * from './Opera';
-export * from './PhantomEvm';
-export * from './Trust';
-export * from './UnknownInjectedWallet';
-export * from './Zerion';
-export * from './Rabby';
-export * from './OKX';
-export declare const injectedWallets: WalletConnectorConstructor[];
+export * from './BloctoInjected';
+export * from './BraveEvm';
+export * from './Dawn';
+export * from './ExodusEvm';
+export * from './Frame';
+export * from './GameStop';
+export * from './Opera';
+export * from './PhantomEvm';
+export * from './Trust';
+export * from './Zerion';
+export * from './Rabby';
+export * from './fetchInjectedWalletConnectors';
+export * from './legacyInjectedWallets';

package/src/injected/legacyInjectedWallets.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var BloctoInjected = require('./BloctoInjected.cjs');
+var BraveEvm = require('./BraveEvm.cjs');
+var Dawn = require('./Dawn.cjs');
+var ExodusEvm = require('./ExodusEvm.cjs');
+var Frame = require('./Frame.cjs');
+var GameStop = require('./GameStop.cjs');
+var Opera = require('./Opera.cjs');
+var PhantomEvm = require('./PhantomEvm.cjs');
+var Trust = require('./Trust.cjs');
+var Zerion = require('./Zerion.cjs');
+var Superb = require('./Superb.cjs');
+var Rabby = require('./Rabby.cjs');
+
+const legacyInjectedWallets = [
+    PhantomEvm.PhantomEvm,
+    BloctoInjected.BloctoInjected,
+    BraveEvm.BraveEvm,
+    Dawn.Dawn,
+    ExodusEvm.ExodusEvm,
+    Frame.Frame,
+    GameStop.GameStop,
+    Opera.Opera,
+    Trust.Trust,
+    Zerion.Zerion,
+    Superb.Superb,
+    Rabby.Rabby,
+];
+const filteredLegacyInjectedWalletKeys = [
+    'phantomevm',
+    'coinbase',
+    'bloctoinjected',
+    'dawn',
+    'exodusevm',
+    'frame',
+    'gamestop',
+    'opera',
+    'trust',
+    'zerion',
+    'superb',
+    'rabby',
+];
+
+exports.filteredLegacyInjectedWalletKeys = filteredLegacyInjectedWalletKeys;
+exports.legacyInjectedWallets = legacyInjectedWallets;

package/src/injected/legacyInjectedWallets.d.ts

@@ -0,0 +1,3 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export declare const legacyInjectedWallets: WalletConnectorConstructor[];
+export declare const filteredLegacyInjectedWalletKeys: string[];

package/src/injected/legacyInjectedWallets.js

@@ -0,0 +1,43 @@
+import { BloctoInjected } from './BloctoInjected.js';
+import { BraveEvm } from './BraveEvm.js';
+import { Dawn } from './Dawn.js';
+import { ExodusEvm } from './ExodusEvm.js';
+import { Frame } from './Frame.js';
+import { GameStop } from './GameStop.js';
+import { Opera } from './Opera.js';
+import { PhantomEvm } from './PhantomEvm.js';
+import { Trust } from './Trust.js';
+import { Zerion } from './Zerion.js';
+import { Superb } from './Superb.js';
+import { Rabby } from './Rabby.js';
+
+const legacyInjectedWallets = [
+    PhantomEvm,
+    BloctoInjected,
+    BraveEvm,
+    Dawn,
+    ExodusEvm,
+    Frame,
+    GameStop,
+    Opera,
+    Trust,
+    Zerion,
+    Superb,
+    Rabby,
+];
+const filteredLegacyInjectedWalletKeys = [
+    'phantomevm',
+    'coinbase',
+    'bloctoinjected',
+    'dawn',
+    'exodusevm',
+    'frame',
+    'gamestop',
+    'opera',
+    'trust',
+    'zerion',
+    'superb',
+    'rabby',
+];
+
+export { filteredLegacyInjectedWalletKeys, legacyInjectedWallets };

package/src/legacyEthProviderHelper.cjs

@@ -0,0 +1,187 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var viem = require('viem');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var isUnsupportedProviderError = require('./utils/isUnsupportedProviderError/isUnsupportedProviderError.cjs');
+var eventListenerHandlers = require('./utils/eventListenerHandlers.cjs');
+
+var _a;
+class LegacyEthProviderHelper {
+    static installedProviderLookup(providerFlags) {
+        const allInstalledProviders = this.allInstalledProviders();
+        return walletConnectorCore.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)[walletConnectorCore.normalizeWalletName(walletName)]) === null || _c === void 0 ? void 0 : _c.call(_b);
+        }
+        catch (err) {
+            if (isUnsupportedProviderError.isUnsupportedProviderError(err)) {
+                walletConnectorCore.logger.error(`ETH Provider is not supported ${err.value}`, err);
+                return;
+            }
+            walletConnectorCore.logger.error(`Could not find provider for ${walletName}`, err);
+            return undefined;
+        }
+    }
+    static findWalletClient(walletName) {
+        const provider = this.findProvider(walletName);
+        if (!provider) {
+            return undefined;
+        }
+        return viem.createWalletClient({
+            transport: viem.custom(provider),
+        });
+    }
+    static fetchPublicAddressWithName(name) {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const [lowercaseAddress] = yield client.requestAddresses();
+                const publicAddress = viem.getAddress(lowercaseAddress);
+                return publicAddress;
+            }
+            catch (err) {
+                walletConnectorCore.logger.error(err);
+                return Promise.reject(err);
+            }
+        });
+    }
+    static signMessageWithName(messageToSign, name) {
+        return _tslib.__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.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,
+};
+
+exports.LegacyEthProviderHelper = LegacyEthProviderHelper;

package/src/legacyEthProviderHelper.d.ts

@@ -0,0 +1,34 @@
+import { Hex, PublicClient, WalletClient } from 'viem';
+import { ProviderCondition, WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { IEthereum, ProviderFlag } from './types';
+export declare class LegacyEthProviderHelper {
+    static BraveProvider: () => IEthereum | undefined;
+    static DawnProvider: () => IEthereum | undefined;
+    static FrameProvider: () => IEthereum | undefined;
+    static CoinbaseProvider: () => IEthereum | undefined;
+    static OperaProvider: () => IEthereum | undefined;
+    static GameStopProvider: () => IEthereum | undefined;
+    static ExodusProvider: () => IEthereum | undefined;
+    static BloctoProvider: () => IEthereum | undefined;
+    static TrustWalletProvider: () => IEthereum | undefined;
+    static PhantomProvider: () => IEthereum | undefined;
+    static ZerionProvider: () => IEthereum | undefined;
+    static SuperbProvider: () => IEthereum | undefined;
+    static RabbyProvider: () => IEthereum | undefined;
+    static OKXProvider: () => IEthereum | undefined;
+    static UnknownInjectedProvider: () => IEthereum | undefined;
+    static providers: {
+        [wallet: string]: () => IEthereum | undefined;
+    };
+    static installedProviderLookup(providerFlags: Array<ProviderCondition<ProviderFlag>>): IEthereum | undefined;
+    static allInstalledProviders(): IEthereum[];
+    static isInstalledHelper(walletName: string): boolean;
+    static findProvider(walletName: string): IEthereum | undefined;
+    static findWalletClient(walletName: string): WalletClient | undefined;
+    static fetchPublicAddressWithName(name: string): Promise<Hex | undefined>;
+    static fetchPublicAddressWithProvider(client: WalletClient): Promise<Hex | undefined>;
+    static signMessageWithName(messageToSign: string, name: string): Promise<Hex | undefined>;
+    static _setupEventListeners(walletName: string, walletConnector: WalletConnector, publicClient: PublicClient): {
+        tearDownEventListeners: () => void;
+    };
+}