@dynamic-labs/ethereum 4.0.0-alpha.9 → 4.0.0

package/src/utils/createInjectedConnector/createInjectedConnector.js

@@ -0,0 +1,89 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import '@dynamic-labs/utils';
+import { InjectedWalletBase } from '../../injected/InjectedWalletBase.js';
+import '@dynamic-labs/wallet-connector-core';
+import '../logger.js';
+
+const createInjectedConnector = (customConnectorFn) => (props) => {
+    const delegate = customConnectorFn(props);
+    return [
+        class extends InjectedWalletBase {
+            constructor(props) {
+                super(Object.assign(Object.assign({}, props), { metadata: delegate.metadata }));
+                this.name = delegate.metadata.name;
+            }
+            init() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return delegate.init();
+                });
+            }
+            findProvider() {
+                return delegate.findProvider();
+            }
+            signMessage(messageToSign) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return delegate.signMessage(messageToSign);
+                });
+            }
+            connect() {
+                const _super = Object.create(null, {
+                    connect: { get: () => super.connect }
+                });
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (delegate.connect) {
+                        return delegate.connect();
+                    }
+                    return _super.connect.call(this);
+                });
+            }
+            endSession() {
+                const _super = Object.create(null, {
+                    endSession: { get: () => super.endSession }
+                });
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (delegate.disconnect) {
+                        yield delegate.disconnect();
+                    }
+                    return _super.endSession.call(this);
+                });
+            }
+            getAddress() {
+                const _super = Object.create(null, {
+                    getAddress: { get: () => super.getAddress }
+                });
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (delegate.getAddress) {
+                        return delegate.getAddress();
+                    }
+                    return _super.getAddress.call(this);
+                });
+            }
+            getConnectedAccounts() {
+                const _super = Object.create(null, {
+                    getConnectedAccounts: { get: () => super.getConnectedAccounts }
+                });
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (delegate.getConnectedAccounts) {
+                        return delegate.getConnectedAccounts();
+                    }
+                    return _super.getConnectedAccounts.call(this);
+                });
+            }
+            filter() {
+                if (delegate.filter) {
+                    return delegate.filter();
+                }
+                return super.filter();
+            }
+            supportsNetworkSwitching() {
+                if (delegate.supportsNetworkSwitching) {
+                    return delegate.supportsNetworkSwitching();
+                }
+                return super.supportsNetworkSwitching();
+            }
+        },
+    ];
+};
+
+export { createInjectedConnector };

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

@@ -0,0 +1 @@
+export * from './createInjectedConnector';

package/src/utils/getConnectorConstructorForEip6963Wallet/getConnectorConstructorForEip6963Wallet.cjs

@@ -0,0 +1,30 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+var InjectedWalletBase = require('../../injected/InjectedWalletBase.cjs');
+
+const getConnectorConstructorForEip6963Wallet = (walletDetail) => {
+    const { info, provider } = walletDetail;
+    const sanitizedName = utils.sanitizeName(info.name);
+    return class extends InjectedWalletBase.InjectedWalletBase {
+        constructor(props) {
+            super(Object.assign(Object.assign({}, props), { metadata: {
+                    groupKey: sanitizedName,
+                    icon: info.icon,
+                    id: info.uuid,
+                    name: info.name,
+                    rdns: info.rdns,
+                } }));
+            this.name = info.name;
+            this.overrideKey = `${sanitizedName}evm`;
+        }
+        findProvider() {
+            return provider;
+        }
+    };
+};
+
+exports.getConnectorConstructorForEip6963Wallet = getConnectorConstructorForEip6963Wallet;

package/src/utils/getConnectorConstructorForEip6963Wallet/getConnectorConstructorForEip6963Wallet.d.ts

@@ -0,0 +1,3 @@
+import { Eip6963ProviderDetail } from '@dynamic-labs/utils';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export declare const getConnectorConstructorForEip6963Wallet: (walletDetail: Eip6963ProviderDetail) => WalletConnectorConstructor;

