@toruslabs/ethereum-controllers 8.17.0 → 9.0.0

package/dist/lib.cjs/utils/viem.js

@@ -0,0 +1,214 @@
+'use strict';
+
+var viem = require('viem');
+
+// viem's serializeTransaction infers tx type via `if (transaction.type)` which is
+// falsy for type 0 (legacy). Map numeric types to string names so the check passes,
+// and strip undefined/null fields that also break viem's type inference.
+const VIEM_TX_TYPE_NAMES = {
+  0: "legacy",
+  1: "eip2930",
+  2: "eip1559",
+  3: "eip4844",
+  4: "eip7702"
+};
+const VIEM_QUANTITY_FIELDS = ["gasPrice", "maxFeePerGas", "maxPriorityFeePerGas", "maxFeePerBlobGas", "value"];
+function toViemQuantity(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return BigInt(value);
+  if (typeof value === "string" && viem.isHex(value)) return BigInt(value);
+  return undefined;
+}
+function toViemNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string" && viem.isHex(value)) return Number(value);
+  return undefined;
+}
+function toViemHex(value) {
+  if (typeof value === "string" && viem.isHex(value)) return value;
+  if (value instanceof Uint8Array) return viem.toHex(value);
+  return undefined;
+}
+function toViemAddress(value) {
+  if (typeof value === "string" && viem.isAddress(value)) return value;
+  return undefined;
+}
+function toViemHexArray(value) {
+  if (!Array.isArray(value)) return undefined;
+  const normalized = [];
+  for (const item of value) {
+    const hex = toViemHex(item);
+    if (!hex) return undefined;
+    normalized.push(hex);
+  }
+  return normalized;
+}
+function toViemAccessList(value) {
+  if (!value) return undefined;
+  const accessList = [];
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (Array.isArray(entry)) {
+        const [addressLike, storageKeysLike] = entry;
+        const address = toViemAddress(addressLike);
+        const storageKeys = toViemHexArray(storageKeysLike);
+        if (!address || !storageKeys) return undefined;
+        accessList.push({
+          address,
+          storageKeys
+        });
+        continue;
+      }
+      if (typeof entry === "object" && entry !== null) {
+        const address = toViemAddress(entry.address);
+        const storageKeys = toViemHexArray(entry.storageKeys);
+        if (!address || !storageKeys) return undefined;
+        accessList.push({
+          address,
+          storageKeys
+        });
+        continue;
+      }
+      return undefined;
+    }
+    return accessList;
+  }
+  if (typeof value === "object") {
+    for (const [addressLike, storageKeysLike] of Object.entries(value)) {
+      const address = toViemAddress(addressLike);
+      const storageKeys = toViemHexArray(storageKeysLike);
+      if (!address || !storageKeys) return undefined;
+      accessList.push({
+        address,
+        storageKeys
+      });
+    }
+    return accessList;
+  }
+  return undefined;
+}
+function toViemAuthorizationList(value) {
+  if (!value) return undefined;
+  const authorizationList = [];
+  for (const authorization of value) {
+    const address = toViemAddress(authorization.address);
+    const chainId = toViemNumber(authorization.chainId);
+    const nonce = toViemNumber(authorization.nonce);
+    if (!address || typeof chainId === "undefined" || typeof nonce === "undefined") {
+      return undefined;
+    }
+    const normalizedAuthorization = {
+      address,
+      chainId,
+      nonce
+    };
+    const signature = authorization.signature;
+    if (typeof signature === "string" && viem.isHex(signature)) {
+      const parsed = viem.parseSignature(signature);
+      normalizedAuthorization.r = parsed.r;
+      normalizedAuthorization.s = parsed.s;
+      normalizedAuthorization.yParity = parsed.yParity;
+    } else if (typeof signature === "object" && signature !== null) {
+      const r = toViemHex(signature.r);
+      const s = toViemHex(signature.s);
+      const yParity = toViemNumber(signature.yParity);
+      const vRaw = signature.v;
+      const v = typeof vRaw === "bigint" ? vRaw : typeof vRaw === "number" ? BigInt(vRaw) : typeof vRaw === "string" && viem.isHex(vRaw) ? BigInt(vRaw) : undefined;
+      if (r && s) {
+        normalizedAuthorization.r = r;
+        normalizedAuthorization.s = s;
+      }
+      if (typeof yParity !== "undefined") {
+        normalizedAuthorization.yParity = yParity;
+      }
+      if (typeof v !== "undefined") {
+        normalizedAuthorization.v = v;
+      }
+    }
+    authorizationList.push(normalizedAuthorization);
+  }
+  return authorizationList;
+}
+function toViemBlobs(value) {
+  if (!value) return undefined;
+  const blobs = [];
+  for (const blob of value) {
+    if (typeof blob === "string" || blob instanceof Uint8Array) {
+      const normalizedBlob = toViemHex(blob);
+      if (!normalizedBlob) return undefined;
+      blobs.push(normalizedBlob);
+      continue;
+    }
+    if (typeof blob === "object" && blob !== null) {
+      const normalizedBlob = toViemHex(blob.data);
+      if (!normalizedBlob) return undefined;
+      blobs.push(normalizedBlob);
+      continue;
+    }
+    return undefined;
+  }
+  return blobs;
+}
+/**
+ * Prepare transaction params for signing.
+ * @param tx - The transaction to prepare.
+ * @returns The prepared transaction.
+ */
+function prepareViemTx(tx) {
+  var _input$gas;
+  const input = tx;
+  const prepared = {};
+  const txType = typeof input.type === "number" ? VIEM_TX_TYPE_NAMES[input.type] : input.type;
+  if (typeof txType === "string") {
+    prepared.type = txType;
+  }
+  // For EIP-4844 Transactions, we want to sign the transaction payload body (tx_payload_body) without the sidecars (ie. without the network wrapper).
+  // ref: https://github.com/wevm/viem/blob/b3af510a6e2e45526e2bb10298b7fc1f178a73a3/src/accounts/utils/signTransaction.ts#L56
+  if (prepared.type === "eip4844") {
+    prepared.sidecars = false;
+  }
+  const chainId = toViemNumber(input.chainId);
+  if (typeof chainId !== "undefined") {
+    prepared.chainId = chainId;
+  }
+  const nonce = toViemNumber(input.nonce);
+  if (typeof nonce !== "undefined") {
+    prepared.nonce = nonce;
+  }
+  const gas = toViemQuantity((_input$gas = input.gas) !== null && _input$gas !== void 0 ? _input$gas : input.gasLimit);
+  if (typeof gas !== "undefined") {
+    prepared.gas = gas;
+  }
+  for (const field of VIEM_QUANTITY_FIELDS) {
+    const value = toViemQuantity(input[field]);
+    if (typeof value !== "undefined") {
+      prepared[field] = value;
+    }
+  }
+  if (typeof input.to === "string") {
+    prepared.to = input.to;
+  }
+  if (typeof input.data === "string") {
+    prepared.data = input.data;
+  }
+  const accessList = toViemAccessList(input.accessList);
+  if (accessList) {
+    prepared.accessList = accessList;
+  }
+  const authorizationList = toViemAuthorizationList(input.authorizationList);
+  if (authorizationList) {
+    prepared.authorizationList = authorizationList;
+  }
+  const blobVersionedHashes = toViemHexArray(input.blobVersionedHashes);
+  if (blobVersionedHashes) {
+    prepared.blobVersionedHashes = blobVersionedHashes;
+  }
+  const blobs = toViemBlobs(input.blobs);
+  if (blobs) {
+    prepared.blobs = blobs;
+  }
+  return prepared;
+}
+
+exports.prepareViemTx = prepareViemTx;

