@toruslabs/ethereum-controllers 4.5.2 → 4.7.0

package/dist/types/Message/AddChainController.d.ts

@@ -0,0 +1,20 @@
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { AddChainMessage, AddChainMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class AddChainController extends AbstractMessageController<AddChainMessage, AddChainMessageParams> {
+    name: string;
+    protected addChain: PreferencesController["addChain"];
+    constructor({ config, state, getNetworkIdentifier, addChain, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<AddChainMessage>>;
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+        addChain: PreferencesController["addChain"];
+    });
+    processAddChain(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    prepMessageForSigning(messageParams: AddChainMessageParams): Promise<AddChainMessageParams>;
+}

package/dist/types/Message/DecryptMessageController.d.ts

@@ -14,7 +14,7 @@ export declare class DecryptMessageController extends AbstractMessageController<
         getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
     });
     processDecryptMessage(messageId: string): Promise<string>;
-    addNewUnapprovedMessage(messageParams: DecryptMessageParams, req: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams): Promise<string>;
-    addUnapprovedMessage(messageParams: DecryptMessageParams, req?: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams): Promise<string>;
+    addNewUnapprovedMessage(messageParams: DecryptMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: DecryptMessageParams, req?: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
     prepMessageForSigning(messageParams: DecryptMessageParams): Promise<DecryptMessageParams>;
 }

package/dist/types/Message/EncryptionPublicKeyController.d.ts

@@ -14,7 +14,7 @@ export declare class EncryptionPublicKeyController extends AbstractMessageContro
         getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
     });
     processGetEncryptionPublicKey(messageId: string): Promise<string>;
-    addNewUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams): Promise<string>;
-    addUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req?: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams): Promise<string>;
+    addNewUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req?: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
     prepMessageForSigning(messageParams: EncryptionPublicKeyParams): Promise<EncryptionPublicKeyParams>;
 }

package/dist/types/Message/MessageController.d.ts

@@ -14,7 +14,7 @@ export declare class MessageController extends AbstractMessageController<Message
         getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
     });
     processSignMessage(messageId: string): Promise<string>;
-    addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
-    addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
+    addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
     prepMessageForSigning(messageParams: MessageParams): Promise<MessageParams>;
 }

package/dist/types/Message/PersonalMessageController.d.ts

@@ -14,7 +14,7 @@ export declare class PersonalMessageController extends AbstractMessageController
         getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
     });
     processPersonalSignMessage(messageId: string): Promise<string>;
-    addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
-    addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
+    addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
     prepMessageForSigning(messageParams: MessageParams): Promise<MessageParams>;
 }

package/dist/types/Message/SwitchChainController.d.ts

@@ -0,0 +1,20 @@
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { SwitchChainMessage, SwitchChainMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class SwitchChainController extends AbstractMessageController<SwitchChainMessage, SwitchChainMessageParams> {
+    name: string;
+    protected switchChain: PreferencesController["switchChain"];
+    constructor({ config, state, getNetworkIdentifier, switchChain, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<SwitchChainMessage>>;
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+        switchChain: PreferencesController["switchChain"];
+    });
+    processSwitchChain(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string>;
+    prepMessageForSigning(messageParams: SwitchChainMessageParams): Promise<SwitchChainMessageParams>;
+}

package/dist/types/Message/TypedMessageController.d.ts

@@ -15,7 +15,7 @@ export declare class TypedMessageController extends AbstractMessageController<Ty
         getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
     });
     processPersonalSignMessage(messageId: string): Promise<string>;
-    addNewUnapprovedMessage(messageParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams, version: SignTypedDataVersion): Promise<string>;
-    addUnapprovedMessage(messageParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams, version: SignTypedDataVersion): Promise<string>;
+    addNewUnapprovedMessage(messageParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams, version: SignTypedDataVersion): Promise<string>;
+    addUnapprovedMessage(messageParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams, version: SignTypedDataVersion): Promise<string>;
     prepMessageForSigning(messageParams: TypedMessageParams): Promise<TypedMessageParams>;
 }

package/dist/types/Message/utils.d.ts

@@ -1,5 +1,5 @@
 import { EthEncryptedData } from "@metamask/eth-sig-util";
