@toruslabs/ethereum-controllers 5.5.3 → 5.5.4

package/src/Gas/gasUtil.ts

@@ -1,163 +0,0 @@
-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

@@ -1,117 +0,0 @@
-import { TypedTransaction } from "@ethereumjs/tx";
-import { bigIntToBytes, bytesToHex, ecsign, privateToAddress, privateToPublic, 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";
-
-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 = accountPrivateKey.padStart(64, "0");
-    const bufferPrivKey = Buffer.from(hexPrivateKey, "hex");
-    const publicKey = bytesToHex(privateToPublic(bufferPrivKey));
-    const address = 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: 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:
-  async signMessage(data: string, address: string): Promise<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

@@ -1,136 +0,0 @@
-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(messageId: string, messageParams: P): Promise<P> {
-    this.setMessageStatus(messageId, 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/AddChainController.ts

@@ -1,73 +0,0 @@
-import { BaseConfig, randomId } from "@toruslabs/base-controllers";
-import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
-import log from "loglevel";
-
-import NetworkController from "../Network/NetworkController";
-import PreferencesController from "../Preferences/PreferencesController";
-import { MESSAGE_EVENTS, MessageStatus, METHOD_TYPES } from "../utils/constants";
-import { AddChainMessage, AddChainMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
-import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
-import { validateAddChainData } from "./utils";
-
-export class AddChainController extends AbstractMessageController<AddChainMessage, AddChainMessageParams> {
-  override name = "AddChainController";
-
-  protected addChain: PreferencesController["addChain"];
-
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier,
-    addChain,
-  }: {
-    config: Partial<BaseConfig>;
-    state: Partial<MessageControllerState<AddChainMessage>>;
-    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
-    addChain: PreferencesController["addChain"];
-  }) {
-    super({ config, state, getNetworkIdentifier });
-    this.addChain = addChain;
-    this.initialize();
-  }
-
-  async processAddChain(messageId: string): Promise<string> {
-    try {
-      const msgObject = this.getMessage(messageId);
-      await this.approveMessage(messageId, msgObject.messageParams);
-      await this.addChain(msgObject.messageParams);
-      this.updateMessage({ ...msgObject, rawSig: JSON.stringify(msgObject.messageParams) });
-      this.setMessageStatus(messageId, MessageStatus.SIGNED);
-      return null;
-    } catch (error) {
-      log.error(error);
-      this.setMessageStatus(messageId, MessageStatus.FAILED);
-    }
-  }
-
-  async addNewUnapprovedMessage(messageParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
-  }
-
-  async addUnapprovedMessage(messageParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
-    validateAddChainData(messageParams);
-    if (req) {
-      messageParams.origin = req.origin;
-    }
-    const messageId = messageParams.id || randomId();
-    const messageData: AddChainMessage = {
-      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: AddChainMessageParams): Promise<AddChainMessageParams> {
-    return Promise.resolve(messageParams);
-  }
-}

package/src/Message/DecryptMessageController.ts

@@ -1,76 +0,0 @@
-// 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 { MESSAGE_EVENTS, MessageStatus, METHOD_TYPES } from "../utils/constants";
-import { DecryptMessage, DecryptMessageParams, 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<DecryptMessage>>;
-    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(messageId, 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<unknown> & UserRequestApprovalParams): Promise<string> {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
-  }
-
-  async addUnapprovedMessage(messageParams: DecryptMessageParams, req?: JRPCRequest<unknown> & UserRequestApprovalParams) {
-    validateDecryptedMessageData(messageParams);
-    if (req) {
-      messageParams.origin = req.origin;
-    }
-    messageParams.data = normalizeMessageData(messageParams.data);
-    const messageId = messageParams.id || randomId();
-    const messageData: DecryptMessage = {
-      id: messageId,
-      messageParams,
-      status: MessageStatus.UNAPPROVED,
-      time: Date.now(),
-      type: METHOD_TYPES.ETH_DECRYPT,
-    };
-    await this.addMessage(messageData);
-    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, { messageData, req });
-    return messageId;
-  }
-
-  prepMessageForSigning(messageParams: DecryptMessageParams): Promise<DecryptMessageParams> {
-    return Promise.resolve({ ...messageParams });
-  }
-}

package/src/Message/EncryptionPublicKeyController.ts

@@ -1,75 +0,0 @@
-// 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 { MESSAGE_EVENTS, 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(messageId, 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<unknown> & UserRequestApprovalParams): Promise<string> {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
-  }
-
-  async addUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req?: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
-    validateEncryptionPublicKeyMessageData(messageParams);
-    if (req) {
-      messageParams.origin = req.origin;
-    }
-    const messageId = messageParams.id || 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(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, { messageData, req });
-    return messageId;
-  }
-
-  prepMessageForSigning(messageParams: EncryptionPublicKeyParams): Promise<EncryptionPublicKeyParams> {
-    // From should be the public key for the encryption
-    return Promise.resolve({ ...messageParams, from: messageParams.data });
-  }
-}