@toruslabs/ethereum-controllers 5.11.0 → 6.0.0

package/dist/lib.esm/Gas/GasFeeController.js

@@ -0,0 +1,212 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { isHexString, addHexPrefix } from '@ethereumjs/util';
+import { BaseController, cloneDeep } from '@toruslabs/base-controllers';
+import log from 'loglevel';
+import { GAS_ESTIMATE_TYPES } from '../utils/constants.js';
+import { idleTimeTracker } from '../utils/helpers.js';
+import { fetchGasEstimates, fetchEthGasPriceEstimate, fetchLegacyGasPriceEstimates, fetchGasEstimatesViaEthFeeHistory, calculateTimeEstimate } from './gasUtil.js';
+
+const GAS_FEE_API = "https://mock-gas-server.herokuapp.com/";
+const LEGACY_GAS_PRICES_API_URL = "https://api.metaswap.codefi.network/gasPrices";
+/**
+ * Returns gas prices in dec gwei
+ */
+class GasFeeController extends BaseController {
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+    getProvider,
+    fetchGasEstimates: fetchGasEstimates$1 = fetchGasEstimates,
+    fetchEthGasPriceEstimate: fetchEthGasPriceEstimate$1 = fetchEthGasPriceEstimate,
+    fetchLegacyGasPriceEstimates: fetchLegacyGasPriceEstimates$1 = fetchLegacyGasPriceEstimates,
+    fetchGasEstimatesViaEthFeeHistory: fetchGasEstimatesViaEthFeeHistory$1 = fetchGasEstimatesViaEthFeeHistory,
+    getCurrentNetworkLegacyGasAPICompatibility,
+    getCurrentNetworkEIP1559Compatibility,
+    getCurrentAccountEIP1559Compatibility,
+    onNetworkStateChange
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "name", "GasFeeController");
+    // https://0x.org/docs/introduction/0x-cheat-sheet#swap-api-endpoints
+    _defineProperty(this, "API_SUPPORTED_CHAINIDS", new Set(["0x1", "0x5", "0xa4b1", "0xa86a", "0x2105", "0x38", "0xfa", "0xa", "0x89"]));
+    _defineProperty(this, "intervalId", void 0);
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "currentChainId", void 0);
+    _defineProperty(this, "getNetworkIdentifier", void 0);
+    _defineProperty(this, "getProvider", void 0);
+    _defineProperty(this, "fetchGasEstimates", void 0);
+    _defineProperty(this, "fetchGasEstimatesViaEthFeeHistory", void 0);
+    _defineProperty(this, "fetchEthGasPriceEstimate", void 0);
+    _defineProperty(this, "fetchLegacyGasPriceEstimates", void 0);
+    _defineProperty(this, "getCurrentNetworkEIP1559Compatibility", void 0);
+    _defineProperty(this, "getCurrentAccountEIP1559Compatibility", void 0);
+    _defineProperty(this, "getCurrentNetworkLegacyGasAPICompatibility", void 0);
+    this.getNetworkIdentifier = getNetworkIdentifier;
+    this.getProvider = getProvider;
+    this.fetchGasEstimates = fetchGasEstimates$1;
+    this.fetchEthGasPriceEstimate = fetchEthGasPriceEstimate$1;
+    this.fetchLegacyGasPriceEstimates = fetchLegacyGasPriceEstimates$1;
+    this.getCurrentNetworkEIP1559Compatibility = getCurrentNetworkEIP1559Compatibility;
+    this.getCurrentNetworkLegacyGasAPICompatibility = getCurrentNetworkLegacyGasAPICompatibility;
+    this.getCurrentAccountEIP1559Compatibility = getCurrentAccountEIP1559Compatibility;
+    this.fetchGasEstimatesViaEthFeeHistory = fetchGasEstimatesViaEthFeeHistory$1;
+    this.defaultConfig = {
+      interval: 30000,
+      legacyAPIEndpoint: LEGACY_GAS_PRICES_API_URL,
+      EIP1559APIEndpoint: GAS_FEE_API
+    };
+    this.defaultState = {
+      gasFeeEstimates: {},
+      estimatedGasFeeTimeBounds: {},
+      gasEstimateType: GAS_ESTIMATE_TYPES.NONE
+    };
+    // Initialize.
+    this.currentChainId = this.getNetworkIdentifier();
+    this.provider = this.getProvider();
+    this.initialize();
+    onNetworkStateChange(() => {
+      this.onNetworkStateChange();
+    });
+  }
+  async onNetworkStateChange() {
+    this.provider = this.getProvider();
+    const newChainId = this.getNetworkIdentifier();
+    if (this.currentChainId !== newChainId) {
+      this.currentChainId = newChainId;
+      await this.fetchGasFeeEstimates();
+    }
+  }
+  async resetPolling() {
+    this.stopPolling();
+    await this.getGasFeeEstimatesAndStartPolling();
+  }
+  async fetchGasFeeEstimates() {
+    return this._fetchGasFeeEstimateData();
+  }
+  async getGasFeeEstimatesAndStartPolling() {
+    await this._fetchGasFeeEstimateData();
+    this._startPolling();
+  }
+  disconnectPoller() {
+    this.stopPolling();
+  }
+
+  /**
+   * Prepare to discard this controller.
+   *
+   * This stops any active polling.
+   */
+  destroy() {
+    this.stopPolling();
+  }
+  stopPolling() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+    this.resetState();
+  }
+
+  /**
+   * Gets and sets gasFeeEstimates in state
+   *
+   * @returns GasFeeEstimates
+   */
+  async _fetchGasFeeEstimateData() {
+    let isEIP1559Compatible;
+    const isLegacyGasAPICompatible = this.getCurrentNetworkLegacyGasAPICompatibility();
+    const chainId = this.getNetworkIdentifier();
+    if (chainId === "loading") return;
+    let chainIdInt;
+    if (typeof chainId === "string" && isHexString(addHexPrefix(chainId))) {
+      chainIdInt = Number.parseInt(chainId, 16);
+    }
+    try {
+      isEIP1559Compatible = await this.getEIP1559Compatibility();
+      log.info("eip1559 compatible", isEIP1559Compatible);
+    } catch (error) {
+      log.warn(error);
+      isEIP1559Compatible = false;
+    }
+    let newState = cloneDeep(this.defaultState);
+    try {
+      if (isEIP1559Compatible) {
+        let estimates;
+        try {
+          if (this.API_SUPPORTED_CHAINIDS.has(chainId)) {
+            estimates = await this.fetchGasEstimates(this.config.EIP1559APIEndpoint.replace("<chain_id>", `${chainIdInt}`));
+          } else {
+            throw new Error("ChainId not supported by api");
+          }
+        } catch (error) {
+          estimates = await this.fetchGasEstimatesViaEthFeeHistory(this.provider);
+        }
+        const {
+          suggestedMaxPriorityFeePerGas,
+          suggestedMaxFeePerGas
+        } = estimates.medium;
+        const estimatedGasFeeTimeBounds = this.getTimeEstimate(suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas);
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds,
+          gasEstimateType: GAS_ESTIMATE_TYPES.FEE_MARKET
+        };
+      } else if (isLegacyGasAPICompatible) {
+        const estimates = await this.fetchLegacyGasPriceEstimates(this.config.legacyAPIEndpoint.replace("<chain_id>", `${chainIdInt}`));
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds: {},
+          gasEstimateType: GAS_ESTIMATE_TYPES.LEGACY
+        };
+      } else {
+        throw new Error("Main gas fee/price estimation failed. Use fallback");
+      }
+    } catch {
+      try {
+        const estimates = await this.fetchEthGasPriceEstimate(this.provider);
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds: {},
+          gasEstimateType: GAS_ESTIMATE_TYPES.ETH_GASPRICE
+        };
+      } catch (error) {
+        throw new Error(`Gas fee/price estimation failed. Message: ${error.message}`);
+      }
+    }
+    this.update(newState);
+    return newState;
+  }
+  async _startPolling() {
+    this._poll();
+  }
+  async _poll() {
+    if (this.intervalId) {
+      window.clearInterval(this.intervalId);
+    }
+    this.intervalId = window.setInterval(async () => {
+      if (!idleTimeTracker.checkIfIdle()) {
+        await this._fetchGasFeeEstimateData();
+      }
+    }, this.config.interval);
+  }
+  resetState() {
+    this.update(cloneDeep(this.defaultState));
+  }
+  async getEIP1559Compatibility() {
+    var _this$getCurrentAccou, _this$getCurrentAccou2;
+    const currentNetworkIsEIP1559Compatible = await this.getCurrentNetworkEIP1559Compatibility();
+    const currentAccountIsEIP1559Compatible = (_this$getCurrentAccou = (_this$getCurrentAccou2 = this.getCurrentAccountEIP1559Compatibility) === null || _this$getCurrentAccou2 === void 0 ? void 0 : _this$getCurrentAccou2.call(this)) !== null && _this$getCurrentAccou !== void 0 ? _this$getCurrentAccou : true;
+    return currentNetworkIsEIP1559Compatible && currentAccountIsEIP1559Compatible;
+  }
+  getTimeEstimate(maxPriorityFeePerGas, maxFeePerGas) {
+    if (!this.state.gasFeeEstimates || this.state.gasEstimateType !== GAS_ESTIMATE_TYPES.FEE_MARKET) {
+      return {};
+    }
+    return calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, this.state.gasFeeEstimates);
+  }
+}
+
+export { GasFeeController };

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

