@toruslabs/ethereum-controllers 4.1.0

package/src/Gas/gasUtil.ts

@@ -0,0 +1,163 @@
+import { get } from "@toruslabs/http-helpers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import BigNumber from "bignumber.js";
+
+import { METHOD_TYPES } from "../utils/constants";
+import { decGWEIToHexWEI, hexWEIToDecGWEI } from "../utils/conversionUtils";
+import {
+  EthereumGasFeeEstimates,
+  EthereumLegacyGasFeeEstimates,
+  GasEstimatesAPIResponse,
+  GasEstimatesLegacyAPIResponse,
+  GasFeeTimeBounds,
+} from "./IGasFeeController";
+
+export function normalizeGWEIDecimalNumbers(n: string | number): number | BigNumber {
+  const numberAsWEIHex = decGWEIToHexWEI(new BigNumber(n));
+  const numberAsGWEI = hexWEIToDecGWEI(numberAsWEIHex);
+  return numberAsGWEI;
+}
+
+export async function fetchGasEstimates(url: string): Promise<EthereumGasFeeEstimates> {
+  const estimates = await get<GasEstimatesAPIResponse>(url);
+  const normalizedEstimates = {
+    estimatedBaseFee: normalizeGWEIDecimalNumbers(estimates.estimatedBaseFee).toString(10),
+    low: {
+      ...estimates.low,
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.low.suggestedMaxPriorityFeePerGas).toString(10),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.low.suggestedMaxFeePerGas).toString(10),
+    },
+    medium: {
+      ...estimates.medium,
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.medium.suggestedMaxPriorityFeePerGas).toString(10),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.medium.suggestedMaxFeePerGas).toString(10),
+    },
+    high: {
+      ...estimates.high,
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.high.suggestedMaxPriorityFeePerGas).toString(10),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.high.suggestedMaxFeePerGas).toString(10),
+    },
+  };
+  return normalizedEstimates;
+}
+
+export interface FeeHistoryResponse {
+  baseFeePerGas: string[];
+  gasUsedRatio: string[];
+  oldestBlock: string;
+  reward: string[][];
+}
+
+export async function fetchGasEstimatesViaEthFeeHistory(provider: SafeEventEmitterProvider): Promise<EthereumGasFeeEstimates> {
+  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<[number, string, number[]], FeeHistoryResponse>({
+    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: 30_000,
+      minWaitTimeEstimate: 15_000,
+      suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.fast.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.fast.toString(16)).toString(),
+    },
+    medium: {
+      maxWaitTimeEstimate: 45_000,
+      minWaitTimeEstimate: 15_000,
+      suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.average.plus(finalBaseFeePerGas).toString(16)).toString(),
+      suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.average.toString(16)).toString(),
+    },
+    low: {
+      maxWaitTimeEstimate: 60_000,
+      minWaitTimeEstimate: 15_000,
+      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.
+ */
+export async function fetchLegacyGasPriceEstimates(url: string): Promise<EthereumLegacyGasFeeEstimates> {
+  const result = await get<GasEstimatesLegacyAPIResponse>(url, {
+    referrer: url,
+    referrerPolicy: "no-referrer-when-downgrade",
+    method: "GET",
+  });
+  // this returns decimal gwei
+  return {
+    low: result.SafeGasPrice,
+    medium: result.ProposeGasPrice,
+    high: result.FastGasPrice,
+  };
+}
+
+export async function fetchEthGasPriceEstimate(provider: SafeEventEmitterProvider): Promise<{ gasPrice: string }> {
+  const gasPrice = await provider.request<never, string>({ method: METHOD_TYPES.ETH_GET_GAS_PRICE });
+  return {
+    gasPrice: hexWEIToDecGWEI(gasPrice).toString(),
+  };
+}
+
+export function calculateTimeEstimate(
+  maxPriorityFeePerGas: string,
+  maxFeePerGas: string,
+  gasFeeEstimates: EthereumGasFeeEstimates
+): GasFeeTimeBounds {
+  // 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: null | number;
+  let upperTimeBound: string | number;
+
+  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,
+  };
+}

package/src/Keyring/KeyringController.ts

