@web3auth/metamask-adapter
Version:
metamask wallet adapter for web3auth
236 lines (228 loc) • 9.64 kB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ "use strict";
/******/ // The require scope
/******/ var __webpack_require__ = {};
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/************************************************************************/
var __webpack_exports__ = {};
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
MetamaskAdapter: () => (/* reexport */ MetamaskAdapter)
});
;// CONCATENATED MODULE: external "@babel/runtime/helpers/defineProperty"
const defineProperty_namespaceObject = require("@babel/runtime/helpers/defineProperty");
var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty_namespaceObject);
;// CONCATENATED MODULE: external "@metamask/detect-provider"
const detect_provider_namespaceObject = require("@metamask/detect-provider");
var detect_provider_default = /*#__PURE__*/__webpack_require__.n(detect_provider_namespaceObject);
;// CONCATENATED MODULE: external "@web3auth/base"
const base_namespaceObject = require("@web3auth/base");
;// CONCATENATED MODULE: external "@web3auth/base-evm-adapter"
const base_evm_adapter_namespaceObject = require("@web3auth/base-evm-adapter");
;// CONCATENATED MODULE: ./src/metamaskAdapter.ts
/* eslint-disable @typescript-eslint/no-explicit-any */
class MetamaskAdapter extends base_evm_adapter_namespaceObject.BaseEvmAdapter {
constructor(...args) {
super(...args);
defineProperty_default()(this, "adapterNamespace", base_namespaceObject.ADAPTER_NAMESPACES.EIP155);
defineProperty_default()(this, "currentChainNamespace", base_namespaceObject.CHAIN_NAMESPACES.EIP155);
defineProperty_default()(this, "type", base_namespaceObject.ADAPTER_CATEGORY.EXTERNAL);
defineProperty_default()(this, "name", base_namespaceObject.WALLET_ADAPTERS.METAMASK);
defineProperty_default()(this, "status", base_namespaceObject.ADAPTER_STATUS.NOT_READY);
defineProperty_default()(this, "metamaskProvider", null);
}
get provider() {
if (this.status !== base_namespaceObject.ADAPTER_STATUS.NOT_READY && this.metamaskProvider) {
return this.metamaskProvider;
}
return null;
}
set provider(_) {
throw new Error("Not implemented");
}
async init(options = {}) {
await super.init(options);
super.checkInitializationRequirements();
this.metamaskProvider = await detect_provider_default()({
mustBeMetaMask: true,
silent: true,
timeout: 1000
});
if (!this.metamaskProvider) throw base_namespaceObject.WalletInitializationError.notInstalled("Metamask extension is not installed");
this.status = base_namespaceObject.ADAPTER_STATUS.READY;
this.emit(base_namespaceObject.ADAPTER_EVENTS.READY, base_namespaceObject.WALLET_ADAPTERS.METAMASK);
try {
base_namespaceObject.log.debug("initializing metamask adapter");
if (options.autoConnect) {
this.rehydrated = true;
await this.connect();
}
} catch (error) {
this.emit(base_namespaceObject.ADAPTER_EVENTS.ERRORED, error);
}
}
async connect() {
super.checkConnectionRequirements();
if (!this.metamaskProvider) throw base_namespaceObject.WalletLoginError.notConnectedError("Not able to connect with metamask");
const {
ethereum
} = window;
const isPhantom = Boolean("isPhantom" in ethereum);
// check which is the active provider
if (ethereum && ethereum.isMetaMask && isPhantom) {
// this means phantom is the active provider.
if (ethereum.providers && ethereum.providers.length > 0) {
const provider = ethereum.providers.find(p => p.isMetaMask && !p.overrideIsMetaMask);
if (provider) {
ethereum.setProvider(provider);
}
}
} else if (ethereum && (ethereum.providers || []).length > 0) {
// this means that there are another providers than metamask (like coinbase).
const provider = ethereum.providers.find(p => p.isMetaMask);
if (provider) {
ethereum.setSelectedProvider(provider);
}
}
this.status = base_namespaceObject.ADAPTER_STATUS.CONNECTING;
this.emit(base_namespaceObject.ADAPTER_EVENTS.CONNECTING, {
adapter: base_namespaceObject.WALLET_ADAPTERS.METAMASK
});
try {
await this.metamaskProvider.request({
method: "eth_requestAccounts"
});
const {
chainId
} = this.metamaskProvider;
if (chainId !== this.chainConfig.chainId) {
await this.addChain(this.chainConfig, true);
await this.switchChain(this.chainConfig, true);
}
this.status = base_namespaceObject.ADAPTER_STATUS.CONNECTED;
if (!this.provider) throw base_namespaceObject.WalletLoginError.notConnectedError("Failed to connect with provider");
const disconnectHandler = () => {
var _this$provider;
// ready to be connected again
this.disconnect();
(_this$provider = this.provider) === null || _this$provider === void 0 || _this$provider.removeListener("disconnect", disconnectHandler);
};
this.provider.on("disconnect", disconnectHandler);
this.emit(base_namespaceObject.ADAPTER_EVENTS.CONNECTED, {
adapter: base_namespaceObject.WALLET_ADAPTERS.METAMASK,
reconnected: this.rehydrated,
provider: this.provider
});
return this.provider;
} catch (error) {
// ready again to be connected
this.status = base_namespaceObject.ADAPTER_STATUS.READY;
this.rehydrated = false;
this.emit(base_namespaceObject.ADAPTER_EVENTS.ERRORED, error);
if (error instanceof base_namespaceObject.Web3AuthError) throw error;
throw base_namespaceObject.WalletLoginError.connectionError("Failed to login with metamask wallet", error);
}
}
async disconnect(options = {
cleanup: false
}) {
var _this$provider2;
await super.disconnectSession();
(_this$provider2 = this.provider) === null || _this$provider2 === void 0 || _this$provider2.removeAllListeners();
if (options.cleanup) {
this.status = base_namespaceObject.ADAPTER_STATUS.NOT_READY;
this.metamaskProvider = null;
} else {
// ready to be connected again
this.status = base_namespaceObject.ADAPTER_STATUS.READY;
}
await super.disconnect();
}
async getUserInfo() {
if (this.status !== base_namespaceObject.ADAPTER_STATUS.CONNECTED) throw base_namespaceObject.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
return {};
}
async addChain(chainConfig, init = false) {
var _this$metamaskProvide;
super.checkAddChainRequirements(chainConfig, init);
await ((_this$metamaskProvide = this.metamaskProvider) === null || _this$metamaskProvide === void 0 ? void 0 : _this$metamaskProvide.request({
method: "wallet_addEthereumChain",
params: [{
chainId: chainConfig.chainId,
chainName: chainConfig.displayName,
rpcUrls: [chainConfig.rpcTarget],
blockExplorerUrls: [chainConfig.blockExplorerUrl],
nativeCurrency: {
name: chainConfig.tickerName,
symbol: chainConfig.ticker,
decimals: chainConfig.decimals || 18
},
iconUrls: [chainConfig.logo]
}]
}));
this.addChainConfig(chainConfig);
}
async switchChain(params, init = false) {
var _this$metamaskProvide2;
super.checkSwitchChainRequirements(params, init);
await ((_this$metamaskProvide2 = this.metamaskProvider) === null || _this$metamaskProvide2 === void 0 ? void 0 : _this$metamaskProvide2.request({
method: "wallet_switchEthereumChain",
params: [{
chainId: params.chainId
}]
}));
this.setAdapterSettings({
chainConfig: this.getChainConfig(params.chainId)
});
}
async enableMFA() {
throw new Error("Method Not implemented");
}
}
;// CONCATENATED MODULE: ./src/index.ts
module.exports = __webpack_exports__;
/******/ })()
;