-import { DecryptMessageParams, EncryptionPublicKeyParams, MessageParams, TypedMessageParams } from "../utils/interfaces";
+import { AddChainMessageParams, DecryptMessageParams, EncryptionPublicKeyParams, MessageParams, SwitchChainMessageParams, TypedMessageParams } from "../utils/interfaces";
 export declare function validateAddress(address: string, propertyName: string): void;
 export declare function validateSignMessageData(messageData: MessageParams): void;
 export declare function normalizeMessageData(data: string): string;
@@ -8,3 +8,5 @@ export declare function validateTypedSignMessageDataV3V4(messageData: TypedMessa
 export declare function validateEncryptionPublicKeyMessageData(messageData: EncryptionPublicKeyParams): void;
 export declare function validateDecryptedMessageData(messageData: DecryptMessageParams): void;
 export declare function parseDecryptMessageData(data: string): EthEncryptedData;
+export declare function validateAddChainData(data: AddChainMessageParams): Promise<void>;
+export declare function validateSwitchChainData(data: SwitchChainMessageParams): void;

package/dist/types/Network/createEthereumMiddleware.d.ts

@@ -1,18 +1,20 @@
 import { InPageWalletProviderState } from "@toruslabs/base-controllers";
 import { JRPCEngineEndCallback, JRPCEngineNextCallback, JRPCMiddleware, JRPCRequest, JRPCResponse } from "@toruslabs/openlogin-jrpc";
-import { BlockParams, EncryptionPublicKeyParams, EthereumTransactionMeta, MessageParams, TransactionParams, TransactionRPCMeta, TypedMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import { AddChainMessageParams, BlockParams, EncryptionPublicKeyParams, EthereumTransactionMeta, MessageParams, SwitchChainMessageParams, TransactionParams, TransactionRPCMeta, TypedMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
 export interface IProviderHandlers {
     version: string;
     requestAccounts?: (req: JRPCRequest<string[]>) => Promise<string[]>;
     getAccounts: (req: JRPCRequest<string[]>) => Promise<string[]>;
     processTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
-    processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
-    processTypedMessage?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
-    processTypedMessageV3?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
-    processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
-    processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
-    processEncryptionPublicKey?: (msgParams: EncryptionPublicKeyParams, req: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams) => Promise<string>;
-    processDecryptMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+    processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processTypedMessage?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processTypedMessageV3?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processEncryptionPublicKey?: (msgParams: EncryptionPublicKeyParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processDecryptMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processSwitchEthereumChain?: (msgParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
+    processAddEthereumChain?: (msgParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
     getPendingNonce?: (nonceParams: {
         address: string;
         blockReference: string;
@@ -31,19 +33,19 @@ export declare function createProcessTransactionMiddleware({ processTransaction,
 }): JRPCMiddleware<TransactionParams, string>;
 export declare function createProcessEthSignMessage({ processEthSignMessage, }: {
     processEthSignMessage: IProviderHandlers["processEthSignMessage"];
-}): JRPCMiddleware<MessageParams, string>;
+}): JRPCMiddleware<unknown, string>;
 export declare function createProcessTypedMessage({ processTypedMessage, }: {
     processTypedMessage: IProviderHandlers["processTypedMessage"];
-}): JRPCMiddleware<TypedMessageParams, string>;
+}): JRPCMiddleware<unknown, string>;
 export declare function createProcessTypedMessageV3({ processTypedMessageV3, }: {
     processTypedMessageV3: IProviderHandlers["processTypedMessageV3"];
-}): JRPCMiddleware<TypedMessageParams, string>;
+}): JRPCMiddleware<unknown, string>;
 export declare function createProcessTypedMessageV4({ processTypedMessageV4, }: {
     processTypedMessageV4: IProviderHandlers["processTypedMessageV4"];
-}): JRPCMiddleware<TypedMessageParams, string>;
+}): JRPCMiddleware<unknown, string>;
 export declare function createProcessPersonalMessage({ processPersonalMessage, }: {
     processPersonalMessage: IProviderHandlers["processPersonalMessage"];
-}): JRPCMiddleware<MessageParams, string>;
+}): JRPCMiddleware<unknown, string>;
 export declare function createPendingNonceMiddleware({ getPendingNonce, }: {
     getPendingNonce: IProviderHandlers["getPendingNonce"];
 }): JRPCMiddleware<{
@@ -56,10 +58,16 @@ export declare function createPendingTxMiddleware({ getPendingTransactionByHash,
 }): JRPCMiddleware<string, TransactionRPCMeta>;
 export declare function createProcessEncryptionPublicKeyMiddleware({ processEncryptionPublicKey, }: {
     processEncryptionPublicKey: IProviderHandlers["processEncryptionPublicKey"];
-}): JRPCMiddleware<EncryptionPublicKeyParams, string>;
+}): JRPCMiddleware<unknown, string>;
 export declare function createProcessDecryptMessageMiddleware({ processDecryptMessage, }: {
     processDecryptMessage: IProviderHandlers["processDecryptMessage"];
-}): JRPCMiddleware<MessageParams, string>;
+}): JRPCMiddleware<unknown, string>;
+export declare function createProcessSwitchEthereumChain({ processSwitchEthereumChain, }: {
+    processSwitchEthereumChain: IProviderHandlers["processSwitchEthereumChain"];
+}): JRPCMiddleware<unknown, string>;
+export declare function createProcessAddEthereumChain({ processAddEthereumChain, }: {
+    processAddEthereumChain: IProviderHandlers["processAddEthereumChain"];
+}): JRPCMiddleware<unknown, string>;
 export declare function createRequestAccountsMiddleware({ requestAccounts, }: {
     requestAccounts: IProviderHandlers["requestAccounts"];
 }): JRPCMiddleware<string[], unknown>;