@@ -0,0 +1,141 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { get } from '@toruslabs/http-helpers';
+import BigNumber from 'bignumber.js';
+import { METHOD_TYPES } from '../utils/constants.js';
+import { hexWEIToDecGWEI, decGWEIToHexWEI } from '../utils/conversionUtils.js';
+
+function normalizeGWEIDecimalNumbers(n) {
+  const numberAsWEIHex = decGWEIToHexWEI(new BigNumber(n));
+  const numberAsGWEI = hexWEIToDecGWEI(numberAsWEIHex);
+  return numberAsGWEI;
+}
+async function fetchGasEstimates(url) {
+  const estimates = await 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: hexWEIToDecGWEI(finalBaseFeePerGas).toString(10),
+    high: {
+      maxWaitTimeEstimate: 30000,
+      minWaitTimeEstimate: 15000,
+      suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.fast.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.fast.toString(16)).toString()
+    },
+    medium: {
+      maxWaitTimeEstimate: 45000,
+      minWaitTimeEstimate: 15000,
+      suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.average.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.average.toString(16)).toString()
+    },
+    low: {
+      maxWaitTimeEstimate: 60000,
+      minWaitTimeEstimate: 15000,
+      suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.slow.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: 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 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: METHOD_TYPES.ETH_GET_GAS_PRICE
+  });
+  return {
+    gasPrice: hexWEIToDecGWEI(gasPrice).toString()
+  };
+}
+function calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, gasFeeEstimates) {
+  // all are in dec gwei
+  const {
+    low,
+    medium,
+    high,
+    estimatedBaseFee
+  } = gasFeeEstimates;
+  const maxPriorityFeePerGasInWEI = new BigNumber(decGWEIToHexWEI(new BigNumber(maxPriorityFeePerGas)), 16);
+  const maxFeePerGasInWEI = new BigNumber(decGWEIToHexWEI(new BigNumber(maxFeePerGas)), 16);
+  const estimatedBaseFeeInWEI = new BigNumber(decGWEIToHexWEI(new BigNumber(estimatedBaseFee)), 16);
+  const effectiveMaxPriorityFee = BigNumber.min(maxPriorityFeePerGasInWEI, maxFeePerGasInWEI.minus(estimatedBaseFeeInWEI));
+  const lowMaxPriorityFeeInWEI = new BigNumber(decGWEIToHexWEI(new BigNumber(low.suggestedMaxPriorityFeePerGas)), 16);
+  const mediumMaxPriorityFeeInWEI = new BigNumber(decGWEIToHexWEI(new BigNumber(medium.suggestedMaxPriorityFeePerGas)), 16);
+  const highMaxPriorityFeeInWEI = new BigNumber(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
+  };
+}
+
+export { calculateTimeEstimate, fetchEthGasPriceEstimate, fetchGasEstimates, fetchGasEstimatesViaEthFeeHistory, fetchLegacyGasPriceEstimates, normalizeGWEIDecimalNumbers };

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