package/dist/lib.esm/Account/AccountTrackerController.js

@@ -2,8 +2,8 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { BaseController } from '@toruslabs/base-controllers';
 import { Mutex } from 'async-mutex';
-import { BrowserProvider, toQuantity, Contract } from 'ethers';
 import log from 'loglevel';
+import { createPublicClient, custom, toHex } from 'viem';
 import { singleBalanceCheckerAbi } from '../utils/abis.js';
 import { SINGLE_CALL_BALANCES_ADDRESSES } from '../utils/contractAddresses.js';
 
@@ -32,7 +32,7 @@ class AccountTrackerController extends BaseController {
     _defineProperty(this, "provider", void 0);
     _defineProperty(this, "blockTracker", void 0);
     _defineProperty(this, "mutex", new Mutex());
-    _defineProperty(this, "ethersProvider", void 0);
+    _defineProperty(this, "publicClient", void 0);
     _defineProperty(this, "getIdentities", void 0);
     _defineProperty(this, "getCurrentChainId", void 0);
     this.defaultState = {
@@ -41,7 +41,9 @@ class AccountTrackerController extends BaseController {
     this.initialize();
     this.provider = provider;
     this.blockTracker = blockTracker;
-    this.ethersProvider = new BrowserProvider(this.provider, "any");
+    this.publicClient = createPublicClient({
+      transport: custom(this.provider)
+    });
     this.getIdentities = getIdentities;
     this.getCurrentChainId = getCurrentChainId;
     onPreferencesStateChange(() => {
@@ -127,21 +129,27 @@ class AccountTrackerController extends BaseController {
     } = this.state;
     if (!accounts[address]) return;
     accounts[address] = {
-      balance: toQuantity(balance)
+      balance: toHex(BigInt(balance))
     };
     this.update({
       accounts
     });
   }
   async _updateAccountsViaBalanceChecker(addresses, deployedContractAddress) {
-    const ethContract = new Contract(deployedContractAddress, singleBalanceCheckerAbi, this.ethersProvider);
     try {
-      const result = await ethContract.balances(addresses, [ZERO_ADDRESS]);
+      const result = await this.publicClient.readContract({
+        address: deployedContractAddress,
+        abi: singleBalanceCheckerAbi,
+        functionName: "balances",
+        args: [addresses, [ZERO_ADDRESS]],
+        authorizationList: undefined // required when public client has no chain specified
+      });
       const {
         accounts
       } = this.state;
       addresses.forEach((address, index) => {
-        const balance = toQuantity(result[index]);
+        var _result$index;
+        const balance = toHex((_result$index = result[index]) !== null && _result$index !== void 0 ? _result$index : 0n);
         if (!accounts[address]) return;
         accounts[address] = {
           balance

package/dist/lib.esm/AccountAbstraction/AccountAbstractionController.js

@@ -1,11 +1,9 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { addHexPrefix } from '@ethereumjs/util';
 import { BaseController, TransactionStatus } from '@toruslabs/base-controllers';
 import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
-import { isHexString } from 'ethers';
 import log from 'loglevel';
-import { defineChain, createPublicClient, http, createWalletClient, custom, parseEther, toHex } from 'viem';
+import { defineChain, createPublicClient, http, createWalletClient, custom, toHex, parseEther, isHex } from 'viem';
 import { createPaymasterClient, createBundlerClient } from 'viem/account-abstraction';
 
 const eoaInterceptorMiddleware = eoaAddress => (req, res, next, end) => {
@@ -124,7 +122,7 @@ class AccountAbstractionController extends BaseController {
     });
   }
   async sendTransaction(id, tx, address) {
-    var _txParams$chainId, _txReceipt$receipt, _txReceipt$nonce, _txReceipt$receipt2, _txReceipt$receipt3, _txReceipt$receipt4;
+    var _txParams$chainId, _txReceipt$receipt, _txReceipt$nonce, _txReceipt$receipt$ga, _txReceipt$receipt2, _txReceipt$receipt$ef, _txReceipt$receipt3, _txReceipt$receipt4;
     if (address.toLowerCase() !== this.smartAccount.address.toLowerCase()) {
       throw new Error("Invalid address");
     }
@@ -164,8 +162,8 @@ class AccountAbstractionController extends BaseController {
       receipt: {
         transactionHash: (_txReceipt$receipt = txReceipt.receipt) === null || _txReceipt$receipt === void 0 ? void 0 : _txReceipt$receipt.transactionHash,
         nonce: (_txReceipt$nonce = txReceipt.nonce) === null || _txReceipt$nonce === void 0 ? void 0 : _txReceipt$nonce.toString(),
-        gasUsed: addHexPrefix((_txReceipt$receipt2 = txReceipt.receipt) === null || _txReceipt$receipt2 === void 0 || (_txReceipt$receipt2 = _txReceipt$receipt2.gasUsed) === null || _txReceipt$receipt2 === void 0 ? void 0 : _txReceipt$receipt2.toString(16)),
-        effectiveGasPrice: addHexPrefix((_txReceipt$receipt3 = txReceipt.receipt) === null || _txReceipt$receipt3 === void 0 || (_txReceipt$receipt3 = _txReceipt$receipt3.effectiveGasPrice) === null || _txReceipt$receipt3 === void 0 ? void 0 : _txReceipt$receipt3.toString(16)),
+        gasUsed: toHex((_txReceipt$receipt$ga = (_txReceipt$receipt2 = txReceipt.receipt) === null || _txReceipt$receipt2 === void 0 ? void 0 : _txReceipt$receipt2.gasUsed) !== null && _txReceipt$receipt$ga !== void 0 ? _txReceipt$receipt$ga : 0n),
+        effectiveGasPrice: toHex((_txReceipt$receipt$ef = (_txReceipt$receipt3 = txReceipt.receipt) === null || _txReceipt$receipt3 === void 0 ? void 0 : _txReceipt$receipt3.effectiveGasPrice) !== null && _txReceipt$receipt$ef !== void 0 ? _txReceipt$receipt$ef : 0n),
         type: (_txReceipt$receipt4 = txReceipt.receipt) === null || _txReceipt$receipt4 === void 0 ? void 0 : _txReceipt$receipt4.type,
         reason: txReceipt.reason
       },
@@ -278,7 +276,7 @@ class AccountAbstractionController extends BaseController {
       throw new Error("Invalid address");
     }
     return (_this$smartAccount = this.smartAccount) === null || _this$smartAccount === void 0 ? void 0 : _this$smartAccount.signMessage({
-      message: isHexString(message) ? {
+      message: isHex(message) ? {
         raw: message
       } : message
     });

package/dist/lib.esm/Eip5792/walletGetCallsStatus.js

@@ -1,7 +1,7 @@
-import { addHexPrefix } from '@ethereumjs/util';
 import { TransactionStatus } from '@toruslabs/base-controllers';
 import { rpcErrors, JsonRpcError } from '@web3auth/auth';
 import { GetCallsStatusCode, EIP_5792_METHODS, EIP5792ErrorCode } from '../utils/eip5792Types.js';
+import { addHexPrefix } from '../utils/hex.js';
 
 /**
  * Maps a TransactionStatus to an EIP-5792 GetCallsStatusCode.

package/dist/lib.esm/Eip5792/walletSendCalls.js

@@ -1,9 +1,8 @@
-import { isValidAddress } from '@ethereumjs/util';
 import { rpcErrors } from '@web3auth/auth';
-import { isHexString } from 'ethers';
 import { v4, parse } from 'uuid';
+import { isHex, isAddress } from 'viem';
 import { getIsEip7702UpgradeSupported } from '../Eip7702/eip7702Utils.js';
-import { SUPPORTED_EIP_5792_VERSIONS, EIP_5792_METHODS } from '../utils/eip5792Types.js';
+import { EIP_5792_METHODS } from '../utils/eip5792Types.js';
 
 /**
  * Generates a unique batch ID for EIP-5792 calls.
@@ -23,20 +22,20 @@ function generateBatchId() {
  */
 function validateCall(call, index) {
   // Validate 'to' address
-  if (!call.to || !isHexString(call.to) || !isValidAddress(call.to)) {
+  if (!call.to || !isHex(call.to) || !isAddress(call.to)) {
     throw rpcErrors.invalidParams(`Invalid 'to' address in call at index ${index}`);
   }
 
   // Validate 'value' if present
   if (call.value !== undefined) {
-    if (!isHexString(call.value)) {
+    if (!isHex(call.value)) {
       throw rpcErrors.invalidParams(`Invalid 'value' in call at index ${index}: must be a valid non-negative hex string`);
     }
   }
 
   // Validate 'data' if present
   if (call.data !== undefined) {
-    if (!isHexString(call.data)) {
+    if (!isHex(call.data)) {
       throw rpcErrors.invalidParams(`Invalid 'data' in call at index ${index}: must be a valid hex string`);
     }
   }
@@ -53,12 +52,12 @@ function validateSendCallsParams(sendCallsParams) {
   }
 
   // Validate version format
-  if (!sendCallsParams.version || !SUPPORTED_EIP_5792_VERSIONS.includes(sendCallsParams.version)) {
-    throw rpcErrors.invalidParams(`Invalid version: expected one of ${SUPPORTED_EIP_5792_VERSIONS.join(", ")}, got "${sendCallsParams.version || "undefined"}"`);
+  if (!sendCallsParams.version || typeof sendCallsParams.version !== "string") {
+    throw rpcErrors.invalidParams(`Invalid version: expected a string, got "${sendCallsParams.version || "undefined"}"`);
   }
 
   // Validate chainId format
-  if (!sendCallsParams.chainId || !isHexString(sendCallsParams.chainId)) {
+  if (!sendCallsParams.chainId || !isHex(sendCallsParams.chainId)) {
     throw rpcErrors.invalidParams("Invalid chainId: must be a valid hex string");
   }
 
@@ -66,7 +65,7 @@ function validateSendCallsParams(sendCallsParams) {
   if (!sendCallsParams.from) {
     throw rpcErrors.invalidParams("Missing 'from' address");
   }
-  if (!isHexString(sendCallsParams.from) || !isValidAddress(sendCallsParams.from)) {
+  if (!isHex(sendCallsParams.from) || !isAddress(sendCallsParams.from)) {
     throw rpcErrors.invalidParams("Invalid 'from' address: must be a valid hex address");
   }
 

package/dist/lib.esm/Eip7702/eip7702Utils.js

@@ -1,8 +1,8 @@
-import { addHexPrefix } from '@ethereumjs/util';
 import { zeroAddress, encodeAbiParameters, parseAbiParameters, encodeFunctionData } from 'viem';
 import { erc7821Abi } from '../utils/abis.js';
 import { SUPPORTED_NETWORKS } from '../utils/constants.js';
 import { EIP_7702_PREFIX } from '../utils/eip7702Types.js';
+import { addHexPrefix } from '../utils/hex.js';
 
 /**
  * The MetaMask EIP-7702 Stateless Delegator contract address.

package/dist/lib.esm/Gas/GasFeeController.js

@@ -1,8 +1,9 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { isHexString, addHexPrefix } from '@ethereumjs/util';
 import { BaseController, PollingManager, cloneDeep } from '@toruslabs/base-controllers';
 import log from 'loglevel';
+import { isHex } from 'viem';
 import { GAS_ESTIMATE_TYPES } from '../utils/constants.js';
+import { addHexPrefix } from '../utils/hex.js';
 import { fetchGasEstimates, fetchEthGasPriceEstimate, fetchLegacyGasPriceEstimates, fetchGasEstimatesViaEthFeeHistory, calculateTimeEstimate } from './gasUtil.js';
 
 const GAS_FEE_API = "https://mock-gas-server.herokuapp.com/";
@@ -119,7 +120,7 @@ class GasFeeController extends BaseController {
     const chainId = this.getNetworkIdentifier();
     if (chainId === "loading") return;
     let chainIdInt;
-    if (typeof chainId === "string" && isHexString(addHexPrefix(chainId))) {
+    if (typeof chainId === "string" && isHex(addHexPrefix(chainId))) {
       chainIdInt = Number.parseInt(chainId, 16);
     }
     try {

package/dist/lib.esm/Keyring/KeyringController.js

@@ -1,8 +1,10 @@
-import { encode } from '@ethereumjs/rlp';
-import { addHexPrefix, bytesToHex, privateToPublic, toChecksumAddress, privateToAddress, stripHexPrefix, bigIntToBytes, isHexString } from '@ethereumjs/util';
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { BaseKeyringController, ecsignature, concatSig } from '@toruslabs/base-controllers';
-import { SigningKey, concat, keccak256, hashMessage, TypedDataEncoder } from 'ethers';
-import { toHex } from 'viem';
+import { hexToBytes } from '@toruslabs/metadata-helpers';
+import { serializeTransaction, keccak256, parseSignature, toHex, isHex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { addHexPrefix, stripHexPrefix } from '../utils/hex.js';
+import { prepareViemTx } from '../utils/viem.js';
 
 class KeyringController extends BaseKeyringController {
   constructor({
@@ -20,49 +22,55 @@ class KeyringController extends BaseKeyringController {
   }
   async signTransaction(tx, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(addHexPrefix(wallet.privateKey));
     const localTx = tx;
-    localTx.signature = privKey.sign(localTx.unsignedHash);
-    return localTx;
+    const txToSign = prepareViemTx(localTx);
+    // NOTE: don't use account.signTransaction directly because it only return signed serialized transaction
+    // we don't want to compute unsigned hash and signature again
+    const serializedUnsigned = serializeTransaction(txToSign);
+    const unsignedHash = keccak256(serializedUnsigned);
+    const rawSig = await account.sign({
+      hash: unsignedHash
+    });
+    const signature = parseSignature(rawSig);
+    const serialized = serializeTransaction(txToSign, signature);
+    return _objectSpread(_objectSpread({}, txToSign), {}, {
+      unsignedHash,
+      serialized,
+      signature
+    });
   }
   async signEip7702Authorization(authorization, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(addHexPrefix(wallet.privateKey));
 
     // Convert hex strings to proper types for RLP encoding
     // EIP-7702 authorization tuple: [chain_id_decimal, address, nonce_decimal]
     const chainIdDecimal = parseInt(authorization.chainId, 16);
     const nonceDecimal = parseInt(authorization.nonce, 16);
-
-    // RLP encode the eip7702 authorization
-    const encodedAuthorization = encode([chainIdDecimal, authorization.address, nonceDecimal]);
-    // Prefixed with EIP7702 Domain Separator (0x05)
-    const prefixedAuthorization = concat(["0x05", encodedAuthorization]);
-    const authorizationHash = keccak256(prefixedAuthorization);
-    const {
-      r,
-      s,
-      v
-    } = privKey.sign(authorizationHash);
-    const signedAuthorization = {
+    const signedAuthorization = await account.signAuthorization({
+      contractAddress: authorization.address,
+      chainId: chainIdDecimal,
+      nonce: nonceDecimal
+    });
+    return {
       address: authorization.address,
       chainId: authorization.chainId,
       nonce: authorization.nonce,
-      r: addHexPrefix(r),
-      s: addHexPrefix(s),
-      yParity: toHex(v - 27 === 0 ? 0 : 1)
+      r: signedAuthorization.r,
+      s: signedAuthorization.s,
+      yParity: toHex(signedAuthorization.yParity)
     };
-    return signedAuthorization;
   }
   getAccounts() {
     return this.state.wallets.map(w => w.publicKey);
   }
-  importAccount(accountPrivateKey) {
+  async importAccount(accountPrivateKey) {
     try {
       const hexPrivateKey = accountPrivateKey.padStart(64, "0");
-      const bufferPrivKey = Buffer.from(hexPrivateKey, "hex");
-      const publicKey = bytesToHex(privateToPublic(bufferPrivKey));
-      const address = toChecksumAddress(bytesToHex(privateToAddress(bufferPrivKey)));
+      const account = privateKeyToAccount(addHexPrefix(hexPrivateKey));
+      const publicKey = account.publicKey;
+      const address = account.address;
       const existingWallet = this.state.wallets.find(w => w.address === address);
       if (existingWallet) return existingWallet.address;
       this.update({
@@ -90,37 +98,57 @@ class KeyringController extends BaseKeyringController {
       });
     }
   }
-  getBufferPrivateKey(privateKey) {
+  getPrivateKeyBytes(privateKey) {
     const stripped = stripHexPrefix(privateKey);
-    return Buffer.from(stripped, "hex");
+    return hexToBytes(stripped);
   }
 
   // For eth_sign, we need to sign arbitrary data:
   async signMessage(data, address) {
+    if (typeof data !== "string") {
+      throw new Error("Torus Keyring - signMessage data must be type 'string'");
+    }
     const wallet = this._getWalletForAccount(address);
-    const privKey = this.getBufferPrivateKey(wallet.privateKey);
-    const messageSig = ecsignature(Buffer.from(stripHexPrefix(data), "hex"), privKey);
-    const sig = concatSig(Buffer.from(bigIntToBytes(messageSig.v)), Buffer.from(messageSig.r), Buffer.from(messageSig.s));
+    const privKey = this.getPrivateKeyBytes(wallet.privateKey);
+    const payload = hexToBytes(stripHexPrefix(data));
+    const messageSig = ecsignature(payload, privKey);
+    const sig = concatSig(messageSig.v, messageSig.r, messageSig.s);
     return sig;
   }
   async signPersonalMessage(data, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(addHexPrefix(wallet.privateKey));
     // we need to check if the data is hex or not
     // For historical reasons, you must submit the message to sign in hex-encoded UTF-8.
     // https://docs.metamask.io/wallet/how-to/sign-data/#use-personal_sign
-    const message = isHexString(data) ? Buffer.from(stripHexPrefix(data), "hex") : Buffer.from(data);
-    const signature = privKey.sign(hashMessage(message)).serialized;
-    return signature;
+    const message = isHex(data) ? {
+      raw: data
+    } : data;
+    return account.signMessage({
+      message
+    });
   }
 
   // personal_signTypedData, signs data along with the schema
   async signTypedData(typedData, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(addHexPrefix(wallet.privateKey));
     delete typedData.types.EIP712Domain;
-    const signature = privKey.sign(TypedDataEncoder.hash(typedData.domain, typedData.types, typedData.message)).serialized;
-    return signature;
+    const primaryType = typedData.primaryType;
+    if (!primaryType) {
+      throw new Error("Torus Keyring - primaryType is required");
+    }
+    const rawSig = await account.signTypedData({
+      domain: _objectSpread(_objectSpread({}, typedData.domain), {}, {
+        chainId: typeof typedData.domain.chainId === "string" ? parseInt(typedData.domain.chainId, 16) : typedData.domain.chainId,
+        salt: typedData.domain.salt,
+        verifyingContract: typedData.domain.verifyingContract
+      }),
+      types: typedData.types,
+      primaryType,
+      message: typedData.message
+    });
+    return rawSig;
   }
   _getWalletForAccount(account) {
     const address = account.toLowerCase();

package/dist/lib.esm/Message/utils.js

@@ -1,10 +1,11 @@
-import { isValidAddress, stripHexPrefix, addHexPrefix, bytesToHex } from '@ethereumjs/util';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { isHexString, JsonRpcProvider, toQuantity } from 'ethers';
+import { bytesToHex, utf8ToBytes } from '@toruslabs/metadata-helpers';
+import { isHex, createPublicClient, http, toHex, isAddress } from 'viem';
+import { stripHexPrefix, addHexPrefix } from '../utils/hex.js';
 
 const hexRe = /^[0-9A-Fa-f]+$/gu;
 function validateAddress(address, propertyName) {
-  if (!address || typeof address !== "string" || !isValidAddress(address)) {
+  if (!address || typeof address !== "string" || !isAddress(address)) {
     throw new Error(`Invalid "${propertyName}" address: ${address} must be a valid string.`);
   }
 }
@@ -27,7 +28,7 @@ function normalizeMessageData(data) {
   } catch {
     // do nothing
   }
-  return bytesToHex(Buffer.from(data, "utf8"));
+  return addHexPrefix(bytesToHex(utf8ToBytes(data)));
 }
 async function validateTypedSignMessageDataV4(messageData, currentChainId) {
   validateAddress(messageData.from, "from");
@@ -72,7 +73,7 @@ async function validateAddChainData(data) {
   if (!chainId) {
     throw new Error("Invalid add chain params: please pass chainId in params");
   }
-  if (!isHexString(chainId)) {
+  if (!isHex(chainId)) {
     throw new Error("Invalid add chain params: please pass a valid hex chainId in params, for: ex: 0x1");
   }
   if (!rpcUrls || rpcUrls.length === 0) throw new Error("params.rpcUrls not provided");
@@ -85,12 +86,12 @@ async function validateAddChainData(data) {
   if (!name) throw new Error("params.nativeCurrency.name not provided");
   if (!symbol) throw new Error("params.nativeCurrency.symbol not provided");
   if (decimals === undefined) throw new Error("params.nativeCurrency.decimals not provided");
-  const _web3 = new JsonRpcProvider(rpcUrls[0], "any");
-  const {
-    chainId: networkChainID
-  } = await _web3.getNetwork();
-  if (Number.parseInt(networkChainID.toString()) !== Number.parseInt(chainId, 16)) {
-    throw new Error(`Provided rpc url's chainId version is not matching with provided chainId, expected: ${toQuantity(networkChainID)}, received: ${chainId}`);
+  const client = createPublicClient({
+    transport: http(rpcUrls[0])
+  });
+  const networkChainID = await client.getChainId();
+  if (networkChainID !== Number.parseInt(chainId, 16)) {
+    throw new Error(`Provided rpc url's chainId version is not matching with provided chainId, expected: ${toHex(networkChainID)}, received: ${chainId}`);
   }
 }
 function validateSwitchChainData(data) {
@@ -100,7 +101,7 @@ function validateSwitchChainData(data) {
   if (!fullChainId) {
     throw new Error("Invalid switch chain params: please pass chainId in params");
   }
-  if (!isHexString(fullChainId)) {
+  if (!isHex(fullChainId)) {
     const [namespace, chainId] = fullChainId.split(":");
     if (namespace !== CHAIN_NAMESPACES.SOLANA && namespace !== CHAIN_NAMESPACES.EIP155) {
       throw new Error("Invalid switch chain params: invalid namespace");

package/dist/lib.esm/Network/createEthereumMiddleware.js

@@ -1,5 +1,5 @@
-import { PROVIDER_JRPC_METHODS, createFetchMiddleware, createGenericJRPCMiddleware } from '@toruslabs/base-controllers';
-import { createAsyncMiddleware, mergeMiddleware, createScaffoldMiddleware } from '@web3auth/auth';
+import { createFetchMiddleware, PROVIDER_JRPC_METHODS, createGenericJRPCMiddleware } from '@toruslabs/base-controllers';
+import { mergeMiddleware, createScaffoldMiddleware, createAsyncMiddleware } from '@web3auth/auth';
 import { walletGetUpgradeStatus } from '../Eip7702/walletGetUpgradeStatus.js';
 import { walletUpgradeAccount } from '../Eip7702/walletUpgradeAccount.js';
 import { METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES, BUNDLER_METHOD_TYPES, PAYMASTER_METHOD_TYPES } from '../utils/constants.js';