@@ -0,0 +1,118 @@
+import { TypedTransaction } from "@ethereumjs/tx";
+import { addHexPrefix, bigIntToBytes, ecsign, stripHexPrefix } from "@ethereumjs/util";
+import {
+  concatSig,
+  decrypt,
+  EthEncryptedData,
+  getEncryptionPublicKey,
+  MessageTypes,
+  personalSign,
+  signTypedData,
+  SignTypedDataVersion,
+  TypedDataV1,
+  TypedMessage,
+} from "@metamask/eth-sig-util";
+import { BaseConfig, BaseKeyringController, IKeyringController, KeyringControllerState } from "@toruslabs/base-controllers";
+import { SigningKey, Wallet } from "ethers";
+
+export default class KeyringController extends BaseKeyringController<Partial<BaseConfig>, KeyringControllerState> implements IKeyringController {
+  constructor({ config, state }: { config: Partial<BaseConfig>; state: Partial<KeyringControllerState> }) {
+    super({ config, state });
+    this.defaultState = { wallets: [] };
+    this.initialize();
+  }
+
+  async signTransaction<T, U>(tx: T, address: string): Promise<U> {
+    const txPayload = tx as unknown as TypedTransaction;
+    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 as unknown as U) : (signedTx as unknown as U);
+  }
+
+  getAccounts(): string[] {
+    return this.state.wallets.map((w) => w.publicKey);
+  }
+
+  importAccount(accountPrivateKey: string): string {
+    const hexPrivateKey = addHexPrefix(accountPrivateKey);
+    const signingKey = new SigningKey(hexPrivateKey);
+    const wallet = new Wallet(signingKey.privateKey);
+    const { address } = wallet;
+
+    const existingWallet = this.state.wallets.find((w) => w.address === address);
+    if (existingWallet) return existingWallet.address;
+
+    this.update({
+      wallets: [
+        ...this.state.wallets,
+        {
+          publicKey: signingKey.publicKey,
+          privateKey: accountPrivateKey,
+          address,
+        },
+      ],
+    });
+    return address;
+  }
+
+  removeAccount(address: string): void {
+    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: string) {
+    const stripped = stripHexPrefix(privateKey);
+    return Buffer.from(stripped, "hex");
+  }
+
+  // For eth_sign, we need to sign arbitrary data:
+  signMessage(data: string, address: string) {
+    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;
+  }
+
+  // For personal_sign, we need to prefix the message: ensure input is hashed and not buffer of utf-8
+  async signPersonalMessage(data: string, address: string) {
+    const wallet = this._getWalletForAccount(address);
+    const privKey = this.getBufferPrivateKey(wallet.privateKey);
+    const sig = personalSign({ privateKey: privKey, data });
+    return sig;
+  }
+
+  // personal_signTypedData, signs data along with the schema
+  async signTypedData<V extends SignTypedDataVersion, T extends MessageTypes>(
+    typedData: V extends "V1" ? TypedDataV1 : TypedMessage<T>,
+    address: string,
+    version: V
+  ) {
+    const wallet = this._getWalletForAccount(address);
+    const privKey = this.getBufferPrivateKey(wallet.privateKey);
+    return signTypedData({ privateKey: privKey, data: typedData, version });
+  }
+
+  signEncryptionPublicKey(address: string) {
+    const wallet = this._getWalletForAccount(address);
+    return getEncryptionPublicKey(stripHexPrefix(wallet.privateKey));
+  }
+
+  decryptMessage(data: EthEncryptedData, address: string) {
+    const wallet = this._getWalletForAccount(address);
+    return decrypt({ encryptedData: data, privateKey: stripHexPrefix(wallet.privateKey) });
+  }
+
+  private _getWalletForAccount(account: string) {
+    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;
+  }
+}

package/src/Message/AbstractMessageController.ts