package/dist/types/Preferences/PreferencesController.d.ts

@@ -3,7 +3,7 @@ import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
 import PollingBlockTracker from "../Block/PollingBlockTracker";
 import KeyringController from "../Keyring/KeyringController";
 import NetworkController from "../Network/NetworkController";
-import type { CustomNetworkPayload, CustomNftInfo, CustomTokenInfo, ExtendedAddressPreferences, TransactionPayload } from "../utils/interfaces";
+import type { AddChainMessageParams, CustomNetworkPayload, CustomNftInfo, CustomTokenInfo, ExtendedAddressPreferences, TransactionPayload } from "../utils/interfaces";
 interface IPreferencesControllerOptions {
     config?: Partial<PreferencesConfig> & Pick<PreferencesConfig, "api" | "commonApiHost" | "signInPrefix">;
     state?: Partial<PreferencesState<ExtendedAddressPreferences>>;
@@ -11,14 +11,16 @@ interface IPreferencesControllerOptions {
     blockTracker?: PollingBlockTracker;
     signAuthMessage?: KeyringController["signAuthMessage"];
     getProviderConfig?: NetworkController["getProviderConfig"];
+    setProviderConfig?: NetworkController["setProviderConfig"];
 }
 export default class PreferencesController extends BasePreferencesController<ExtendedAddressPreferences, PreferencesConfig, PreferencesState<ExtendedAddressPreferences>> implements IPreferencesController<ExtendedAddressPreferences, PreferencesConfig, PreferencesState<ExtendedAddressPreferences>> {
     private _handle?;
     private _mutex;
     private getProviderConfig;
+    private setProviderConfig;
     private provider;
     private blockTracker;
-    constructor({ config, state, provider, blockTracker, signAuthMessage, getProviderConfig }: IPreferencesControllerOptions);
+    constructor({ config, state, provider, blockTracker, signAuthMessage, getProviderConfig, setProviderConfig }: IPreferencesControllerOptions);
     poll(interval?: number): Promise<void>;
     initPreferences(params: {
         address: string;
@@ -44,6 +46,10 @@ export default class PreferencesController extends BasePreferencesController<Ext
     getSimpleHashNfts(address: string, chainId: string): Promise<CustomNftInfo[]>;
     getCustomTokens(address?: string): CustomToken[];
     getCustomNfts(address?: string): CustomNft[];
+    addChain(network: AddChainMessageParams): Promise<void>;
+    switchChain(data: {
+        chainId: string;
+    }): void;
     addCustomNetwork({ type, network }: {
         type: string;
         network: CustomNetworkPayload;
@@ -54,6 +60,7 @@ export default class PreferencesController extends BasePreferencesController<Ext
         id: number | null;
     }): Promise<boolean>;
     private calculatePaymentTx;
+    private getChainOptions;
     private calculatePastTx;
     private cancelTxCalculate;
 }

package/dist/types/index.d.ts

@@ -5,10 +5,12 @@ export { default as GasFeeController } from "./Gas/GasFeeController";
 export * from "./Gas/IGasFeeController";
 export { default as KeyringController } from "./Keyring/KeyringController";
 export * from "./Message/AbstractMessageController";
+export * from "./Message/AddChainController";
 export * from "./Message/DecryptMessageController";
 export * from "./Message/EncryptionPublicKeyController";
 export * from "./Message/MessageController";
 export * from "./Message/PersonalMessageController";
+export * from "./Message/SwitchChainController";
 export * from "./Message/TypedMessageController";
 export * from "./Message/utils";
 export * from "./Network/createEthereumMiddleware";

package/dist/types/utils/constants.d.ts

@@ -43,6 +43,8 @@ export declare const METHOD_TYPES: {
     readonly ETH_GET_BLOCK_BY_HASH: "eth_getBlockByHash";
     readonly ETH_GET_CODE: "eth_getCode";
     readonly ETH_GET_GAS_PRICE: "eth_gasPrice";
+    readonly SWITCH_CHAIN: "wallet_switchEthereumChain";
+    readonly ADD_CHAIN: "wallet_addEthereumChain";
 };
 export declare const TRANSACTION_ENVELOPE_TYPES: {
     readonly LEGACY: "0x0";

package/dist/types/utils/interfaces.d.ts

@@ -54,7 +54,7 @@ export interface BaseRequestParams {
     /**
      * Unique id for each request
      */
-    id: string;
+    id?: string;
     /**
      * Address to send this transaction from.
      */
@@ -89,6 +89,27 @@ export type SignTypedDataMessageV3V4 = {
     primaryType: string;
     message: unknown;
 };
+export interface SwitchChainMessageParams extends BaseRequestParams {
+    chainId: string;
+    displayName?: string;
+}
+export interface SwitchChainMessage extends AbstractMessage {
+    messageParams: SwitchChainMessageParams;
+}
+export interface AddChainMessageParams extends BaseRequestParams {
+    chainId: string;
+    chainName: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+}
+export interface AddChainMessage extends AbstractMessage {
+    messageParams: AddChainMessageParams;
+}
 export interface TypedMessageParams extends BaseRequestParams {
     data: Record<string, unknown>[] | string | SignTypedDataMessageV3V4;
     version?: SignTypedDataVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toruslabs/ethereum-controllers",
-  "version": "4.5.2",
+  "version": "4.7.0",
   "homepage": "https://github.com/torusresearch/controllers#readme",
   "license": "ISC",
   "main": "dist/ethereumControllers.cjs.js",
@@ -19,18 +19,18 @@
     "pre-commit": "lint-staged --cwd ."
   },
   "dependencies": {
-    "@ethereumjs/common": "^4.0.0",
-    "@ethereumjs/tx": "^5.0.0",
-    "@ethereumjs/util": "^9.0.0",
+    "@ethereumjs/common": "^4.1.0",
+    "@ethereumjs/tx": "^5.1.0",
+    "@ethereumjs/util": "^9.0.1",
     "@metamask/eth-sig-util": "^7.0.0",
-    "@metamask/rpc-errors": "^6.0.0",
-    "@toruslabs/base-controllers": "^4.5.2",
+    "@metamask/rpc-errors": "^6.1.0",
+    "@toruslabs/base-controllers": "^4.7.0",
     "@toruslabs/http-helpers": "^5.0.0",
-    "@toruslabs/openlogin-jrpc": "^5.1.0",
+    "@toruslabs/openlogin-jrpc": "^6.0.0",
     "async-mutex": "^0.4.0",
     "bignumber.js": "^9.1.2",
     "bn.js": "^5.2.1",
-    "ethers": "^6.7.1",
+    "ethers": "^6.8.1",
     "fast-json-patch": "^3.1.1",
     "jsonschema": "^1.4.1",
     "lodash": "^4.17.21",
@@ -64,8 +64,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b9cdf82ea7bf007ae8461e27d7213baeb4a84768",
+  "gitHead": "607fe40ee1f6c932e02e99f203f2480ad3f59ece",
   "devDependencies": {
-    "ganache": "^7.9.1"
+    "hardhat": "^2.19.0"
   }
 }

package/src/Message/AddChainController.ts

@@ -0,0 +1,73 @@
+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);
+      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);
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: AddChainMessageParams): Promise<AddChainMessageParams> {
+    return Promise.resolve(messageParams);
+  }
+}

package/src/Message/DecryptMessageController.ts

@@ -46,15 +46,12 @@ export class DecryptMessageController extends AbstractMessageController<DecryptM
     }
   }
 
