@dynamic-labs/ethereum 0.0.0-exp20240808.0

package/src/EthWalletConnector.js

@@ -0,0 +1,230 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { getAddress, formatEther } from 'viem';
+import { toAccount } from 'viem/accounts';
+import { parseEvmNetworks, retryableFn, FALLBACK_UNDEFINED, DynamicError } from '@dynamic-labs/utils';
+import { chainsMap, getOrMapViemChain, createViemUiTransaction } from '@dynamic-labs/viem-utils';
+import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
+import { findEvmNetwork } from './utils/findEvmNetwork.js';
+import { getNameservice } from './utils/getNameservice.js';
+import { EthereumWallet } from './wallet/EthereumWallet.js';
+
+class EthWalletConnector extends WalletConnectorBase {
+    getPublicClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const networkId = (_a = (yield this.getNetwork())) !== null && _a !== void 0 ? _a : 1;
+            if (this.evmNetworks.length === 0) {
+                return undefined;
+            }
+            const configurations = {
+                cosmos: [],
+                evm: this.evmNetworks,
+                solana: [],
+                starknet: undefined,
+            };
+            if (!this.chainRpcProviders)
+                return undefined;
+            const providers = this.chainRpcProviders.getProviders(configurations);
+            return (_b = this.chainRpcProviders.getEvmProviderByChainId(providers, networkId)) === null || _b === void 0 ? void 0 : _b.provider;
+        });
+    }
+    constructor(props) {
+        var _a;
+        super(props);
+        this.ChainWallet = EthereumWallet;
+        this.evmNetworkRpcMap = () => this.evmNetworks.reduce((acc, network) => {
+            var _a;
+            [acc[network.chainId]] = ((_a = network === null || network === void 0 ? void 0 : network.privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a.length)
+                ? network.privateCustomerRpcUrls
+                : network.rpcUrls;
+            return acc;
+        }, {});
+        this.evmNetworks = parseEvmNetworks(props.evmNetworks);
+        this.chainRpcProviders = props.chainRpcProviders;
+        (_a = this.chainRpcProviders) === null || _a === void 0 ? void 0 : _a.registerEvmProviders();
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getWalletClient();
+            if (!this.supportsNetworkSwitching || !provider) {
+                return Promise.resolve(undefined);
+            }
+            const chainId = yield retryableFn(provider.getChainId, {
+                fallbackValue: FALLBACK_UNDEFINED,
+                /**
+                 * The timeout is set to 1 second because the getChainId method
+                 * takes around 500ms to resolve on Brave. If the timeout is not set
+                 * it will use 100ms by default and the method will fail.
+                 * QNTM-815
+                 */
+                timeoutMs: 1000,
+            });
+            this.setActiveChain(chainsMap[chainId]);
+            return chainId;
+        });
+    }
+    getNameService(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcProvider = yield this.getPublicClient();
+            if (!rpcProvider) {
+                return;
+            }
+            return getNameservice({ address, rpcProvider });
+        });
+    }
+    isTestnet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            return (_c = (_b = (_a = (yield this.getPublicClient())) === null || _a === void 0 ? void 0 : _a.chain) === null || _b === void 0 ? void 0 : _b.testnet) !== null && _c !== void 0 ? _c : false;
+        });
+    }
+    parseAddress(address) {
+        try {
+            // Ensures the address follows the EIP55 format.
+            // see: https://eips.ethereum.org/EIPS/eip-55
+            return getAddress(address);
+        }
+        catch (err) {
+            logger.debug(`Failed to parse EVM address into EIP55 format: error getting checksum, returning default ${address}`, err);
+        }
+        return address;
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getWalletClient();
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.getPublicClient();
+            const result = yield (client === null || client === void 0 ? void 0 : client.getBalance({
+                address: address,
+            }));
+            if (!result && result !== BigInt(0))
+                return;
+            return formatEther(result);
+        });
+    }
+    supportsNetworkSwitching() {
+        return true;
+    }
+    switchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ networkName, networkChainId, }) {
+            const network = findEvmNetwork({
+                chainId: networkChainId,
+                name: networkName,
+                networks: this.evmNetworks,
+            });
+            if (!network) {
+                throw new DynamicError(`Could not find network mapping for chain ${networkName ? networkName : networkChainId}`);
+            }
+            if (!this.supportsNetworkSwitching()) {
+                throw new DynamicError('Network switching is not supported');
+            }
+            const provider = this.getWalletClient();
+            if (!provider) {
+                throw new DynamicError('Provider not found');
+            }
+            return this.providerSwitchNetwork({ network, provider });
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getWalletClient();
+            if (!provider)
+                return [];
+            const addresses = yield retryableFn(provider.getAddresses, {
+                fallbackValue: [],
+                timeoutMs: 500,
+            });
+            if (addresses.length) {
+                this.setActiveAccount(addresses[0]);
+            }
+            return addresses;
+        });
+    }
+    providerSwitchNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ network, provider, }) {
+            var _b, _c, _d, _e;
+            const { chainId } = network;
+            const currentNetworkId = yield this.getNetwork();
+            if (currentNetworkId && currentNetworkId === chainId) {
+                return;
+            }
+            try {
+                if (!this.supportsNetworkSwitching()) {
+                    throw new DynamicError('Network switching is not supported');
+                }
+                const viemChain = getOrMapViemChain(network);
+                yield provider.switchChain(viemChain);
+                if (this.key === 'magiceden') {
+                    const newChainId = yield provider.getChainId();
+                    this.emit('chainChange', { chain: newChainId.toString() });
+                }
+                else {
+                    this.setActiveChain(viemChain);
+                }
+            }
+            catch (error) {
+                // we need to check for unrecognized chain error first because it also contains 'rejected' in message
+                if (error.code === 4902 ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('Unrecognized chain')) ||
+                    // https://github.com/MetaMask/metamask-mobile/issues/3312#issuecomment-1065923294
+                    ((_d = (_c = error.data) === null || _c === void 0 ? void 0 : _c.orginalError) === null || _d === void 0 ? void 0 : _d.code) === 4902) {
+                    // error code indicates the chain has not been added yet
+                    // https://docs.metamask.io/guide/rpc-api.html#usage-with-wallet-switchethereumchain
+                    return this.providerAddNetwork({ network, provider });
+                }
+                else if (((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('rejected')) ||
+                    (typeof error === 'string' && error.includes('rejected'))) {
+                    throw new DynamicError("User rejected the wallet's request to switch network");
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
+    }
+    providerAddNetwork(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ network, provider, }) {
+            var _b;
+            try {
+                return yield provider.addChain({ chain: getOrMapViemChain(network) });
+            }
+            catch (error) {
+                if (((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('rejected')) ||
+                    (typeof error === 'string' && error.includes('rejected'))) {
+                    throw new DynamicError("User rejected the wallet's request to add network");
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
+    }
+    setActiveAccount(account) {
+        this.activeAccount = account ? toAccount(account) : undefined;
+    }
+    getActiveAccount() {
+        return this.activeAccount;
+    }
+    setActiveChain(chain) {
+        this.activeChain = chain;
+    }
+    getActiveChain() {
+        return this.activeChain;
+    }
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletClient = yield this.getWalletClient();
+            const publicClient = yield this.getPublicClient();
+            if (!publicClient || !walletClient) {
+                throw new DynamicError('No public client available');
+            }
+            return createViemUiTransaction({ from, publicClient, walletClient });
+        });
+    }
+}
+
+export { EthWalletConnector };

