@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

package/dist/lib.esm/Message/MessageController.js

@@ -0,0 +1,75 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { randomId } from '@toruslabs/base-controllers';
+import log from 'loglevel';
+import { MessageStatus, METHOD_TYPES, MESSAGE_EVENTS } from '../utils/constants.js';
+import { AbstractMessageController } from './AbstractMessageController.js';
+import { validateSignMessageData, normalizeMessageData } from './utils.js';
+
+class MessageController extends AbstractMessageController {
+  constructor({
+    config,
+    state,
+    signMessage,
+    getNetworkIdentifier
+  }) {
+    super({
+      config,
+      state,
+      getNetworkIdentifier
+    });
+    _defineProperty(this, "name", "MessageController");
+    _defineProperty(this, "signMessage", void 0);
+    this.signMessage = signMessage;
+    this.initialize();
+  }
+  async processSignMessage(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
+    try {
+      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
+      const rawSig = await this.signMessage(cleanMsgParams.data, cleanMsgParams.from);
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig
+      }));
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    validateSignMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = normalizeMessageData(messageParams.data);
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.ETH_SIGN
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+export { MessageController };

package/dist/lib.esm/Message/PersonalMessageController.js

@@ -0,0 +1,75 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { randomId } from '@toruslabs/base-controllers';
+import log from 'loglevel';
+import { MessageStatus, METHOD_TYPES, MESSAGE_EVENTS } from '../utils/constants.js';
+import { AbstractMessageController } from './AbstractMessageController.js';
+import { validateSignMessageData, normalizeMessageData } from './utils.js';
+
+class PersonalMessageController extends AbstractMessageController {
+  constructor({
+    config,
+    state,
+    signPersonalMessage,
+    getNetworkIdentifier
+  }) {
+    super({
+      config,
+      state,
+      getNetworkIdentifier
+    });
+    _defineProperty(this, "name", "PersonalMessageController");
+    _defineProperty(this, "signPersonalMessage", void 0);
+    this.signPersonalMessage = signPersonalMessage;
+    this.initialize();
+  }
+  async processSignPersonalMessage(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
+    try {
+      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
+      const rawSig = await this.signPersonalMessage(cleanMsgParams.data, cleanMsgParams.from);
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig
+      }));
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    validateSignMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = normalizeMessageData(messageParams.data);
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.PERSONAL_SIGN
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+export { PersonalMessageController };

package/dist/lib.esm/Message/SwitchChainController.js