-  async addNewUnapprovedMessage(
-    messageParams: DecryptMessageParams,
-    req: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams
-  ): Promise<string> {
+  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<DecryptMessageParams> & UserRequestApprovalParams) {
+  async addUnapprovedMessage(messageParams: DecryptMessageParams, req?: JRPCRequest<unknown> & UserRequestApprovalParams) {
     validateDecryptedMessageData(messageParams);
     if (req) {
       messageParams.origin = req.origin;

package/src/Message/EncryptionPublicKeyController.ts

@@ -45,18 +45,12 @@ export class EncryptionPublicKeyController extends AbstractMessageController<Enc
     }
   }
 
-  async addNewUnapprovedMessage(
-    messageParams: EncryptionPublicKeyParams,
-    req: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams
-  ): Promise<string> {
+  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<EncryptionPublicKeyParams> & UserRequestApprovalParams
-  ): Promise<string> {
+  async addUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req?: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
     validateEncryptionPublicKeyMessageData(messageParams);
     if (req) {
       messageParams.origin = req.origin;

package/src/Message/MessageController.ts

@@ -44,12 +44,12 @@ export class MessageController extends AbstractMessageController<Message, Messag
     }
   }
 
-  async addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string> {
+  async addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
     await this.addUnapprovedMessage(messageParams, req);
     return this.waitForFinishStatus(messageParams, this.name);
   }
 
-  async addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string> {
+  async addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
     validateSignMessageData(messageParams);
     if (req) {
       messageParams.origin = req.origin;

package/src/Message/PersonalMessageController.ts

@@ -44,12 +44,12 @@ export class PersonalMessageController extends AbstractMessageController<Message
     }
   }
 
-  async addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string> {
+  async addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
     await this.addUnapprovedMessage(messageParams, req);
     return this.waitForFinishStatus(messageParams, this.name);
   }
 
-  async addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string> {
+  async addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
     validateSignMessageData(messageParams);
     if (req) {
       messageParams.origin = req.origin;
@@ -64,7 +64,7 @@ export class PersonalMessageController extends AbstractMessageController<Message
       type: METHOD_TYPES.PERSONAL_SIGN,
     };
     await this.addMessage(messageData);
-    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, { messageData, req });
     return messageId;
   }
 