@@ -0,0 +1,136 @@
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+import { providerErrors, rpcErrors } from "@metamask/rpc-errors";
+import { BaseConfig, BaseController, BaseState } from "@toruslabs/base-controllers";
+import { JRPCRequest, Json } from "@toruslabs/openlogin-jrpc";
+
+import NetworkController from "../Network/NetworkController";
+import { MessageStatus } from "../utils/constants";
+import { AbstractMessage, BaseRequestParams, MessageStatusType, UserRequestApprovalParams } from "../utils/interfaces";
+
+export interface MessageControllerState<M extends AbstractMessage> extends BaseState {
+  unapprovedMessages: Record<string, M>;
+  unapprovedMessagesCount: number;
+}
+
+export default abstract class AbstractMessageController<M extends AbstractMessage, P extends BaseRequestParams> extends BaseController<
+  BaseConfig,
+  MessageControllerState<M>
+> {
+  protected messages: M[];
+
+  protected getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+
+  /**
+   * Controller in charge of managing - storing, adding, removing, updating - Messages.
+   *
+   */
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+  }: {
+    config?: Partial<BaseConfig>;
+    state?: Partial<MessageControllerState<M>>;
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state });
+    this.defaultState = {
+      unapprovedMessages: {},
+      unapprovedMessagesCount: 0,
+    };
+    this.messages = [];
+    this.defaultConfig = {};
+    this.getNetworkIdentifier = getNetworkIdentifier;
+    super.initialize();
+  }
+
+  getMessage(messageId: string) {
+    return this.messages.find((message) => message.id === messageId);
+  }
+
+  getAllMessages() {
+    return this.messages;
+  }
+
+  setMetadata(messageId: string, metadata: Json) {
+    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: { [key: string]: M }, message: M) => {
+        result[message.id] = message;
+        return result;
+      }, {}) as { [key: string]: M };
+  }
+
+  async addMessage(message: M) {
+    this.messages.push(message);
+    this.saveMessageList();
+  }
+
+  approveMessage(messageParams: P): Promise<P> {
+    this.setMessageStatus(messageParams.id, MessageStatus.APPROVED);
+    return this.prepMessageForSigning(messageParams);
+  }
+
+  setMessageStatus(messageId: string, status: MessageStatusType) {
+    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: P, messageName: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const handleFinished = (msg: M) => {
+        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 as string);
+        }
+
+        return reject(rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
+      };
+      this.once(`${msgParams.id}:finished`, handleFinished);
+    });
+  }
+
+  protected updateMessage(message: M) {
+    const index = this.messages.findIndex((msg) => message.id === msg.id);
+    if (index !== -1) {
+      this.messages[index] = message;
+    }
+    this.saveMessageList();
+  }
+
+  protected saveMessageList() {
+    const unapprovedMessages = this.getUnapprovedMessages();
+    const unapprovedMessagesCount = Object.keys(unapprovedMessages).length;
+    this.update({ unapprovedMessages, unapprovedMessagesCount });
+  }
+
+  abstract prepMessageForSigning(messageParams: P): Promise<P>;
+
+  abstract addUnapprovedMessage(
+    messageParams: P,
+    request: JRPCRequest<P> & UserRequestApprovalParams,
+    version?: SignTypedDataVersion
+  ): Promise<string>;
+}

package/src/Message/DecryptMessageController.ts

