@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

package/dist/lib.cjs/Gas/gasUtil.js

@@ -0,0 +1,148 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var httpHelpers = require('@toruslabs/http-helpers');
+var BigNumber = require('bignumber.js');
+var constants = require('../utils/constants.js');
+var conversionUtils = require('../utils/conversionUtils.js');
+
+function normalizeGWEIDecimalNumbers(n) {
+  const numberAsWEIHex = conversionUtils.decGWEIToHexWEI(new BigNumber(n));
+  const numberAsGWEI = conversionUtils.hexWEIToDecGWEI(numberAsWEIHex);
+  return numberAsGWEI;
+}
+async function fetchGasEstimates(url) {
+  const estimates = await httpHelpers.get(url);
+  const normalizedEstimates = {
+    estimatedBaseFee: normalizeGWEIDecimalNumbers(estimates.estimatedBaseFee).toString(10),
+    low: _objectSpread(_objectSpread({}, estimates.low), {}, {
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.low.suggestedMaxPriorityFeePerGas).toString(10),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.low.suggestedMaxFeePerGas).toString(10)
+    }),
+    medium: _objectSpread(_objectSpread({}, estimates.medium), {}, {
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.medium.suggestedMaxPriorityFeePerGas).toString(10),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.medium.suggestedMaxFeePerGas).toString(10)
+    }),
+    high: _objectSpread(_objectSpread({}, estimates.high), {}, {
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.high.suggestedMaxPriorityFeePerGas).toString(10),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.high.suggestedMaxFeePerGas).toString(10)
+    })
+  };
+  return normalizedEstimates;
+}
+async function fetchGasEstimatesViaEthFeeHistory(provider) {
+  const noOfBlocks = 10;
+  const newestBlock = "latest";
+  // get the 10, 50 and 95th percentile of the tip fees from the last 10 blocks
+  const percentileValues = [10, 50, 95];
+  const feeHistory = await provider.request({
+    method: "eth_feeHistory",
+    params: [noOfBlocks, newestBlock, percentileValues]
+  });
+  // this is in hex wei
+  const finalBaseFeePerGas = feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1];
+  // this is in hex wei
+  const priorityFeeCalcs = feeHistory.reward.reduce((acc, curr) => {
+    return {
+      slow: acc.slow.plus(new BigNumber(curr[0], 16)),
+      average: acc.average.plus(new BigNumber(curr[1], 16)),
+      fast: acc.fast.plus(new BigNumber(curr[2], 16))
+    };
+  }, {
+    slow: new BigNumber(0),
+    average: new BigNumber(0),
+    fast: new BigNumber(0)
+  });
+  return {
+    estimatedBaseFee: conversionUtils.hexWEIToDecGWEI(finalBaseFeePerGas).toString(10),
+    high: {
+      maxWaitTimeEstimate: 30000,
+      minWaitTimeEstimate: 15000,
+      suggestedMaxFeePerGas: conversionUtils.hexWEIToDecGWEI(priorityFeeCalcs.fast.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: conversionUtils.hexWEIToDecGWEI(priorityFeeCalcs.fast.toString(16)).toString()
+    },
+    medium: {
+      maxWaitTimeEstimate: 45000,
+      minWaitTimeEstimate: 15000,
+      suggestedMaxFeePerGas: conversionUtils.hexWEIToDecGWEI(priorityFeeCalcs.average.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: conversionUtils.hexWEIToDecGWEI(priorityFeeCalcs.average.toString(16)).toString()
+    },
+    low: {
+      maxWaitTimeEstimate: 60000,
+      minWaitTimeEstimate: 15000,
+      suggestedMaxFeePerGas: conversionUtils.hexWEIToDecGWEI(priorityFeeCalcs.slow.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: conversionUtils.hexWEIToDecGWEI(priorityFeeCalcs.slow.toString(16)).toString()
+    }
+  };
+}
+
+/**
+ * Hit the legacy MetaSwaps gasPrices estimate api and return the low, medium
+ * high values from that API.
+ */
+async function fetchLegacyGasPriceEstimates(url) {
+  const result = await httpHelpers.get(url, {
+    referrer: url,
+    referrerPolicy: "no-referrer-when-downgrade",
+    method: "GET"
+  });
+  // this returns decimal gwei
+  return {
+    low: result.SafeGasPrice,
+    medium: result.ProposeGasPrice,
+    high: result.FastGasPrice
+  };
+}
+async function fetchEthGasPriceEstimate(provider) {
+  const gasPrice = await provider.request({
+    method: constants.METHOD_TYPES.ETH_GET_GAS_PRICE
+  });
+  return {
+    gasPrice: conversionUtils.hexWEIToDecGWEI(gasPrice).toString()
+  };
+}
+function calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, gasFeeEstimates) {
+  // all are in dec gwei
+  const {
+    low,
+    medium,
+    high,
+    estimatedBaseFee
+  } = gasFeeEstimates;
+  const maxPriorityFeePerGasInWEI = new BigNumber(conversionUtils.decGWEIToHexWEI(new BigNumber(maxPriorityFeePerGas)), 16);
+  const maxFeePerGasInWEI = new BigNumber(conversionUtils.decGWEIToHexWEI(new BigNumber(maxFeePerGas)), 16);
+  const estimatedBaseFeeInWEI = new BigNumber(conversionUtils.decGWEIToHexWEI(new BigNumber(estimatedBaseFee)), 16);
+  const effectiveMaxPriorityFee = BigNumber.min(maxPriorityFeePerGasInWEI, maxFeePerGasInWEI.minus(estimatedBaseFeeInWEI));
+  const lowMaxPriorityFeeInWEI = new BigNumber(conversionUtils.decGWEIToHexWEI(new BigNumber(low.suggestedMaxPriorityFeePerGas)), 16);
+  const mediumMaxPriorityFeeInWEI = new BigNumber(conversionUtils.decGWEIToHexWEI(new BigNumber(medium.suggestedMaxPriorityFeePerGas)), 16);
+  const highMaxPriorityFeeInWEI = new BigNumber(conversionUtils.decGWEIToHexWEI(new BigNumber(high.suggestedMaxPriorityFeePerGas)), 16);
+  let lowerTimeBound;
+  let upperTimeBound;
+  if (effectiveMaxPriorityFee.lt(lowMaxPriorityFeeInWEI)) {
+    lowerTimeBound = null;
+    upperTimeBound = "unknown";
+  } else if (effectiveMaxPriorityFee.gte(lowMaxPriorityFeeInWEI) && effectiveMaxPriorityFee.lt(mediumMaxPriorityFeeInWEI)) {
+    lowerTimeBound = low.minWaitTimeEstimate;
+    upperTimeBound = low.maxWaitTimeEstimate;
+  } else if (effectiveMaxPriorityFee.gte(mediumMaxPriorityFeeInWEI) && effectiveMaxPriorityFee.lt(highMaxPriorityFeeInWEI)) {
+    lowerTimeBound = medium.minWaitTimeEstimate;
+    upperTimeBound = medium.maxWaitTimeEstimate;
+  } else if (effectiveMaxPriorityFee.eq(highMaxPriorityFeeInWEI)) {
+    lowerTimeBound = high.minWaitTimeEstimate;
+    upperTimeBound = high.maxWaitTimeEstimate;
+  } else {
+    lowerTimeBound = 0;
+    upperTimeBound = high.maxWaitTimeEstimate;
+  }
+  return {
+    lowerTimeBound,
+    upperTimeBound
+  };
+}
+
+exports.calculateTimeEstimate = calculateTimeEstimate;
+exports.fetchEthGasPriceEstimate = fetchEthGasPriceEstimate;
+exports.fetchGasEstimates = fetchGasEstimates;
+exports.fetchGasEstimatesViaEthFeeHistory = fetchGasEstimatesViaEthFeeHistory;
+exports.fetchLegacyGasPriceEstimates = fetchLegacyGasPriceEstimates;
+exports.normalizeGWEIDecimalNumbers = normalizeGWEIDecimalNumbers;

package/dist/lib.cjs/Keyring/KeyringController.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var util = require('@ethereumjs/util');
+var baseControllers = require('@toruslabs/base-controllers');
+var ethers = require('ethers');
+
+class KeyringController extends baseControllers.BaseKeyringController {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    this.defaultState = {
+      wallets: []
+    };
+    this.initialize();
+  }
+  async signTransaction(tx, address) {
+    const txPayload = tx;
+    const wallet = this._getWalletForAccount(address);
+    const privKey = this.getBufferPrivateKey(wallet.privateKey);
+    const signedTx = txPayload.sign(privKey);
+    // Newer versions of Ethereumjs-tx are immutable and return a new tx object
+    return signedTx === undefined ? tx : signedTx;
+  }
+  getAccounts() {
+    return this.state.wallets.map(w => w.publicKey);
+  }
+  importAccount(accountPrivateKey) {
+    const hexPrivateKey = accountPrivateKey.padStart(64, "0");
+    const bufferPrivKey = Buffer.from(hexPrivateKey, "hex");
+    const publicKey = util.bytesToHex(util.privateToPublic(bufferPrivKey));
+    const address = util.toChecksumAddress(util.bytesToHex(util.privateToAddress(bufferPrivKey)));
+    const existingWallet = this.state.wallets.find(w => w.address === address);
+    if (existingWallet) return existingWallet.address;
+    this.update({
+      wallets: [...this.state.wallets, {
+        publicKey,
+        privateKey: accountPrivateKey,
+        address
+      }]
+    });
+    return address;
+  }
+  removeAccount(address) {
+    const newWallets = [...this.state.wallets];
+    const idx = newWallets.findIndex(w => w.address === address);
+    if (idx !== -1) {
+      newWallets.splice(idx, 1);
+      this.update({
+        wallets: newWallets
+      });
+    }
+  }
+  getBufferPrivateKey(privateKey) {
+    const stripped = util.stripHexPrefix(privateKey);
+    return Buffer.from(stripped, "hex");
+  }
+
+  // For eth_sign, we need to sign arbitrary data:
+  async signMessage(data, address) {
+    const wallet = this._getWalletForAccount(address);
+    const privKey = this.getBufferPrivateKey(wallet.privateKey);
+    const messageSig = util.ecsign(Buffer.from(util.stripHexPrefix(data), "hex"), privKey);
+    const sig = baseControllers.concatSig(Buffer.from(util.bigIntToBytes(messageSig.v)), Buffer.from(messageSig.r), Buffer.from(messageSig.s));
+    return sig;
+  }
+  async signPersonalMessage(data, address) {
+    const wallet = this._getWalletForAccount(address);
+    const privKey = new ethers.SigningKey(util.addHexPrefix(wallet.privateKey));
+    const signature = privKey.sign(ethers.hashMessage(data)).serialized;
+    return signature;
+  }
+
+  // personal_signTypedData, signs data along with the schema
+  async signTypedData(typedData, address) {
+    const wallet = this._getWalletForAccount(address);
+    const privKey = new ethers.SigningKey(util.addHexPrefix(wallet.privateKey));
+    const signature = privKey.sign(ethers.TypedDataEncoder.hash(typedData.domain, typedData.types, typedData.message)).serialized;
+    return signature;
+  }
+  _getWalletForAccount(account) {
+    const address = account.toLowerCase();
+    const wallet = this.state.wallets.find(w => w.address.toLowerCase() === address);
+    if (!wallet) throw new Error("Torus Keyring - Unable to find matching address.");
+    return wallet;
+  }
+}
+
+exports.KeyringController = KeyringController;