package/src/Message/SwitchChainController.ts

@@ -0,0 +1,74 @@
+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 { SwitchChainMessage, SwitchChainMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+import { validateSwitchChainData } from "./utils";
+
+export class SwitchChainController extends AbstractMessageController<SwitchChainMessage, SwitchChainMessageParams> {
+  override name = "SwitchChainController";
+
+  protected switchChain: PreferencesController["switchChain"];
+
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+    switchChain,
+  }: {
+    config: Partial<BaseConfig>;
+    state: Partial<MessageControllerState<SwitchChainMessage>>;
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    switchChain: PreferencesController["switchChain"];
+  }) {
+    super({ config, state, getNetworkIdentifier });
+
+    this.switchChain = switchChain;
+    this.initialize();
+  }
+
+  async processSwitchChain(messageId: string): Promise<string> {
+    try {
+      const msgObject = this.getMessage(messageId);
+      await this.approveMessage(messageId, msgObject.messageParams);
+      this.switchChain({ chainId: msgObject.messageParams.chainId });
+      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: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+
+  async addUnapprovedMessage(messageParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams): Promise<string> {
+    validateSwitchChainData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    const messageId = messageParams.id || randomId();
+    const messageData: SwitchChainMessage = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.SWITCH_CHAIN,
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, messageData);
+    return messageId;
+  }
+
+  prepMessageForSigning(messageParams: SwitchChainMessageParams): Promise<SwitchChainMessageParams> {
+    return Promise.resolve(messageParams);
+  }
+}

package/src/Message/TypedMessageController.ts

@@ -61,7 +61,7 @@ export class TypedMessageController extends AbstractMessageController<TypedMessa
 
   async addNewUnapprovedMessage(
     messageParams: TypedMessageParams,
-    req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams,
+    req: JRPCRequest<unknown> & UserRequestApprovalParams,
     version: SignTypedDataVersion
   ): Promise<string> {
     await this.addUnapprovedMessage(messageParams, req, version);
@@ -70,7 +70,7 @@ export class TypedMessageController extends AbstractMessageController<TypedMessa
 
   async addUnapprovedMessage(
     messageParams: TypedMessageParams,
-    req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams,
+    req: JRPCRequest<unknown> & UserRequestApprovalParams,
     version: SignTypedDataVersion
   ): Promise<string> {
     if (version === SignTypedDataVersion.V1) {