@@ -0,0 +1,76 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { randomId } from '@toruslabs/base-controllers';
+import log from 'loglevel';
+import { MessageStatus, METHOD_TYPES, MESSAGE_EVENTS } from '../utils/constants.js';
+import { AbstractMessageController } from './AbstractMessageController.js';
+import { validateSwitchChainData } from './utils.js';
+
+class SwitchChainController extends AbstractMessageController {
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+    switchChain
+  }) {
+    super({
+      config,
+      state,
+      getNetworkIdentifier
+    });
+    _defineProperty(this, "name", "SwitchChainController");
+    _defineProperty(this, "switchChain", void 0);
+    this.switchChain = switchChain;
+    this.initialize();
+  }
+  async processSwitchChain(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
+    try {
+      await this.approveMessage(messageId, msgObject.messageParams);
+      this.switchChain({
+        chainId: msgObject.messageParams.chainId
+      });
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig: JSON.stringify(msgObject.messageParams)
+      }));
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return null;
+    } catch (error) {
+      log.error(error);
+      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    validateSwitchChainData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.SWITCH_CHAIN
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+export { SwitchChainController };

package/dist/lib.esm/Message/TypedMessageController.js

@@ -0,0 +1,79 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { randomId } from '@toruslabs/base-controllers';
+import log from 'loglevel';
+import { MessageStatus, METHOD_TYPES, MESSAGE_EVENTS } from '../utils/constants.js';
+import { AbstractMessageController } from './AbstractMessageController.js';
+import { validateTypedSignMessageDataV4 } from './utils.js';
+
+class TypedMessageController extends AbstractMessageController {
+  constructor({
+    config,
+    state,
+    signTypedData,
+    getNetworkIdentifier
+  }) {
+    super({
+      config,
+      state,
+      getNetworkIdentifier
+    });
+    _defineProperty(this, "name", "TypedMessageController");
+    _defineProperty(this, "signTypedData", void 0);
+    this.signTypedData = signTypedData;
+    this.initialize();
+  }
+  async processSignTypedMessage(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
+    try {
+      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
+      const msgData = JSON.parse(cleanMsgParams.data);
+      const rawSig = await this.signTypedData(msgData, cleanMsgParams.from);
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig
+      }));
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    const currentChainId = this.getNetworkIdentifier();
+    await validateTypedSignMessageDataV4(messageParams, currentChainId);
+    if (typeof messageParams.data !== "string") {
+      messageParams.data = JSON.stringify(messageParams.data);
+    }
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+export { TypedMessageController };

package/dist/lib.esm/Message/utils.js

@@ -0,0 +1,105 @@
+import { isValidAddress, stripHexPrefix, addHexPrefix, bytesToHex } from '@ethereumjs/util';
+import { isHexString, JsonRpcProvider, toQuantity } from 'ethers';
+
+const hexRe = /^[0-9A-Fa-f]+$/gu;
+function validateAddress(address, propertyName) {
+  if (!address || typeof address !== "string" || !isValidAddress(address)) {
+    throw new Error(`Invalid "${propertyName}" address: ${address} must be a valid string.`);
+  }
+}
+function validateSignMessageData(messageData) {
+  const {
+    from,
+    data
+  } = messageData;
+  validateAddress(from, "from");
+  if (!data || typeof data !== "string") {
+    throw new Error(`Invalid message "data": ${data} must be a valid string.`);
+  }
+}
+function normalizeMessageData(data) {
+  try {
+    const stripped = stripHexPrefix(data);
+    if (stripped.match(hexRe)) {
+      return addHexPrefix(stripped);
+    }
+  } catch (e) {}
+  return bytesToHex(Buffer.from(data, "utf8"));
+}
+async function validateTypedSignMessageDataV4(messageData, currentChainId) {
+  validateAddress(messageData.from, "from");
+  if (!messageData.data || Array.isArray(messageData.data) || typeof messageData.data !== "object" && typeof messageData.data !== "string") {
+    throw new Error(`Invalid message "data": Must be a valid string or object.`);
+  }
+  let data;
+  if (typeof messageData.data === "object") {
+    data = messageData.data;
+  } else {
+    try {
+      data = JSON.parse(messageData.data);
+    } catch (e) {
+      throw new Error("Data must be passed as a valid JSON string.");
+    }
+  }
+  if (!currentChainId) {
+    throw new Error("Current chainId cannot be null or undefined.");
+  }
+  let {
+    chainId
+  } = data.domain;
+  if (chainId) {
+    if (typeof chainId === "string") {
+      chainId = parseInt(chainId, chainId.startsWith("0x") ? 16 : 10);
+    }
+    const activeChainId = parseInt(currentChainId, 16);
+    if (Number.isNaN(activeChainId)) {
+      throw new Error(`Cannot sign messages for chainId "${chainId}", because MetaMask is switching networks.`);
+    }
+    if (chainId !== activeChainId) {
+      throw new Error(`Provided chainId "${chainId}" must match the active chainId "${activeChainId}"`);
+    }
+  }
+}
+async function validateAddChainData(data) {
+  const {
+    chainId,
+    rpcUrls,
+    nativeCurrency
+  } = data || {};
+  if (!chainId) {
+    throw new Error("Invalid add chain params: please pass chainId in params");
+  }
+  if (!isHexString(chainId)) {
+    throw new Error("Invalid add chain params: please pass a valid hex chainId in params, for: ex: 0x1");
+  }
+  if (!rpcUrls || rpcUrls.length === 0) throw new Error("params.rpcUrls not provided");
+  if (!nativeCurrency) throw new Error("params.nativeCurrency not provided");
+  const {
+    name,
+    symbol,
+    decimals
+  } = nativeCurrency;
+  if (!name) throw new Error("params.nativeCurrency.name not provided");
+  if (!symbol) throw new Error("params.nativeCurrency.symbol not provided");
+  if (decimals === undefined) throw new Error("params.nativeCurrency.decimals not provided");
+  const _web3 = new JsonRpcProvider(rpcUrls[0], "any");
+  const {
+    chainId: networkChainID
+  } = await _web3.getNetwork();
+  if (Number.parseInt(networkChainID.toString()) !== Number.parseInt(chainId, 16)) {
+    throw new Error(`Provided rpc url's chainId version is not matching with provided chainId, expected: ${toQuantity(networkChainID)}, received: ${chainId}`);
+  }
+}
+function validateSwitchChainData(data) {
+  const {
+    chainId
+  } = data || {};
+  if (!chainId) {
+    throw new Error("Invalid switch chain params: please pass chainId in params");
+  }
+  if (!isHexString(chainId)) {
+    throw new Error("Invalid switch chain params: please pass a valid hex chainId in params, for: ex: 0x1");
+  }
+}
+
+export { normalizeMessageData, validateAddChainData, validateAddress, validateSignMessageData, validateSwitchChainData, validateTypedSignMessageDataV4 };

package/dist/lib.esm/Network/NetworkController.js

@@ -0,0 +1,199 @@
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { BaseController, createSwappableProxy, createEventEmitterProxy } from '@toruslabs/base-controllers';
+import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { Mutex } from 'async-mutex';
+import log from 'loglevel';
+import { SUPPORTED_NETWORKS, MAINNET_CHAIN_ID } from '../utils/constants.js';
+import { createEthereumMiddleware } from './createEthereumMiddleware.js';
+import { createJsonRpcClient } from './createJsonRpcClient.js';
+
+const _excluded = ["chainId", "rpcTarget"];
+class NetworkController extends BaseController {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "name", "NetworkController");
+    _defineProperty(this, "providerProxy", void 0);
+    _defineProperty(this, "blockTrackerProxy", void 0);
+    _defineProperty(this, "mutex", new Mutex());
+    _defineProperty(this, "provider", null);
+    _defineProperty(this, "blockTracker", null);
+    _defineProperty(this, "baseProviderHandlers", void 0);
+    this.defaultState = {
+      chainId: "loading",
+      properties: {
+        EIPS_1559: undefined
+      },
+      providerConfig: SUPPORTED_NETWORKS[MAINNET_CHAIN_ID]
+    };
+
+    // when a new network is set,
+    // we set to loading first and
+    // then when connection succeeds,
+    // we update the network
+    this.initialize();
+  }
+  getNetworkIdentifier() {
+    return this.state.chainId;
+  }
+  getNetworkRPCUrl() {
+    return this.state.providerConfig.rpcTarget;
+  }
+
+  /**
+   * Called by orchestrator once while initializing the class
+   * @param providerHandlers - JRPC handlers for provider
+   * @returns - provider - Returns the providerProxy
+   */
+  initializeProvider(providerHandlers) {
+    this.baseProviderHandlers = providerHandlers;
+    this.configureProvider();
+    this.lookupNetwork(); // Not awaiting this, because we don't want to block the initialization
+    return this.providerProxy;
+  }
+  getProvider() {
+    return this.providerProxy;
+  }
+  getBlockTracker() {
+    return this.blockTrackerProxy;
+  }
+  getProviderConfig() {
+    return this.state.providerConfig;
+  }
+  setProviderConfig(config) {
+    this.update({
+      providerConfig: _objectSpread({}, config)
+    });
+    this.refreshNetwork();
+  }
+  async getEIP1559Compatibility() {
+    const {
+      EIPS_1559
+    } = this.state.properties;
+    // log.info('checking eip 1559 compatibility')
+    if (EIPS_1559 !== undefined) {
+      return EIPS_1559;
+    }
+    const latestBlock = await this.blockTracker.getLatestBlock();
+    const supportsEIP1559 = latestBlock && latestBlock.baseFeePerGas !== undefined;
+    this.update({
+      properties: {
+        EIPS_1559: supportsEIP1559
+      }
+    });
+    return supportsEIP1559;
+  }
+
+  /**
+   * Refreshes the current network code
+   */
+  async lookupNetwork() {
+    const {
+      chainId,
+      rpcTarget
+    } = this.getProviderConfig();
+    if (!chainId || !rpcTarget || !this.provider) {
+      this.update({
+        chainId: "loading",
+        properties: {}
+      });
+      return;
+    }
+    const releaseLock = await this.mutex.acquire();
+    try {
+      // use eth_chainId
+      const [networkChainId] = await Promise.all([this.provider.request({
+        method: "eth_chainId"
+      }), this.getEIP1559Compatibility()]);
+      log.info("network fetched chain id", networkChainId);
+      // update chain ID
+      this.update({
+        chainId: networkChainId
+      });
+      this.emit("networkDidChange");
+    } catch {
+      this.update({
+        chainId: "loading"
+      });
+    } finally {
+      releaseLock();
+    }
+  }
+  configureProvider() {
+    const _this$getProviderConf = this.getProviderConfig(),
+      {
+        chainId,
+        rpcTarget
+      } = _this$getProviderConf,
+      rest = _objectWithoutProperties(_this$getProviderConf, _excluded);
+    if (!chainId || !rpcTarget) {
+      throw new Error("chainId and rpcTarget must be provider in providerConfig");
+    }
+    this.configureStandardProvider(_objectSpread({
+      chainId,
+      rpcTarget
+    }, rest));
+  }
+  setNetworkClient({
+    networkMiddleware,
+    blockTracker
+  }) {
+    const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers);
+    const engine = new JRPCEngine();
+    engine.push(ethereumMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.setProvider({
+      provider,
+      blockTracker
+    });
+  }
+  setProvider({
+    provider,
+    blockTracker
+  }) {
+    if (this.providerProxy) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.providerProxy.setTarget(provider);
+    } else {
+      this.providerProxy = createSwappableProxy(provider);
+    }
+    if (this.blockTrackerProxy) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.blockTrackerProxy.setTarget(blockTracker);
+    } else {
+      this.blockTrackerProxy = createEventEmitterProxy(blockTracker, {
+        eventFilter: "skipInternal"
+      });
+    }
+
+    // set new provider and blockTracker
+    this.provider = provider;
+    provider.setMaxListeners(10);
+    this.blockTracker = blockTracker;
+  }
+  configureStandardProvider(providerConfig) {
+    const networkClient = createJsonRpcClient(providerConfig, this.config);
+    log.info("networkClient", networkClient);
+    this.setNetworkClient(networkClient);
+  }
+  refreshNetwork() {
+    this.update({
+      chainId: "loading",
+      properties: {}
+    });
+    this.configureProvider();
+    this.lookupNetwork();
+  }
+}
+
+export { NetworkController };