package/src/coinbase/coinbase.cjs

@@ -0,0 +1,98 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var viem = require('viem');
+var viemUtils = require('@dynamic-labs/viem-utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var EthWalletConnector = require('../EthWalletConnector.cjs');
+var helpers = require('./helpers.cjs');
+
+class Coinbase extends EthWalletConnector.EthWalletConnector {
+    constructor(_a) {
+        var { appName, appLogoUrl, evmNetworks, coinbaseWalletPreference } = _a, props = _tslib.__rest(_a, ["appName", "appLogoUrl", "evmNetworks", "coinbaseWalletPreference"]);
+        super(Object.assign({ evmNetworks }, props));
+        this.name = 'Coinbase';
+        this.overrideKey = 'coinbase';
+        this.supportedChains = ['EVM', 'ETH'];
+        this.connectedChain = 'EVM';
+        this.canConnectViaQrCode = false;
+        this.canConnectViaCustodialService = !this.isInstalledOnBrowser();
+        this.coinbaseProviderOpts = {
+            appLogoUrl: appLogoUrl,
+            appName: appName,
+            evmNetworks: evmNetworks,
+            walletPreference: coinbaseWalletPreference,
+        };
+    }
+    get coinbaseProvider() {
+        return helpers.getCoinbaseProvider(this.coinbaseProviderOpts);
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const accounts = yield this.coinbaseProvider.request({
+                    method: 'eth_accounts',
+                });
+                if (accounts[0]) {
+                    this.setActiveAccount(accounts[0]);
+                }
+                return accounts;
+            }
+            catch (error) {
+                return [];
+            }
+        });
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        return Boolean((_a = window === null || window === void 0 ? void 0 : window.coinbaseWalletExtension) === null || _a === void 0 ? void 0 : _a.isCoinbaseWallet);
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const [address] = yield this.coinbaseProvider.request({
+                method: 'eth_requestAccounts',
+            });
+            this.setActiveAccount(address);
+            return address;
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const [address] = yield this.coinbaseProvider.request({
+                method: 'eth_requestAccounts',
+            });
+            try {
+                return yield this.coinbaseProvider.request({
+                    method: 'personal_sign',
+                    params: [viem.toHex(viem.toBytes(messageToSign)), address.toLowerCase()],
+                });
+            }
+            catch (err) {
+                return undefined;
+            }
+        });
+    }
+    setupEventListeners() {
+        const { handleAccountChange, handleChainChange, handleDisconnect } = walletConnectorCore.eventListenerHandlers(this);
+        this.coinbaseProvider.on('accountsChanged', handleAccountChange);
+        this.coinbaseProvider.on('chainChanged', handleChainChange);
+        this.coinbaseProvider.on('disconnect', handleDisconnect);
+        this.teardownEventListeners = () => {
+            this.coinbaseProvider.removeListener('accountsChanged', handleAccountChange);
+            this.coinbaseProvider.removeListener('chainChanged', handleChainChange);
+            this.coinbaseProvider.removeListener('disconnect', handleDisconnect);
+        };
+    }
+    getWalletClient(chainId) {
+        return viem.createWalletClient({
+            account: this.getActiveAccount(),
+            chain: chainId ? viemUtils.chainsMap[chainId] : undefined,
+            transport: viem.custom(this.coinbaseProvider),
+        });
+    }
+}
+
+exports.Coinbase = Coinbase;