@@ -0,0 +1,81 @@
+// import { isValidAddress } from "@ethereumjs/util";
+import { BaseConfig, randomId } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import log from "loglevel";
+
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { MessageStatus, METHOD_TYPES } from "../utils/constants";
+import { DecryptMessage, DecryptMessageParams, Message, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+import { normalizeMessageData, parseDecryptMessageData, validateDecryptedMessageData } from "./utils";
+
+export class DecryptMessageController extends AbstractMessageController<DecryptMessage, DecryptMessageParams> {
+  override name = "DecryptMessageController";
+
+  protected decryptMessage: KeyringController["decryptMessage"];
+
+  constructor({
+    config,
+    state,
+    decryptMessage,
+    getNetworkIdentifier,
+  }: {
+    config: Partial<BaseConfig>;
+    state: Partial<MessageControllerState<Message>>;
+    decryptMessage: KeyringController["decryptMessage"];
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state, getNetworkIdentifier });
+    this.decryptMessage = decryptMessage;
+    this.initialize();
+  }
+
+  async processDecryptMessage(messageId: string): Promise<string> {
+    try {
+      const msgObject = this.getMessage(messageId);
+      const cleanMsgParams = await this.approveMessage(msgObject.messageParams);
+      const parsedData = parseDecryptMessageData(cleanMsgParams.data);
+      const rawSig = this.decryptMessage(parsedData, cleanMsgParams.from);
+      this.updateMessage({ ...msgObject, rawSig });
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+
+  async addNewUnapprovedMessage(
+    messageParams: DecryptMessageParams,
+    req: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams
+  ): Promise<string> {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+
+  async addUnapprovedMessage(messageParams: DecryptMessageParams, req?: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams) {
+    validateDecryptedMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = normalizeMessageData(messageParams.data);
+    const messageId = randomId();
+    const messageData: DecryptMessage = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.ETH_DECRYPT,
+    };
+    await this.addMessage(messageData);
+    this.emit(`unapprovedMessage`, {
+      ...messageParams,
+    });
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: DecryptMessageParams): Promise<DecryptMessageParams> {
+    return Promise.resolve({ ...messageParams });
+  }
+}

package/src/Message/EncryptionPublicKeyController.ts

@@ -0,0 +1,83 @@
+// import { isValidAddress } from "@ethereumjs/util";
+import { BaseConfig, randomId } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import log from "loglevel";
+
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { MessageStatus, METHOD_TYPES } from "../utils/constants";
+import { EncryptionPublicKey, EncryptionPublicKeyParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+import { validateEncryptionPublicKeyMessageData } from "./utils";
+
+export class EncryptionPublicKeyController extends AbstractMessageController<EncryptionPublicKey, EncryptionPublicKeyParams> {
+  override name = "EncryptionPublicKeyController";
+
+  protected signEncryptionPublicKey: KeyringController["signEncryptionPublicKey"];
+
+  constructor({
+    config,
+    state,
+    signEncryptionPublicKey,
+    getNetworkIdentifier,
+  }: {
+    config: Partial<BaseConfig>;
+    state: Partial<MessageControllerState<EncryptionPublicKey>>;
+    signEncryptionPublicKey: KeyringController["signEncryptionPublicKey"];
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state, getNetworkIdentifier });
+    this.signEncryptionPublicKey = signEncryptionPublicKey;
+    this.initialize();
+  }
+
+  async processGetEncryptionPublicKey(messageId: string): Promise<string> {
+    try {
+      const msgObject = this.getMessage(messageId);
+      const cleanMsgParams = await this.approveMessage(msgObject.messageParams);
+      const publicKey = this.signEncryptionPublicKey(cleanMsgParams.from);
+      this.updateMessage({ ...msgObject, rawSig: publicKey });
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return publicKey;
+    } catch (error) {
+      log.error(error);
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+
+  async addNewUnapprovedMessage(
+    messageParams: EncryptionPublicKeyParams,
+    req: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams
+  ): Promise<string> {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+
+  async addUnapprovedMessage(
+    messageParams: EncryptionPublicKeyParams,
+    req?: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams
+  ): Promise<string> {
+    validateEncryptionPublicKeyMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    const messageId = randomId();
+    const messageData: EncryptionPublicKey = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.ETH_GET_ENCRYPTION_PUBLIC_KEY,
+    };
+    await this.addMessage(messageData);
+    this.emit(`unapprovedMessage`, {
+      ...messageParams,
+    });
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: EncryptionPublicKeyParams): Promise<EncryptionPublicKeyParams> {
+    // From should be the public key for the encryption
+    return Promise.resolve({ ...messageParams, from: messageParams.data });
+  }
+}

package/src/Message/MessageController.ts

@@ -0,0 +1,74 @@
+import { BaseConfig, randomId } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import log from "loglevel";
+
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { MessageStatus, METHOD_TYPES } from "../utils/constants";
+import { Message, MessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+import { normalizeMessageData, validateSignMessageData } from "./utils";
+
+export class MessageController extends AbstractMessageController<Message, MessageParams> {
+  override name = "MessageController";
+
+  protected signMessage: KeyringController["signMessage"];
+
+  constructor({
+    config,
+    state,
+    signMessage,
+    getNetworkIdentifier,
+  }: {
+    config: Partial<BaseConfig>;
+    state: Partial<MessageControllerState<Message>>;
+    signMessage: KeyringController["signMessage"];
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state, getNetworkIdentifier });
+    this.signMessage = signMessage;
+    this.initialize();
+  }
+
+  async processSignMessage(messageId: string): Promise<string> {
+    try {
+      const msgObject = this.getMessage(messageId);
+      const cleanMsgParams = await this.approveMessage(msgObject.messageParams);
+      const rawSig = this.signMessage(cleanMsgParams.data, cleanMsgParams.from);
+      this.updateMessage({ ...msgObject, rawSig });
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+
+  async addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string> {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+
+  async addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string> {
+    validateSignMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = normalizeMessageData(messageParams.data);
+    const messageId = randomId();
+    const messageData: Message = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.ETH_SIGN,
+    };
+    await this.addMessage(messageData);
+    this.emit(`unapprovedMessage`, messageParams);
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: MessageParams): Promise<MessageParams> {
+    return Promise.resolve(messageParams);
+  }
+}