@toruslabs/ethereum-controllers 4.1.0

package/src/Message/PersonalMessageController.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 PersonalMessageController extends AbstractMessageController<Message, MessageParams> {
+  override name = "PersonalMessageController";
+
+  protected signPersonalMessage: KeyringController["signPersonalMessage"];
+
+  constructor({
+    config,
+    state,
+    signPersonalMessage,
+    getNetworkIdentifier,
+  }: {
+    config: Partial<BaseConfig>;
+    state: Partial<MessageControllerState<Message>>;
+    signPersonalMessage: KeyringController["signPersonalMessage"];
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state, getNetworkIdentifier });
+    this.signPersonalMessage = signPersonalMessage;
+    this.initialize();
+  }
+
+  async processPersonalSignMessage(messageId: string): Promise<string> {
+    try {
+      const msgObject = this.getMessage(messageId);
+      const cleanMsgParams = await this.approveMessage(msgObject.messageParams);
+      const rawSig = await this.signPersonalMessage(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.PERSONAL_SIGN,
+    };
+    await this.addMessage(messageData);
+    this.emit(`unapprovedMessage`, messageParams);
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: MessageParams): Promise<MessageParams> {
+    return Promise.resolve(messageParams);
+  }
+}

package/src/Message/TypedMessageController.ts