package/src/coinbase/coinbase.d.ts

@@ -0,0 +1,22 @@
+import { WalletClient, Account, Transport, Chain as ViemChain } from 'viem';
+import { ProviderInterface } from '@coinbase/wallet-sdk';
+import { Chain } from '@dynamic-labs/wallet-connector-core';
+import { EthWalletConnector } from '../EthWalletConnector';
+import { CoinbaseOpts, GetCoinbaseProviderOpts } from './types';
+export declare class Coinbase extends EthWalletConnector {
+    name: string;
+    overrideKey: string;
+    supportedChains: Chain[];
+    connectedChain: Chain;
+    canConnectViaQrCode: boolean;
+    coinbaseProviderOpts: GetCoinbaseProviderOpts;
+    constructor({ appName, appLogoUrl, evmNetworks, coinbaseWalletPreference, ...props }: CoinbaseOpts);
+    get coinbaseProvider(): ProviderInterface;
+    getConnectedAccounts(): Promise<string[]>;
+    isInstalledOnBrowser(): boolean;
+    canConnectViaCustodialService: boolean;
+    getAddress(): Promise<string | undefined>;
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    setupEventListeners(): void;
+    getWalletClient(chainId?: string): WalletClient<Transport, ViemChain, Account> | undefined;
+}

package/src/coinbase/coinbase.js