package/src/utils/getConnectorConstructorForEip6963Wallet/getConnectorConstructorForEip6963Wallet.js

@@ -0,0 +1,26 @@
+'use client'
+import { sanitizeName } from '@dynamic-labs/utils';
+import { InjectedWalletBase } from '../../injected/InjectedWalletBase.js';
+
+const getConnectorConstructorForEip6963Wallet = (walletDetail) => {
+    const { info, provider } = walletDetail;
+    const sanitizedName = sanitizeName(info.name);
+    return class extends InjectedWalletBase {
+        constructor(props) {
+            super(Object.assign(Object.assign({}, props), { metadata: {
+                    groupKey: sanitizedName,
+                    icon: info.icon,
+                    id: info.uuid,
+                    name: info.name,
+                    rdns: info.rdns,
+                } }));
+            this.name = info.name;
+            this.overrideKey = `${sanitizedName}evm`;
+        }
+        findProvider() {
+            return provider;
+        }
+    };
+};
+
+export { getConnectorConstructorForEip6963Wallet };

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

@@ -0,0 +1 @@
+export { getConnectorConstructorForEip6963Wallet } from './getConnectorConstructorForEip6963Wallet';

package/src/utils/getConnectorConstructorInjectedWallet/getConnectorConstructorInjectedWallet.cjs

@@ -0,0 +1,44 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var InjectedWalletBase = require('../../injected/InjectedWalletBase.cjs');
+var logger = require('../logger.cjs');
+
+const getConnectorConstructorInjectedWallet = (key, wallet) => {
+    const { shortName } = wallet;
+    const name = shortName || wallet.name;
+    const walletConnectorFallback = Boolean(wallet.walletConnect);
+    return class extends InjectedWalletBase.InjectedWalletBase {
+        constructor() {
+            super(...arguments);
+            this.name = name;
+            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;
+        }
+        getAddress() {
+            const _super = Object.create(null, {
+                getAddress: { get: () => super.getAddress }
+            });
+            return _tslib.__awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (this.isInstalledOnBrowser()) {
+                    return _super.getAddress.call(this);
+                }
+                const inAppBrowserBase = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.inAppBrowserUrl;
+                if (!inAppBrowserBase) {
+                    const error = new Error(`No inAppBrowserBase found for ${this.name}.`);
+                    logger.logger.error(error.message);
+                    throw error;
+                }
+                window.location.href = `${inAppBrowserBase}/${window.location.href}`;
+                return undefined;
+            });
+        }
+    };
+};
+
+exports.getConnectorConstructorInjectedWallet = getConnectorConstructorInjectedWallet;

package/src/utils/getConnectorConstructorInjectedWallet/getConnectorConstructorInjectedWallet.d.ts

@@ -0,0 +1,3 @@
+import { WalletSchema } from '@dynamic-labs/wallet-book';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+export declare const getConnectorConstructorInjectedWallet: (key: string, wallet: WalletSchema) => WalletConnectorConstructor;

package/src/utils/getConnectorConstructorInjectedWallet/getConnectorConstructorInjectedWallet.js

@@ -0,0 +1,40 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { InjectedWalletBase } from '../../injected/InjectedWalletBase.js';
+import { logger } from '../logger.js';
+
+const getConnectorConstructorInjectedWallet = (key, wallet) => {
+    const { shortName } = wallet;
+    const name = shortName || wallet.name;
+    const walletConnectorFallback = Boolean(wallet.walletConnect);
+    return class extends InjectedWalletBase {
+        constructor() {
+            super(...arguments);
+            this.name = name;
+            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;
+        }
+        getAddress() {
+            const _super = Object.create(null, {
+                getAddress: { get: () => super.getAddress }
+            });
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (this.isInstalledOnBrowser()) {
+                    return _super.getAddress.call(this);
+                }
+                const inAppBrowserBase = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.inAppBrowserUrl;
+                if (!inAppBrowserBase) {
+                    const error = new Error(`No inAppBrowserBase found for ${this.name}.`);
+                    logger.error(error.message);
+                    throw error;
+                }
+                window.location.href = `${inAppBrowserBase}/${window.location.href}`;
+                return undefined;
+            });
+        }
+    };
+};
+
+export { getConnectorConstructorInjectedWallet };

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