@@ -0,0 +1,91 @@
+import { bytesToHex, privateToPublic, toChecksumAddress, privateToAddress, stripHexPrefix, ecsign, bigIntToBytes, addHexPrefix } from '@ethereumjs/util';
+import { BaseKeyringController, concatSig } from '@toruslabs/base-controllers';
+import { SigningKey, hashMessage, TypedDataEncoder } from 'ethers';
+
+class KeyringController extends 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 = bytesToHex(privateToPublic(bufferPrivKey));
+    const address = toChecksumAddress(bytesToHex(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 = 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 = ecsign(Buffer.from(stripHexPrefix(data), "hex"), privKey);
+    const sig = concatSig(Buffer.from(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 SigningKey(addHexPrefix(wallet.privateKey));
+    const signature = privKey.sign(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 SigningKey(addHexPrefix(wallet.privateKey));
+    const signature = privKey.sign(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;
+  }
+}
+
+export { KeyringController };

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

@@ -0,0 +1,105 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { BaseController } from '@toruslabs/base-controllers';
+import { providerErrors, rpcErrors } from '@web3auth/auth';
+import { MessageStatus } from '../utils/constants.js';
+
+class AbstractMessageController extends 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 === 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, 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 === MessageStatus.REJECTED || status === MessageStatus.SIGNED || status === MessageStatus.FAILED) {
+      this.emit(`${messageId}:finished`, message);
+    }
+  }
+  async waitForFinishStatus(msgParams, messageName) {
+    return new Promise((resolve, reject) => {
+      const handleFinished = msg => {
+        if (msg.status === MessageStatus.REJECTED) {
+          return reject(providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
+        }
+        if (msg.status === MessageStatus.FAILED) {
+          return reject(rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
+        }
+        if (msg.status === MessageStatus.SIGNED) {
+          return resolve(msg.rawSig);
+        }
+        return reject(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
+    });
+  }
+}
+
+export { AbstractMessageController };

package/dist/lib.esm/Message/AddChainController.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 { validateAddChainData } from './utils.js';
+
+class AddChainController extends 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, 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) {
+    // 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 validateAddChainData(messageParams);
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.ADD_CHAIN
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+export { AddChainController };