@@ -0,0 +1,94 @@
+'use client'
+import { __rest, __awaiter } from '../../_virtual/_tslib.js';
+import { toHex, toBytes, createWalletClient, custom } from 'viem';
+import { chainsMap } from '@dynamic-labs/viem-utils';
+import { eventListenerHandlers } from '@dynamic-labs/wallet-connector-core';
+import { EthWalletConnector } from '../EthWalletConnector.js';
+import { getCoinbaseProvider } from './helpers.js';
+
+class Coinbase extends EthWalletConnector {
+    constructor(_a) {
+        var { appName, appLogoUrl, evmNetworks, coinbaseWalletPreference } = _a, props = __rest(_a, ["appName", "appLogoUrl", "evmNetworks", "coinbaseWalletPreference"]);
+        super(Object.assign({ evmNetworks }, props));
+        this.name = 'Coinbase';
+        this.overrideKey = 'coinbase';
+        this.supportedChains = ['EVM', 'ETH'];
+        this.connectedChain = 'EVM';
+        this.canConnectViaQrCode = false;
+        this.canConnectViaCustodialService = !this.isInstalledOnBrowser();
+        this.coinbaseProviderOpts = {
+            appLogoUrl: appLogoUrl,
+            appName: appName,
+            evmNetworks: evmNetworks,
+            walletPreference: coinbaseWalletPreference,
+        };
+    }
+    get coinbaseProvider() {
+        return getCoinbaseProvider(this.coinbaseProviderOpts);
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const accounts = yield this.coinbaseProvider.request({
+                    method: 'eth_accounts',
+                });
+                if (accounts[0]) {
+                    this.setActiveAccount(accounts[0]);
+                }
+                return accounts;
+            }
+            catch (error) {
+                return [];
+            }
+        });
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        return Boolean((_a = window === null || window === void 0 ? void 0 : window.coinbaseWalletExtension) === null || _a === void 0 ? void 0 : _a.isCoinbaseWallet);
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [address] = yield this.coinbaseProvider.request({
+                method: 'eth_requestAccounts',
+            });
+            this.setActiveAccount(address);
+            return address;
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [address] = yield this.coinbaseProvider.request({
+                method: 'eth_requestAccounts',
+            });
+            try {
+                return yield this.coinbaseProvider.request({
+                    method: 'personal_sign',
+                    params: [toHex(toBytes(messageToSign)), address.toLowerCase()],
+                });
+            }
+            catch (err) {
+                return undefined;
+            }
+        });
+    }
+    setupEventListeners() {
+        const { handleAccountChange, handleChainChange, handleDisconnect } = eventListenerHandlers(this);
+        this.coinbaseProvider.on('accountsChanged', handleAccountChange);
+        this.coinbaseProvider.on('chainChanged', handleChainChange);
+        this.coinbaseProvider.on('disconnect', handleDisconnect);
+        this.teardownEventListeners = () => {
+            this.coinbaseProvider.removeListener('accountsChanged', handleAccountChange);
+            this.coinbaseProvider.removeListener('chainChanged', handleChainChange);
+            this.coinbaseProvider.removeListener('disconnect', handleDisconnect);
+        };
+    }
+    getWalletClient(chainId) {
+        return createWalletClient({
+            account: this.getActiveAccount(),
+            chain: chainId ? chainsMap[chainId] : undefined,
+            transport: custom(this.coinbaseProvider),
+        });
+    }
+}
+
+export { Coinbase };

package/src/coinbase/helpers.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletSdk = require('@coinbase/wallet-sdk');
+
+// storing a reference to the coinbase provider because the provider methods work better when
+// they are called on the same instance
+let coinbaseProvider;
+const baseSepolia = 84532;
+const baseMainnet = 8453;
+const getCoinbaseProvider = ({ appLogoUrl, appName, evmNetworks, walletPreference, } = {}) => {
+    const appChainIds = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.map((network) => Number(network.chainId));
+    // just brings base sepolia to the front of the list, because that is treated as the default chain
+    const hasBaseSepolia = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.some((network) => network.chainId === baseSepolia);
+    if (hasBaseSepolia) {
+        appChainIds === null || appChainIds === void 0 ? void 0 : appChainIds.sort((a, b) => a === baseSepolia ? -1 : b === baseSepolia ? 1 : 0);
+    }
+    // just brings base mainnet to the front, because that that is treated as the default chain
+    const hasBaseMainnet = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.some((network) => network.chainId === baseMainnet);
+    if (hasBaseMainnet) {
+        appChainIds === null || appChainIds === void 0 ? void 0 : appChainIds.sort((a, b) => a === baseMainnet ? -1 : b === baseMainnet ? 1 : 0);
+    }
+    if (!coinbaseProvider) {
+        const coinbaseSdk = new walletSdk.CoinbaseWalletSDK({
+            appChainIds,
+            appLogoUrl,
+            appName,
+        });
+        coinbaseProvider = coinbaseSdk.makeWeb3Provider({
+            options: walletPreference !== null && walletPreference !== void 0 ? walletPreference : 'all',
+        });
+    }
+    return coinbaseProvider;
+};
+
+exports.getCoinbaseProvider = getCoinbaseProvider;