package/dist/lib.cjs/Message/AbstractMessageController.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var constants = require('../utils/constants.js');
+
+class AbstractMessageController extends baseControllers.BaseController {
+  /**
+   * Controller in charge of managing - storing, adding, removing, updating - Messages.
+   *
+   */
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "messages", void 0);
+    _defineProperty(this, "getNetworkIdentifier", void 0);
+    this.defaultState = {
+      unapprovedMessages: {},
+      unapprovedMessagesCount: 0
+    };
+    this.messages = [];
+    this.defaultConfig = {};
+    this.getNetworkIdentifier = getNetworkIdentifier;
+    super.initialize();
+  }
+  getMessage(messageId) {
+    return this.messages.find(message => message.id === messageId);
+  }
+  getAllMessages() {
+    return this.messages;
+  }
+  setMetadata(messageId, metadata) {
+    const message = this.getMessage(messageId);
+    if (!message) {
+      throw new Error(`${this.name}: Message not found for id: ${messageId}.`);
+    }
+    message.metadata = metadata;
+    this.updateMessage(message);
+  }
+  getUnapprovedMessages() {
+    return this.messages.filter(message => message.status === constants.MessageStatus.UNAPPROVED).reduce((result, message) => {
+      result[message.id] = message;
+      return result;
+    }, {});
+  }
+  async addMessage(message) {
+    this.messages.push(message);
+    this.saveMessageList();
+  }
+  approveMessage(messageId, messageParams) {
+    this.setMessageStatus(messageId, constants.MessageStatus.APPROVED);
+    return this.prepMessageForSigning(messageParams);
+  }
+  setMessageStatus(messageId, status) {
+    const message = this.getMessage(messageId);
+    if (!message) {
+      throw new Error(`${this.name}: Message not found for id: ${messageId}.`);
+    }
+    message.status = status;
+    this.updateMessage(message);
+    this.emit(`${messageId}:${status}`, message);
+    if (status === constants.MessageStatus.REJECTED || status === constants.MessageStatus.SIGNED || status === constants.MessageStatus.FAILED) {
+      this.emit(`${messageId}:finished`, message);
+    }
+  }
+  async waitForFinishStatus(msgParams, messageName) {
+    return new Promise((resolve, reject) => {
+      const handleFinished = msg => {
+        if (msg.status === constants.MessageStatus.REJECTED) {
+          return reject(auth.providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
+        }
+        if (msg.status === constants.MessageStatus.FAILED) {
+          return reject(auth.rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
+        }
+        if (msg.status === constants.MessageStatus.SIGNED) {
+          return resolve(msg.rawSig);
+        }
+        return reject(auth.rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
+      };
+      this.once(`${msgParams.id}:finished`, handleFinished);
+    });
+  }
+  updateMessage(message) {
+    const index = this.messages.findIndex(msg => message.id === msg.id);
+    if (index !== -1) {
+      this.messages[index] = message;
+    }
+    this.saveMessageList();
+  }
+  saveMessageList() {
+    const unapprovedMessages = this.getUnapprovedMessages();
+    const unapprovedMessagesCount = Object.keys(unapprovedMessages).length;
+    this.update({
+      unapprovedMessages,
+      unapprovedMessagesCount
+    });
+  }
+}
+
+exports.AbstractMessageController = AbstractMessageController;

package/dist/lib.cjs/Message/AddChainController.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var log = require('loglevel');
+var constants = require('../utils/constants.js');
+var AbstractMessageController = require('./AbstractMessageController.js');
+var utils = require('./utils.js');
+
+class AddChainController extends AbstractMessageController.AbstractMessageController {
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+    addChain
+  }) {
+    super({
+      config,
+      state,
+      getNetworkIdentifier
+    });
+    _defineProperty(this, "name", "AddChainController");
+    _defineProperty(this, "addChain", void 0);
+    this.addChain = addChain;
+    this.initialize();
+  }
+  async processAddChain(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error("Message not found");
+    }
+    try {
+      await this.approveMessage(messageId, msgObject.messageParams);
+      await this.addChain(msgObject.messageParams);
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig: JSON.stringify(msgObject.messageParams)
+      }));
+      this.setMessageStatus(messageId, constants.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, constants.MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    // set message params origin first to satisfy the eslint rule (origin won't be checked by validateAddChainData)
+    // for "Possible race condition: `messageParams.origin` might be assigned based on an outdated state of `messageParams`"
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    await utils.validateAddChainData(messageParams);
+    const messageId = messageParams.id || baseControllers.randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: constants.MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: constants.METHOD_TYPES.ADD_CHAIN
+    };
+    await this.addMessage(messageData);
+    this.emit(constants.MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+exports.AddChainController = AddChainController;

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

@@ -0,0 +1,77 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var log = require('loglevel');
+var constants = require('../utils/constants.js');
+var AbstractMessageController = require('./AbstractMessageController.js');
+var utils = require('./utils.js');
+
+class MessageController extends AbstractMessageController.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, constants.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, constants.MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    utils.validateSignMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = utils.normalizeMessageData(messageParams.data);
+    const messageId = messageParams.id || baseControllers.randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: constants.MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: constants.METHOD_TYPES.ETH_SIGN
+    };
+    await this.addMessage(messageData);
+    this.emit(constants.MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+exports.MessageController = MessageController;

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

@@ -0,0 +1,77 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var log = require('loglevel');
+var constants = require('../utils/constants.js');
+var AbstractMessageController = require('./AbstractMessageController.js');
+var utils = require('./utils.js');
+
+class PersonalMessageController extends AbstractMessageController.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, constants.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, constants.MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    utils.validateSignMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = utils.normalizeMessageData(messageParams.data);
+    const messageId = messageParams.id || baseControllers.randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: constants.MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: constants.METHOD_TYPES.PERSONAL_SIGN
+    };
+    await this.addMessage(messageData);
+    this.emit(constants.MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+exports.PersonalMessageController = PersonalMessageController;

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

@@ -0,0 +1,78 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var log = require('loglevel');
+var constants = require('../utils/constants.js');
+var AbstractMessageController = require('./AbstractMessageController.js');
+var utils = require('./utils.js');
+
+class SwitchChainController extends AbstractMessageController.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, constants.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, constants.MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    utils.validateSwitchChainData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    const messageId = messageParams.id || baseControllers.randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: constants.MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: constants.METHOD_TYPES.SWITCH_CHAIN
+    };
+    await this.addMessage(messageData);
+    this.emit(constants.MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+exports.SwitchChainController = SwitchChainController;