@@ -0,0 +1,112 @@
+import { MessageTypes, SignTypedDataVersion, TypedDataV1, TypedMessage as EthSigTypedMessage } from "@metamask/eth-sig-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 { METHOD_TYPES_TYPE, TypedMessage, TypedMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+import { validateTypedSignMessageDataV1, validateTypedSignMessageDataV3V4 } from "./utils";
+
+function getMessageType(version: SignTypedDataVersion): METHOD_TYPES_TYPE {
+  switch (version) {
+    case SignTypedDataVersion.V1:
+      return METHOD_TYPES.ETH_SIGN_TYPED_DATA;
+    case SignTypedDataVersion.V3:
+      return METHOD_TYPES.ETH_SIGN_TYPED_DATA_V3;
+    case SignTypedDataVersion.V4:
+      return METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4;
+    default:
+      return METHOD_TYPES.ETH_SIGN_TYPED_DATA;
+  }
+}
+
+export class TypedMessageController extends AbstractMessageController<TypedMessage, TypedMessageParams> {
+  override name = "TypedMessageController";
+
+  protected signTypedData: KeyringController["signTypedData"];
+
+  constructor({
+    config,
+    state,
+    signTypedData,
+    getNetworkIdentifier,
+  }: {
+    config: Partial<BaseConfig>;
+    state: Partial<MessageControllerState<TypedMessage>>;
+    signTypedData: KeyringController["signTypedData"];
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state, getNetworkIdentifier });
+    this.signTypedData = signTypedData;
+    this.initialize();
+  }
+
+  async processPersonalSignMessage(messageId: string): Promise<string> {
+    try {
+      const msgObject = this.getMessage(messageId);
+      const cleanMsgParams = await this.approveMessage(msgObject.messageParams);
+      const rawSig = await this.signTypedData(
+        cleanMsgParams.data as TypedDataV1 | EthSigTypedMessage<MessageTypes>,
+        cleanMsgParams.from,
+        cleanMsgParams.version
+      );
+      this.updateMessage({ ...msgObject, rawSig });
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+
+  async addNewUnapprovedMessage(
+    messageParams: TypedMessageParams,
+    req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams,
+    version: SignTypedDataVersion
+  ): Promise<string> {
+    await this.addUnapprovedMessage(messageParams, req, version);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+
+  async addUnapprovedMessage(
+    messageParams: TypedMessageParams,
+    req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams,
+    version: SignTypedDataVersion
+  ): Promise<string> {
+    if (version === SignTypedDataVersion.V1) {
+      validateTypedSignMessageDataV1(messageParams);
+    }
+
+    if (version === SignTypedDataVersion.V3 || version === SignTypedDataVersion.V4) {
+      const currentChainId = this.getNetworkIdentifier();
+      validateTypedSignMessageDataV3V4(messageParams, currentChainId);
+    }
+
+    if (typeof messageParams.data !== "string" && (version === SignTypedDataVersion.V3 || version === SignTypedDataVersion.V4)) {
+      messageParams.data = JSON.stringify(messageParams.data);
+    }
+
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.version = version;
+    const messageId = randomId();
+    const messageData: TypedMessage = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: getMessageType(version),
+    };
+    await this.addMessage(messageData);
+    this.emit(`unapprovedMessage`, messageParams);
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: TypedMessageParams): Promise<TypedMessageParams> {
+    return Promise.resolve(messageParams);
+  }
+}

package/src/Message/utils.ts

@@ -0,0 +1,107 @@
+import { addHexPrefix, bytesToHex, isValidAddress, stripHexPrefix } from "@ethereumjs/util";
+import { EthEncryptedData, TYPED_MESSAGE_SCHEMA, TypedDataV1Field, typedSignatureHash } from "@metamask/eth-sig-util";
+import { validate } from "jsonschema";
+
+import { DecryptMessageParams, EncryptionPublicKeyParams, MessageParams, TypedMessageParams } from "../utils/interfaces";
+
+const hexRe = /^[0-9A-Fa-f]+$/gu;
+
+export function validateAddress(address: string, propertyName: string) {
+  if (!address || typeof address !== "string" || !isValidAddress(address)) {
+    throw new Error(`Invalid "${propertyName}" address: ${address} must be a valid string.`);
+  }
+}
+
+export function validateSignMessageData(messageData: MessageParams) {
+  const { from, data } = messageData;
+  validateAddress(from, "from");
+
+  if (!data || typeof data !== "string") {
+    throw new Error(`Invalid message "data": ${data} must be a valid string.`);
+  }
+}
+
+export function normalizeMessageData(data: string): string {
+  try {
+    const stripped = stripHexPrefix(data);
+    if (stripped.match(hexRe)) {
+      return addHexPrefix(stripped);
+    }
+  } catch (e) {}
+  return bytesToHex(Buffer.from(data, "utf8"));
+}
+
+export function validateTypedSignMessageDataV1(messageData: TypedMessageParams) {
+  validateAddress(messageData.from, "from");
+
+  if (!messageData.data || !Array.isArray(messageData.data)) {
+    throw new Error(`Invalid message "data": ${messageData.data} must be a valid array.`);
+  }
+
+  try {
+    // typedSignatureHash will throw if the data is invalid.
+    typedSignatureHash(messageData.data as TypedDataV1Field[]);
+  } catch (e) {
+    throw new Error(`Expected EIP712 typed data.`);
+  }
+}
+
+export function validateTypedSignMessageDataV3V4(messageData: TypedMessageParams, currentChainId: string) {
+  validateAddress(messageData.from, "from");
+
+  if (!messageData.data || Array.isArray(messageData.data) || (typeof messageData.data !== "object" && typeof messageData.data !== "string")) {
+    throw new Error(`Invalid message "data": Must be a valid string or object.`);
+  }
+
+  let data;
+  if (typeof messageData.data === "object") {
+    data = messageData.data;
+  } else {
+    try {
+      data = JSON.parse(messageData.data);
+    } catch (e) {
+      throw new Error("Data must be passed as a valid JSON string.");
+    }
+  }
+
+  const validation = validate(data, TYPED_MESSAGE_SCHEMA);
+  if (validation.errors.length > 0) {
+    throw new Error("Data must conform to EIP-712 schema. See https://git.io/fNtcx.");
+  }
+
+  if (!currentChainId) {
+    throw new Error("Current chainId cannot be null or undefined.");
+  }
+
+  let { chainId } = data.domain;
+  if (chainId) {
+    if (typeof chainId === "string") {
+      chainId = parseInt(chainId, chainId.startsWith("0x") ? 16 : 10);
+    }
+
+    const activeChainId = parseInt(currentChainId, 16);
+    if (Number.isNaN(activeChainId)) {
+      throw new Error(`Cannot sign messages for chainId "${chainId}", because MetaMask is switching networks.`);
+    }
+
+    if (chainId !== activeChainId) {
+      throw new Error(`Provided chainId "${chainId}" must match the active chainId "${activeChainId}"`);
+    }
+  }
+}
+
+export function validateEncryptionPublicKeyMessageData(messageData: EncryptionPublicKeyParams) {
+  const { from } = messageData;
+  validateAddress(from, "from");
+}
+
+export function validateDecryptedMessageData(messageData: DecryptMessageParams) {
+  const { from } = messageData;
+  validateAddress(from, "from");
+}
+
+export function parseDecryptMessageData(data: string): EthEncryptedData {
+  const stripped = stripHexPrefix(data);
+  const buffer = Buffer.from(stripped, "hex");
+  return JSON.parse(buffer.toString("utf8")) as EthEncryptedData;
+}

package/src/Network/NetworkController.ts

@@ -0,0 +1,184 @@
+import { BaseController, createEventEmitterProxy, createSwappableProxy, INetworkController } from "@toruslabs/base-controllers";
+import { JRPCEngine, JRPCMiddleware, providerFromEngine, SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { Mutex } from "async-mutex";
+import log from "loglevel";
+
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import { SUPPORTED_NETWORKS } from "../utils/constants";
+import { EthereumNetworkConfig, EthereumNetworkState, EthereumProviderConfig } from "../utils/interfaces";
+import { createEthereumMiddleware, IProviderHandlers } from "./createEthereumMiddleware";
+import { createJsonRpcClient } from "./createJsonRpcClient";
+
+export default class NetworkController
+  extends BaseController<EthereumNetworkConfig, EthereumNetworkState>
+  implements INetworkController<EthereumNetworkConfig, EthereumNetworkState>
+{
+  name = "NetworkController";
+
+  providerProxy: SafeEventEmitterProvider;
+
+  blockTrackerProxy: PollingBlockTracker;
+
+  private mutex: Mutex = new Mutex();
+
+  private provider?: SafeEventEmitterProvider = null;
+
+  private blockTracker?: PollingBlockTracker = null;
+
+  private baseProviderHandlers: IProviderHandlers;
+
+  constructor({ config, state }: { config?: Partial<EthereumNetworkConfig>; state?: Partial<EthereumNetworkState> }) {
+    super({ config, state });
+
+    this.defaultState = {
+      chainId: "loading",
+      properties: { EIPS_1559: undefined },
+      providerConfig: SUPPORTED_NETWORKS.mainnet,
+    };
+
+    // when a new network is set,
+    // we set to loading first and
+    // then when connection succeeds,
+    // we update the network
+    this.initialize();
+  }
+
+  getNetworkIdentifier(): string {
+    return this.state.chainId;
+  }
+
+  getNetworkRPCUrl(): string {
+    return this.state.providerConfig.rpcTarget;
+  }
+
+  /**
+   * Called by orchestrator once while initializing the class
+   * @param providerHandlers - JRPC handlers for provider
+   * @returns - provider - Returns the providerProxy
+   */
+  public initializeProvider(providerHandlers: IProviderHandlers): SafeEventEmitterProvider {
+    this.baseProviderHandlers = providerHandlers;
+    this.configureProvider();
+    this.lookupNetwork(); // Not awaiting this, because we don't want to block the initialization
+    return this.providerProxy;
+  }
+
+  getProvider(): SafeEventEmitterProvider {
+    return this.providerProxy;
+  }
+
+  getBlockTracker(): PollingBlockTracker {
+    return this.blockTrackerProxy;
+  }
+
+  getProviderConfig(): EthereumProviderConfig {
+    return this.state.providerConfig;
+  }
+
+  setProviderConfig(config: EthereumProviderConfig): void {
+    this.update({
+      providerConfig: { ...config },
+    });
+    this.refreshNetwork();
+  }
+
+  async getEIP1559Compatibility(): Promise<boolean> {
+    const { EIPS_1559 } = this.state.properties;
+    // log.info('checking eip 1559 compatibility')
+    if (EIPS_1559 !== undefined) {
+      return EIPS_1559 as boolean;
+    }
+    const latestBlock = await this.blockTracker.getLatestBlock();
+    const supportsEIP1559 = latestBlock && latestBlock.baseFeePerGas !== undefined;
+    this.update({ properties: { EIPS_1559: supportsEIP1559 } });
+    return supportsEIP1559;
+  }
+
+  /**
+   * Refreshes the current network code
+   */
+  async lookupNetwork(): Promise<void> {
+    const { chainId, rpcTarget } = this.getProviderConfig();
+    if (!chainId || !rpcTarget || !this.provider) {
+      this.update({ chainId: "loading", properties: {} });
+      return;
+    }
+    const releaseLock = await this.mutex.acquire();
+    try {
+      // use eth_chainId
+      const [networkChainId] = await Promise.all([this.provider.request<never, string>({ method: "eth_chainId" }), this.getEIP1559Compatibility()]);
+      log.info("network fetched chain id", networkChainId);
+      // update chain ID
+      this.update({
+        chainId: networkChainId,
+      });
+      this.emit("networkDidChange");
+    } catch {
+      this.update({
+        chainId: "loading",
+      });
+    } finally {
+      releaseLock();
+    }
+  }
+
+  private configureProvider(): void {
+    const { chainId, rpcTarget, ...rest } = this.getProviderConfig();
+    if (!chainId || !rpcTarget) {
+      throw new Error("chainId and rpcTarget must be provider in providerConfig");
+    }
+    this.configureStandardProvider({ chainId, rpcTarget, ...rest });
+  }
+
+  private setNetworkClient({
+    networkMiddleware,
+    blockTracker,
+  }: {
+    networkMiddleware: JRPCMiddleware<unknown, unknown>;
+    blockTracker: PollingBlockTracker;
+  }): void {
+    const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers);
+    const engine = new JRPCEngine();
+    engine.push(ethereumMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.setProvider({ provider, blockTracker });
+  }
+
+  private setProvider({ provider, blockTracker }: { provider: SafeEventEmitterProvider; blockTracker: PollingBlockTracker }): void {
+    if (this.providerProxy) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.providerProxy.setTarget(provider);
+    } else {
+      this.providerProxy = createSwappableProxy<SafeEventEmitterProvider>(provider);
+    }
+
+    if (this.blockTrackerProxy) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.blockTrackerProxy.setTarget(blockTracker);
+    } else {
+      this.blockTrackerProxy = createEventEmitterProxy<PollingBlockTracker>(blockTracker, {
+        eventFilter: "skipInternal",
+      });
+    }
+
+    // set new provider and blockTracker
+    this.provider = provider;
+    provider.setMaxListeners(10);
+    this.blockTracker = blockTracker;
+  }
+
+  private configureStandardProvider(providerConfig: EthereumProviderConfig): void {
+    const networkClient = createJsonRpcClient(providerConfig);
+    log.info("networkClient", networkClient);
+    this.setNetworkClient(networkClient);
+  }
+
+  private refreshNetwork() {
+    this.update({ chainId: "loading", properties: {} });
+    this.configureProvider();
+    this.lookupNetwork();
+  }
+}