package/src/coinbase/helpers.d.ts

@@ -0,0 +1,3 @@
+import { type GetCoinbaseProvider } from './types';
+export declare const getCoinbaseProvider: GetCoinbaseProvider;
+export declare const resetCoinbaseProvider: () => void;

package/src/coinbase/helpers.js

@@ -0,0 +1,34 @@
+'use client'
+import { CoinbaseWalletSDK } from '@coinbase/wallet-sdk';
+
+// storing a reference to the coinbase provider because the provider methods work better when
+// they are called on the same instance
+let coinbaseProvider;
+const baseSepolia = 84532;
+const baseMainnet = 8453;
+const getCoinbaseProvider = ({ appLogoUrl, appName, evmNetworks, walletPreference, } = {}) => {
+    const appChainIds = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.map((network) => Number(network.chainId));
+    // just brings base sepolia to the front of the list, because that is treated as the default chain
+    const hasBaseSepolia = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.some((network) => network.chainId === baseSepolia);
+    if (hasBaseSepolia) {
+        appChainIds === null || appChainIds === void 0 ? void 0 : appChainIds.sort((a, b) => a === baseSepolia ? -1 : b === baseSepolia ? 1 : 0);
+    }
+    // just brings base mainnet to the front, because that that is treated as the default chain
+    const hasBaseMainnet = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.some((network) => network.chainId === baseMainnet);
+    if (hasBaseMainnet) {
+        appChainIds === null || appChainIds === void 0 ? void 0 : appChainIds.sort((a, b) => a === baseMainnet ? -1 : b === baseMainnet ? 1 : 0);
+    }
+    if (!coinbaseProvider) {
+        const coinbaseSdk = new CoinbaseWalletSDK({
+            appChainIds,
+            appLogoUrl,
+            appName,
+        });
+        coinbaseProvider = coinbaseSdk.makeWeb3Provider({
+            options: walletPreference !== null && walletPreference !== void 0 ? walletPreference : 'all',
+        });
+    }
+    return coinbaseProvider;
+};
+
+export { getCoinbaseProvider };

package/src/coinbase/index.d.ts

@@ -0,0 +1,3 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export * from './coinbase';
+export declare const CoinbaseWalletConnectors: (props: any) => WalletConnectorConstructor[];

package/src/coinbase/types.d.ts

@@ -0,0 +1,18 @@
+import { type ProviderInterface } from '@coinbase/wallet-sdk';
+import { type CoinbaseWalletPreference, type GenericNetwork } from '@dynamic-labs/types';
+import { type EthWalletConnectorOpts } from '../EthWalletConnector';
+export type GetCoinbaseProviderOpts = {
+    appLogoUrl?: string;
+    appName?: string;
+    evmNetworks?: GenericNetwork[];
+    walletPreference?: CoinbaseWalletPreference;
+};
+export type CoinbaseProviderHandlerOpts = {
+    onDisconnect(): Promise<void>;
+};
+export type GetCoinbaseProvider = (opts?: GetCoinbaseProviderOpts) => ProviderInterface;
+export type CoinbaseOpts = EthWalletConnectorOpts & {
+    appLogoUrl?: string;
+    appName?: string;
+    coinbaseWalletPreference?: CoinbaseWalletPreference;
+};

package/src/constants.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const INFURA_ID = '87939db78f824920ada5c872db3e56b8';
+
+exports.INFURA_ID = INFURA_ID;

package/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const INFURA_ID: "87939db78f824920ada5c872db3e56b8";

package/src/constants.js

@@ -0,0 +1,4 @@
+'use client'
+const INFURA_ID = '87939db78f824920ada5c872db3e56b8';
+
+export { INFURA_ID };