@toruslabs/ethereum-controllers 8.17.0 → 9.0.0

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

@@ -8,7 +8,6 @@ const EIP_5792_METHODS = {
   WALLET_GET_CALLS_STATUS: "wallet_getCallsStatus",
   WALLET_SHOW_CALLS_STATUS: "wallet_showCallsStatus"
 };
-const SUPPORTED_EIP_5792_VERSIONS = ["1.0", "2.0"];
 
 // ============================================================================
 // EIP-5792 Types
@@ -102,4 +101,4 @@ const Eip5792AtomicStatus = {
  * Currently only atomic batches are supported via EIP-7702.
  */
 
-export { EIP5792ErrorCode, EIP_5792_METHODS, Eip5792AtomicStatus, GetCallsStatusCode, SUPPORTED_EIP_5792_VERSIONS };
+export { EIP5792ErrorCode, EIP_5792_METHODS, Eip5792AtomicStatus, GetCallsStatusCode };

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

@@ -1,10 +1,11 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { addHexPrefix, stripHexPrefix, isValidAddress, toChecksumAddress } from '@ethereumjs/util';
-import { formatSmallNumbers, significantDigits, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, addressSlicer, TransactionStatus } from '@toruslabs/base-controllers';
+import { TransactionStatus, formatSmallNumbers, significantDigits, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, addressSlicer } from '@toruslabs/base-controllers';
 import { BigNumber } from 'bignumber.js';
 import log from 'loglevel';
+import { toHex, isAddress, getAddress } from 'viem';
 import { determineTransactionType } from '../Transaction/TransactionUtils.js';
-import { SUPPORTED_NETWORKS, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ERC1155, CONTRACT_TYPE_ERC20, METHOD_TYPES, MAINNET_CHAIN_ID, TEST_CHAINS, CONTRACT_TYPE_ETH } from './constants.js';
+import { SUPPORTED_NETWORKS, CONTRACT_TYPE_ERC1155, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ERC20, MAINNET_CHAIN_ID, TEST_CHAINS, METHOD_TYPES, CONTRACT_TYPE_ETH } from './constants.js';
+import { addHexPrefix, stripHexPrefix } from './hex.js';
 
 function hexToBn(hex) {
   return new BigNumber(stripHexPrefix(hex), 16);
@@ -93,18 +94,18 @@ function formatTime(time) {
 }
 function isAddressByChainId(address, _chainId) {
   // TOOD: add rsk network checks.
-  return isValidAddress(address);
+  return isAddress(address);
 }
 function toChecksumAddressByChainId(address, chainId) {
   // TOOD: add rsk network checks.
   if (!isAddressByChainId(address)) return address;
-  return toChecksumAddress(address);
+  return getAddress(address);
 }
 const GAS_LIMITS = {
   // maximum gasLimit of a simple send
-  SIMPLE: addHexPrefix(21000 .toString(16)),
+  SIMPLE: toHex(21000),
   // a base estimate for token transfers.
-  BASE_TOKEN_ESTIMATE: addHexPrefix(100000 .toString(16))
+  BASE_TOKEN_ESTIMATE: toHex(100000)
 };
 function bnLessThan(a, b) {
   if (a === null || a === undefined || b === null || b === undefined) {

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

@@ -0,0 +1,21 @@
+import { isHex } from 'viem';
+
+/**
+ * Removes '0x' from a given `String` if present
+ */
+const stripHexPrefix = str => {
+  if (typeof str !== "string") throw new Error(`[stripHexPrefix] input must be type 'string', received ${typeof str}`);
+  return isHex(str) ? str.slice(2) : str;
+};
+
+/**
+ * Adds "0x" to a given `string` if it does not already start with "0x".
+ */
+const addHexPrefix = str => {
+  if (typeof str !== "string") {
+    return str;
+  }
+  return isHex(str) ? str : `0x${str}`;
+};
+
+export { addHexPrefix, stripHexPrefix };

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

@@ -25,4 +25,68 @@ const TRANSACTION_CATEGORY_EIP7702 = {
  * Type Def for function to query the deployment bytecode of an address. (eth_getCode)
  */
 
+/**
+ *  A [[HexString]] whose length is even, which ensures it is a valid
+ *  representation of binary data.
+ */
+
+/**
+ *  An object that can be used to represent binary data.
+ */
+
+/**
+ *  A BLOb object that can be passed for [[link-eip-4844]]
+ *  transactions.
+ *
+ *  It may have had its commitment and proof already provided
+ *  or rely on an attached [[KzgLibrary]] to compute them.
+ */
+
+/**
+ *  A KZG Library with the necessary functions to compute
+ *  BLOb commitments and proofs.
+ */
+
+/**
+ *  A KZG Library with any of the various API configurations.
+ *  As the library is still experimental and the API is not
+ *  stable, depending on the version used the method names and
+ *  signatures are still in flux.
+ *
+ *  This allows any of the versions to be passed into Transaction
+ *  while providing a stable external API.
+ */
+
+/**
+ *  Any type that can be used where a numeric value is needed.
+ */
+
+/**
+ *  Any type that can be used where a big number is needed.
+ */
+
+/**
+ *  A SignatureLike
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+
+/**
+ *  A **TransactionLike** is an object which is appropriate as a loose
+ *  input for many operations which will populate missing properties of
+ *  a transaction.
+ */
+
+/**
+ *  A single [[AccessList]] entry of storage keys (slots) for an address.
+ */
+
+/**
+ *  An ordered collection of [[AccessList]] entries.
+ */
+
+/**
+ *  Any ethers-supported access list structure.
+ */
+
 export { TRANSACTION_CATEGORY_EIP7702 };

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

@@ -1,27 +1,23 @@
-import { createCustomCommon, Mainnet } from '@ethereumjs/common';
-import { createTxFromRLP } from '@ethereumjs/tx';
-import { hexToBytes, addHexPrefix, bytesToHex } from '@ethereumjs/util';
 import log from 'loglevel';
+import { recoverTransactionAddress, keccak256 } from 'viem';
 import { METHOD_TYPES } from './constants.js';
+import { addHexPrefix } from './hex.js';
 
 /**
  * Transaction decoder for analytics.
  * Decodes eth_sendRawTransaction and eth_sendUserOperation requests.
  */
-const transactionDecoder = (req, chainId) => {
+const transactionDecoder = async (req, chainId) => {
   let sender = "";
   let txHash = "";
   try {
     if (req.method === METHOD_TYPES.ETH_SEND_RAW_TRANSACTION) {
       const rawTx = req.params[0];
-      const txBytes = hexToBytes(addHexPrefix(rawTx));
-      const tx = createTxFromRLP(txBytes, {
-        common: createCustomCommon({
-          chainId
-        }, Mainnet)
+      const normalizedRawTx = addHexPrefix(rawTx);
+      sender = await recoverTransactionAddress({
+        serializedTransaction: normalizedRawTx
       });
-      sender = tx.getSenderAddress().toString();
-      txHash = bytesToHex(tx.hash());
+      txHash = keccak256(normalizedRawTx);
     } else if (req.method === METHOD_TYPES.ETH_SEND_USER_OPERATION) {
       const userOpReq = req;
       sender = userOpReq.params.map(p => p.sender).join(",");

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

@@ -0,0 +1,214 @@
+import { isHex, parseSignature, isAddress, toHex } from '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" && 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" && isHex(value)) return Number(value);
+  return undefined;
+}
+function toViemHex(value) {
+  if (typeof value === "string" && isHex(value)) return value;
+  if (value instanceof Uint8Array) return toHex(value);
+  return undefined;
+}
+function toViemAddress(value) {
+  if (typeof value === "string" && 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" && isHex(signature)) {
+      const parsed = 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" && 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;
+}
+
+export { prepareViemTx };

package/package.json

@@ -1,38 +1,34 @@
 {
   "name": "@toruslabs/ethereum-controllers",
-  "version": "8.17.0",
+  "version": "9.0.0",
   "homepage": "https://github.com/torusresearch/controllers#readme",
   "license": "ISC",
   "sideEffects": false,
   "main": "dist/lib.cjs/index.js",
   "module": "dist/lib.esm/index.js",
-  "unpkg": "dist/ethereumControllers.umd.min.js",
-  "jsdelivr": "dist/ethereumControllers.umd.min.js",
+  "unpkg": "dist/lib.esm/index.js",
+  "jsdelivr": "dist/lib.esm/index.js",
   "types": "dist/lib.cjs/types/index.d.ts",
   "author": "Torus Labs",
   "scripts": {
     "dev": "rimraf dist/ && cross-env NODE_ENV=development torus-scripts start",
     "build": "rimraf dist/ && cross-env NODE_ENV=production torus-scripts build",
-    "lint": "eslint --fix 'src/**/*.ts' 'test/**/*.ts'",
+    "lint": "torus-scripts lint src/ test/",
     "prepack": "npm run build",
     "pre-commit": "lint-staged --cwd .",
-    "test": "vitest run --config test/configs/browsers.config.mts --coverage"
+    "test": "vitest run --config test/configs/browsers.config.mts --coverage",
+    "type-check": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@ethereumjs/common": "^10.1.0",
-    "@ethereumjs/rlp": "^10.1.0",
-    "@ethereumjs/tx": "^10.1.0",
-    "@ethereumjs/util": "^10.1.0",
-    "@metamask/smart-accounts-kit": "~0.3.0",
-    "@toruslabs/base-controllers": "^8.17.0",
-    "@toruslabs/http-helpers": "^8.1.1",
+    "@metamask/smart-accounts-kit": "~0.4.0-beta.1",
+    "@toruslabs/base-controllers": "^9.0.0",
+    "@toruslabs/http-helpers": "^9.0.0",
+    "@toruslabs/metadata-helpers": "^8.1.0",
     "@web3auth/auth": "^10.8.0",
     "async-mutex": "^0.5.0",
     "bignumber.js": "^9.3.1",
-    "bn.js": "^5.2.2",
     "deepmerge": "^4.3.1",
     "ethereum-cryptography": "^3.2.0",
-    "ethers": "^6.16.0",
     "fast-json-patch": "^3.1.1",
     "fast-safe-stringify": "^2.1.1",
     "jsonschema": "^1.5.0",
@@ -61,16 +57,15 @@
     "url": "https://github.com/torusresearch/controllers/issues"
   },
   "engines": {
-    "node": ">=20.x",
-    "npm": ">=9.x"
+    "node": ">=22.x",
+    "npm": ">=10.x"
   },
   "keywords": [],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8755704edcb1b9a066eb6a045975d72d48e7f2dd",
+  "gitHead": "85e8f530c68dc0916a30421454b99bba01711d0a",
   "devDependencies": {
-    "@typechain/ethers-v6": "^0.5.1",
     "@types/uuid": "^10.0.0",
     "typechain": "^8.3.2"
   }