refactor: remove use of web3-eth-accounts (#12370)

Author: Jack-Works

eslint.config.js

@@ -21,7 +21,6 @@ const deferPackages = [
     '@metamask/eth-sig-util',
     '@masknet/gun-utils',
     'web3-eth',
-    'web3-eth-accounts',
     'twitter-text',
     'web3-utils',
     '@solana/web3.js',

packages/mask/background/services/identity/persona/sign.ts

@@ -5,53 +5,50 @@ import {
     fromBase64URL,
     PopupRoutes,
     type ECKeyIdentifier,
-    type SignType,
     MaskMessages,
+    type SignMessage,
 } from '@masknet/shared-base'
 import { queryPersonasWithPrivateKey } from '../../../database/persona/web.js'
 import { openPopupWindow } from '../../helper/popup-opener.js'
 
+async function getIdentifier(message: unknown, identifier?: ECKeyIdentifier, source?: string, silent = false) {
+    if (!identifier || !silent) {
+        const requestID = crypto.randomUUID()
+        await openPopupWindow(PopupRoutes.PersonaSignRequest, {
+            message: JSON.stringify(message),
+            requestID,
+            identifier: identifier?.toText(),
+            source,
+        })
+
+        return timeout(
+            new Promise<PersonaIdentifier>((resolve, reject) => {
+                MaskMessages.events.personaSignRequest.on((approval) => {
+                    if (approval.requestID !== requestID) return
+                    if (!approval.selectedPersona) reject(new Error('The user refused to sign message with persona.'))
+                    resolve(approval.selectedPersona!)
+                })
+            }),
+            60 * 1000,
+            'Timeout of signing with persona.',
+        )
+    }
+    return identifier
+}
 /**
  * Generate a signature w or w/o confirmation from user
  */
 export async function signWithPersona(
-    type: SignType,
-    message: unknown,
+    message: SignMessage,
     identifier?: ECKeyIdentifier,
-    source?: string,
+    origin?: string,
     silent = false,
 ): Promise<string> {
-    const getIdentifier = async () => {
-        if (!identifier || !silent) {
-            const requestID = crypto.randomUUID()
-            await openPopupWindow(PopupRoutes.PersonaSignRequest, {
-                message: JSON.stringify(message),
-                requestID,
-                identifier: identifier?.toText(),
-                source,
-            })
-
-            return timeout(
-                new Promise<PersonaIdentifier>((resolve, reject) => {
-                    MaskMessages.events.personaSignRequest.on((approval) => {
-                        if (approval.requestID !== requestID) return
-                        if (!approval.selectedPersona)
-                            reject(new Error('The user refused to sign message with persona.'))
-                        resolve(approval.selectedPersona!)
-                    })
-                }),
-                60 * 1000,
-                'Timeout of signing with persona.',
-            )
-        }
-        return identifier
-    }
-
-    const identifier_ = await getIdentifier()
+    identifier = await getIdentifier(message.data, identifier, origin, silent)
 
     // find the persona with the signer's identifier
-    const persona = (await queryPersonasWithPrivateKey()).find((x) => x.identifier === identifier_)
+    const persona = (await queryPersonasWithPrivateKey()).find((x) => x.identifier === identifier)
     if (!persona?.privateKey.d) throw new Error('Persona not found')
 
-    return Signer.sign(type, Buffer.from(fromBase64URL(persona.privateKey.d)), message)
+    return Signer.sign(message, Buffer.from(fromBase64URL(persona.privateKey.d)))
 }

packages/mask/background/services/wallet/services/send.ts

@@ -1,5 +1,5 @@
 import type { JsonRpcRequest } from 'web3-types'
-import { ECKeyIdentifier, type SignType } from '@masknet/shared-base'
+import { ECKeyIdentifier, SignType } from '@masknet/shared-base'
 import { EVMRequestReadonly, EVMWeb3Readonly } from '@masknet/web3-providers'
 import {
     ChainId,
@@ -8,10 +8,10 @@ import {
     EthereumMethodType,
     PayloadEditor,
     type TransactionOptions,
-    Signer,
 } from '@masknet/web3-shared-evm'
 import { signWithWallet } from './wallet/index.js'
 import { signWithPersona } from '../../identity/persona/sign.js'
+import type { TransactionSerializable } from 'viem'
 
 /**
  * The entrance of all RPC requests to MaskWallet.
@@ -23,25 +23,35 @@ export async function send(payload: JsonRpcRequest, options?: TransactionOptions
         from,
         chainId = options?.chainId ?? ChainId.Mainnet,
         signableMessage,
-        signableConfig,
+        signableTransaction,
     } = PayloadEditor.fromPayload(payload, options)
     const identifier = ECKeyIdentifier.from(options?.identifier).unwrapOr(undefined)
-    const signer =
-        identifier ?
-            new Signer(identifier, <T>(type: SignType, message: T, identifier?: ECKeyIdentifier) =>
-                signWithPersona(type, message, identifier, undefined, true),
-            )
-        :   new Signer(owner || from!, signWithWallet)
+    const signTransaction = async (transaction: TransactionSerializable) => {
+        const message = { type: SignType.Transaction as const, data: transaction }
+        if (identifier) {
+            return signWithPersona(message, identifier)
+        } else {
+            return signWithWallet(message, owner || from!)
+        }
+    }
+    const signMessageOrTypedData = async (type: SignType.Message | SignType.TypedData, message: string) => {
+        const msg = { type, data: message }
+        if (identifier) {
+            return signWithPersona(msg, identifier)
+        } else {
+            return signWithWallet(msg, owner || from!)
+        }
+    }
 
     switch (payload.method) {
         case EthereumMethodType.eth_sendTransaction:
         case EthereumMethodType.MASK_REPLACE_TRANSACTION:
-            if (!signableConfig) throw new Error('No transaction to be sent.')
+            if (!signableTransaction) throw new Error('No transaction to be sent.')
 
             try {
                 return createJsonRpcResponse(
                     pid,
-                    await EVMWeb3Readonly.sendSignedTransaction(await signer.signTransaction(signableConfig), {
+                    await EVMWeb3Readonly.sendSignedTransaction(await signTransaction(signableTransaction), {
                         chainId,
                         providerURL,
                     }),
@@ -53,21 +63,21 @@ export async function send(payload: JsonRpcRequest, options?: TransactionOptions
         case EthereumMethodType.personal_sign:
             try {
                 if (!signableMessage) throw new Error('No message to be signed.')
-                return createJsonRpcResponse(pid, await signer.signMessage(signableMessage))
+                return createJsonRpcResponse(pid, await signMessageOrTypedData(SignType.Message, signableMessage))
             } catch (error) {
                 throw ErrorEditor.from(error, null, 'Failed to sign message.').error
             }
         case EthereumMethodType.eth_signTypedData_v4:
             try {
                 if (!signableMessage) throw new Error('No typed data to be signed.')
-                return createJsonRpcResponse(pid, await signer.signTypedData(signableMessage))
+                return createJsonRpcResponse(pid, await signMessageOrTypedData(SignType.TypedData, signableMessage))
             } catch (error) {
                 throw ErrorEditor.from(error, null, 'Failed to sign typed data.').error
             }
         case EthereumMethodType.eth_signTransaction:
             try {
-                if (!signableConfig) throw new Error('No transaction to be signed.')
-                return createJsonRpcResponse(pid, await signer.signTransaction(signableConfig))
+                if (!signableTransaction) throw new Error('No transaction to be signed.')
+                return createJsonRpcResponse(pid, await signTransaction(signableTransaction))
             } catch (error) {
                 throw ErrorEditor.from(error, null, 'Failed to sign transaction.').error
             }

packages/mask/background/services/wallet/services/wallet/index.ts

@@ -4,7 +4,7 @@ import defer * as web3_utils from 'web3-utils'
 import { toBytes } from '@ethereumjs/util'
 import { api } from '@dimensiondev/mask-wallet-core/proto'
 import { Signer } from '@masknet/web3-providers'
-import { ImportSource, type SignType, type Wallet } from '@masknet/shared-base'
+import { ImportSource, type SignMessage, type Wallet } from '@masknet/shared-base'
 import { HD_PATH_WITHOUT_INDEX_ETHEREUM } from '@masknet/web3-shared-base'
 import * as Mask from '../maskwallet/index.js'
 import * as database from './database/index.js'
@@ -249,8 +249,8 @@ export async function resetAllWallets() {
     await database.resetAllWallets()
 }
 
-export async function signWithWallet<T>(type: SignType, message: T, address: string) {
-    return Signer.sign(type, Buffer.from(toBytes(`0x${await exportPrivateKey(address)}`)), message)
+export async function signWithWallet(message: SignMessage, address: string) {
+    return Signer.sign(message, Buffer.from(toBytes(`0x${await exportPrivateKey(address)}`)))
 }
 
 export async function exportMnemonicWords(address: string, unverifiedPassword?: string) {

packages/mask/popups/components/ConnectedWallet/index.tsx

@@ -117,8 +117,7 @@ export const ConnectedWallet = memo(function ConnectedWallet() {
             if (!result) return
 
             const signature = await Services.Identity.signWithPersona(
-                SignType.Message,
-                result.signPayload,
+                { type: SignType.Message, data: result.signPayload },
                 persona.identifier,
                 location.origin,
                 true,

packages/mask/popups/pages/Personas/AccountDetail/index.tsx

@@ -77,8 +77,7 @@ export const Component = memo(() => {
             if (!result) return
 
             const signature = await Service.Identity.signWithPersona(
-                SignType.Message,
-                result.signPayload,
+                { type: SignType.Message, data: result.signPayload },
                 currentPersona.identifier,
                 location.origin,
                 true,

packages/mask/popups/pages/Personas/ConnectWallet/index.tsx

@@ -172,8 +172,7 @@ export const Component = memo(function ConnectWalletPage() {
 
             if (!payload) return
             const personaSignature = await Services.Identity.signWithPersona(
-                SignType.Message,
-                payload.signPayload,
+                { type: SignType.Message, data: payload.signPayload },
                 currentPersona.identifier,
                 location.origin,
                 true,

packages/mask/popups/pages/Personas/PersonaAvatarSetting/index.tsx

@@ -132,8 +132,7 @@ const PersonaAvatarSetting = memo(function PersonaAvatar() {
                 // Verify Wallet sign with persona
                 if (bindingWallets.some((x) => isSameAddress(x.identity, account))) {
                     sign = await Services.Identity.signWithPersona(
-                        SignType.Message,
-                        JSON.stringify(data),
+                        { type: SignType.Message, data: JSON.stringify(data) },
                         currentPersona.identifier,
                         location.origin,
                         true,

packages/mask/popups/pages/Personas/PersonaSignRequest/index.tsx

@@ -60,8 +60,7 @@ export const Component = memo(function PersonaSignRequest() {
             case MethodAfterPersonaSign.DISCONNECT_NEXT_ID:
                 if (!message) break
                 const signature = await Services.Identity.signWithPersona(
-                    SignType.Message,
-                    message,
+                    { type: SignType.Message, data: message },
                     selectedPersona,
                     location.origin,
                     true,

packages/mask/shared-ui/initUIContext.ts

@@ -40,7 +40,7 @@ export function setupUIContext() {
         queryPersonaByProfile: Services.Identity.queryPersonaByProfile,
         openDashboard: Services.Helper.openDashboard,
         openPopupWindow,
-        signWithPersona: (a, b, c, d) => Services.Identity.signWithPersona(a, b, c, location.origin, d),
+        signWithPersona: (a, b, c) => Services.Identity.signWithPersona(a, b, location.origin, c),
         hasPaymentPassword: Services.Wallet.hasPassword,
         createPersona: () => Services.Helper.openDashboard(DashboardRoutes.SignUpPersona),
         attachProfile: Services.Identity.attachProfile,