@@ -0,0 +1 @@
+export { getConnectorConstructorInjectedWallet } from './getConnectorConstructorInjectedWallet';

package/src/utils/logger.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('@dynamic-labs/ethereum');
+
+exports.logger = logger;

package/src/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;

package/src/utils/logger.js

@@ -0,0 +1,6 @@
+'use client'
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('@dynamic-labs/ethereum');
+
+export { logger };

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

@@ -0,0 +1 @@
+export { normalizeRpcError } from './normalizeRpcError';

package/src/utils/normalizeRpcError/normalizeRpcError.cjs

@@ -0,0 +1,51 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var viem = require('viem');
+
+/**
+ * Some wallets may not reject some operations following the EIP-1193 standard.
+ * This function normalizes the errors to follow the EIP-1193 standard.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const normalizeRpcError = (err) => {
+    /**
+     * When the error already comply with the EIP-1193 standard, we don't need to normalize it
+     */
+    if (err.code === 4001) {
+        throw err;
+    }
+    let mappedError = null;
+    try {
+        mappedError = mapRpcError(err);
+    }
+    catch (e) {
+        // ignore errors when mapping
+    }
+    if (mappedError) {
+        throw mappedError;
+    }
+    /**
+     * If no error is mapped, we rethrow the original error
+     */
+    throw err;
+};
+const mapRpcError = (err) => {
+    /**
+     * Checks for user rejection error message
+     * Rainbow Extension will return a message like "User rejected the request"
+     * BitGet will return a message like "user reject this request"
+     * Keplr will return a message that matches "Request rejected"
+     */
+    if (typeof err.message === 'string' &&
+        (err.message.includes('User rejected the request') ||
+            err.message.includes('user reject this request') ||
+            err.message === 'Request rejected')) {
+        return new viem.UserRejectedRequestError(err);
+    }
+    return null;
+};
+
+exports.normalizeRpcError = normalizeRpcError;

package/src/utils/normalizeRpcError/normalizeRpcError.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Some wallets may not reject some operations following the EIP-1193 standard.
+ * This function normalizes the errors to follow the EIP-1193 standard.
+ */
+export declare const normalizeRpcError: (err: any) => never;

package/src/utils/normalizeRpcError/normalizeRpcError.js

@@ -0,0 +1,47 @@
+'use client'
+import { UserRejectedRequestError } from 'viem';
+
+/**
+ * Some wallets may not reject some operations following the EIP-1193 standard.
+ * This function normalizes the errors to follow the EIP-1193 standard.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const normalizeRpcError = (err) => {
+    /**
+     * When the error already comply with the EIP-1193 standard, we don't need to normalize it
+     */
+    if (err.code === 4001) {
+        throw err;
+    }
+    let mappedError = null;
+    try {
+        mappedError = mapRpcError(err);
+    }
+    catch (e) {
+        // ignore errors when mapping
+    }
+    if (mappedError) {
+        throw mappedError;
+    }
+    /**
+     * If no error is mapped, we rethrow the original error
+     */
+    throw err;
+};
+const mapRpcError = (err) => {
+    /**
+     * Checks for user rejection error message
+     * Rainbow Extension will return a message like "User rejected the request"
+     * BitGet will return a message like "user reject this request"
+     * Keplr will return a message that matches "Request rejected"
+     */
+    if (typeof err.message === 'string' &&
+        (err.message.includes('User rejected the request') ||
+            err.message.includes('user reject this request') ||
+            err.message === 'Request rejected')) {
+        return new UserRejectedRequestError(err);
+    }
+    return null;
+};
+
+export { normalizeRpcError };