@toruslabs/ethereum-controllers 8.17.1 → 9.1.0

package/dist/lib.esm/Transaction/TransactionUtils.js

@@ -1,35 +1,31 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { isHexString, addHexPrefix, isValidAddress } from '@ethereumjs/util';
 import { TRANSACTION_TYPES, TransactionStatus, randomId } from '@toruslabs/base-controllers';
+import { add0x } from '@toruslabs/metadata-helpers';
 import { rpcErrors } from '@web3auth/auth';
-import { Interface } from 'ethers';
 import log from 'loglevel';
+import { isHex, decodeFunctionData, isAddress } from 'viem';
 import { erc20Abi, erc721Abi, erc1155Abi } from '../utils/abis.js';
 import { CONTRACT_TYPE_ETH, TRANSACTION_ENVELOPE_TYPES, CONTRACT_TYPE_ERC20, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ERC1155, METHOD_TYPES } from '../utils/constants.js';
 
-const erc20Interface = new Interface(erc20Abi);
-const erc721Interface = new Interface(erc721Abi);
-const erc1155Interface = new Interface(erc1155Abi);
-
 // functions that handle normalizing of that key in txParams
 
 const normalizers = {
-  from: (from, LowerCase = true) => LowerCase ? addHexPrefix(from).toLowerCase() : addHexPrefix(from),
-  to: (to, LowerCase = true) => LowerCase ? addHexPrefix(to).toLowerCase() : addHexPrefix(to),
-  nonce: nonce => addHexPrefix(nonce),
-  customNonceValue: nonce => addHexPrefix(nonce),
-  value: value => addHexPrefix(value),
-  data: data => addHexPrefix(data),
-  gas: gas => addHexPrefix(gas),
-  gasPrice: gasPrice => addHexPrefix(gasPrice),
-  type: addHexPrefix,
-  maxFeePerGas: addHexPrefix,
-  maxPriorityFeePerGas: addHexPrefix,
-  callGasLimit: addHexPrefix,
-  preVerificationGas: addHexPrefix,
-  verificationGasLimit: addHexPrefix,
-  paymasterVerificationGasLimit: addHexPrefix,
-  paymasterPostOpGasLimit: addHexPrefix,
+  from: (from, LowerCase = true) => LowerCase ? add0x(from).toLowerCase() : add0x(from),
+  to: (to, LowerCase = true) => LowerCase ? add0x(to).toLowerCase() : add0x(to),
+  nonce: nonce => add0x(nonce),
+  customNonceValue: nonce => add0x(nonce),
+  value: value => add0x(value),
+  data: data => add0x(data),
+  gas: gas => add0x(gas),
+  gasPrice: gasPrice => add0x(gasPrice),
+  type: add0x,
+  maxFeePerGas: add0x,
+  maxPriorityFeePerGas: add0x,
+  callGasLimit: add0x,
+  preVerificationGas: add0x,
+  verificationGasLimit: add0x,
+  paymasterVerificationGasLimit: add0x,
+  paymasterPostOpGasLimit: add0x,
   authorizationList: authorizationList => authorizationList
 };
 
@@ -65,7 +61,9 @@ function transactionMatchesNetwork(transaction, chainId) {
  */
 function isEIP1559Transaction(transaction) {
   var _transaction$transact, _transaction$transact2;
-  return isHexString(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas)) && isHexString(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas));
+  const maxFeePerGas = transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas;
+  const maxPriorityFeePerGas = transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas;
+  return typeof maxFeePerGas === "string" && typeof maxPriorityFeePerGas === "string" && isHex(add0x(maxFeePerGas)) && isHex(add0x(maxPriorityFeePerGas));
 }
 
 /**
@@ -78,7 +76,7 @@ function isEIP1559Transaction(transaction) {
  *  EIP1559 fields
  */
 function isLegacyTransaction(transaction) {
-  return typeof transaction.transaction.maxFeePerGas === "undefined" && typeof transaction.transaction.maxPriorityFeePerGas === "undefined" && (typeof transaction.transaction.gasPrice === "undefined" || isHexString(addHexPrefix(transaction.transaction.gasPrice)));
+  return typeof transaction.transaction.maxFeePerGas === "undefined" && typeof transaction.transaction.maxPriorityFeePerGas === "undefined" && (typeof transaction.transaction.gasPrice === "undefined" || isHex(add0x(transaction.transaction.gasPrice)));
 }
 
 /**
@@ -129,7 +127,7 @@ function validateFrom(txParams) {
   if (!(typeof txParams.from === "string")) {
     throw rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
   }
-  if (!isValidAddress(txParams.from)) {
+  if (!isAddress(txParams.from)) {
     throw rpcErrors.invalidParams('Invalid "from" address.');
   }
 }
@@ -144,7 +142,7 @@ function validateRecipient(txParameters) {
     } else {
       throw rpcErrors.invalidParams('Invalid "to" address.');
     }
-  } else if (txParameters.to !== undefined && !isValidAddress(txParameters.to)) {
+  } else if (txParameters.to !== undefined && !isAddress(txParameters.to)) {
     throw rpcErrors.invalidParams('Invalid "to" address.');
   }
   return txParameters;
@@ -213,10 +211,10 @@ function validateTxParameters(txParams, eip1559Compatibility = true) {
           if (typeof authorization !== "object" || authorization === null) {
             throw rpcErrors.invalidParams(`Invalid transaction params: ${key} is not an object. got: (${authorization})`);
           }
-          if (typeof authorization.address !== "string" || !isValidAddress(authorization.address)) {
+          if (typeof authorization.address !== "string" || !isAddress(authorization.address)) {
             throw rpcErrors.invalidParams(`Invalid transaction params: authorization.address is not a valid address. got: (${authorization.address})`);
           }
-          if (typeof authorization.chainId !== "string" || !isHexString(addHexPrefix(authorization.chainId))) {
+          if (typeof authorization.chainId !== "string" || !isHex(add0x(authorization.chainId))) {
             throw rpcErrors.invalidParams(`Invalid transaction params: authorization.chainId is not a valid hex string. got: (${authorization.chainId})`);
           }
         });
@@ -247,36 +245,42 @@ function getFinalStates() {
 }
 function parseStandardTokenTransactionData(data) {
   try {
-    const txDesc = erc20Interface.parseTransaction({
-      data
+    var _txDesc$args;
+    const txDesc = decodeFunctionData({
+      abi: erc20Abi,
+      data: data
     });
     if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
+      name: txDesc.functionName,
+      methodParams: [...((_txDesc$args = txDesc.args) !== null && _txDesc$args !== void 0 ? _txDesc$args : [])],
       type: CONTRACT_TYPE_ERC20
     };
   } catch {
     // ignore and next try to parse with erc721 ABI
   }
   try {
-    const txDesc = erc721Interface.parseTransaction({
-      data
+    var _txDesc$args2;
+    const txDesc = decodeFunctionData({
+      abi: erc721Abi,
+      data: data
     });
     if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
+      name: txDesc.functionName,
+      methodParams: [...((_txDesc$args2 = txDesc.args) !== null && _txDesc$args2 !== void 0 ? _txDesc$args2 : [])],
       type: CONTRACT_TYPE_ERC721
     };
   } catch {
     // ignore and next try to parse with erc1155 ABI
   }
   try {
-    const txDesc = erc1155Interface.parseTransaction({
-      data
+    var _txDesc$args3;
+    const txDesc = decodeFunctionData({
+      abi: erc1155Abi,
+      data: data
     });
     if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
+      name: txDesc.functionName,
+      methodParams: [...((_txDesc$args3 = txDesc.args) !== null && _txDesc$args3 !== void 0 ? _txDesc$args3 : [])],
       type: CONTRACT_TYPE_ERC1155
     };
   } catch {

package/dist/lib.esm/index.js

@@ -11,9 +11,6 @@ export { PersonalMessageController } from './Message/PersonalMessageController.j
 export { SwitchChainController } from './Message/SwitchChainController.js';
 export { TypedMessageController } from './Message/TypedMessageController.js';
 export { normalizeMessageData, validateAddChainData, validateAddress, validateSignMessageData, validateSwitchChainData, validateTypedSignMessageDataV4 } from './Message/utils.js';
-export { createAAMiddleware, createEip5792Middleware, createEip7702Middleware, createEthereumMiddleware, createGetAccountsMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEstimateUserOperationGasMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSignTransactionMiddleware, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProcessWalletSwitchChain, createRequestAccountsMiddleware, formatTxMetaForRpcResult } from './Network/createEthereumMiddleware.js';
-export { createChainIdMiddleware, createJsonRpcClient, createProviderConfigMiddleware } from './Network/createJsonRpcClient.js';
-export { NetworkController } from './Network/NetworkController.js';
 export { NftHandler } from './Nfts/NftHandler.js';
 export { NftsController } from './Nfts/NftsController.js';
 export { PreferencesController } from './Preferences/PreferencesController.js';
@@ -35,11 +32,15 @@ export { DUMMY_AUTHORIZATION_SIGNATURE, EIP_7702_METHODS, EIP_7702_PREFIX, EIP_7
 export { BNToHex, GAS_LIMITS, addEtherscanTransactions, bnLessThan, formatDate, formatPastTx, formatTime, getChainType, getEthTxStatus, getEtherScanHashLink, getIpfsEndpoint, hexToBn, isAddressByChainId, sanitizeNftMetdataUrl, toChecksumAddressByChainId } from './utils/helpers.js';
 export { TRANSACTION_CATEGORY_EIP7702 } from './utils/interfaces.js';
 export { BiconomySmartAccount } from './AccountAbstraction/smartAccounts/BiconomySmartAccount.js';
+export { CacheStrategy, blockTagParamIndex, cacheIdentifierForRequest, cacheTypeForMethod } from './Network/cacheIdentifier.js';
 export { KernelSmartAccount } from './AccountAbstraction/smartAccounts/KernelSmartAccount.js';
 export { MetamaskSmartAccount } from './AccountAbstraction/smartAccounts/MetamaskSmartAccount.js';
+export { NetworkController } from './Network/NetworkController.js';
 export { NexusSmartAccount } from './AccountAbstraction/smartAccounts/NexusSmartAccount.js';
 export { SafeSmartAccount } from './AccountAbstraction/smartAccounts/SafeSmartAccount.js';
 export { TrustSmartAccount } from './AccountAbstraction/smartAccounts/TrustSmartAccount.js';
+export { createAAMiddleware, createEip5792Middleware, createEip7702Middleware, createEthereumMiddleware, createGetAccountsMiddleware, createGetProviderStateMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEstimateUserOperationGasMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSignTransactionMiddleware, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProcessWalletSwitchChain, createRequestAccountsMiddleware, formatTxMetaForRpcResult } from './Network/createEthereumMiddleware.js';
+export { createChainIdMiddleware, createJsonRpcClient, createProviderConfigMiddleware } from './Network/createJsonRpcClient.js';
 export { generateBatchId, processMultipleTransactions, processSingleTransaction, validateSendCallsParams, walletSendCalls } from './Eip5792/walletSendCalls.js';
 export { mapTransactionStatusToEip5792Status, walletGetCallsStatus } from './Eip5792/walletGetCallsStatus.js';
 export { walletGetCapabilities } from './Eip5792/walletGetCapabilities.js';

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

@@ -7,6 +7,7 @@ const erc20Abi = [{
     type: "string"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -23,6 +24,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -33,6 +35,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -52,6 +55,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -62,6 +66,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: true,
@@ -75,6 +80,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: true,
@@ -85,6 +91,7 @@ const erc20Abi = [{
     type: "string"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -101,6 +108,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: false,
@@ -120,6 +128,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -136,6 +145,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   inputs: [{
@@ -151,9 +161,11 @@ const erc20Abi = [{
     name: "_tokenSymbol",
     type: "string"
   }],
+  stateMutability: "nonpayable",
   type: "constructor"
 }, {
   payable: false,
+  stateMutability: "nonpayable",
   type: "fallback"
 }];
 const erc721Abi = [{

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

@@ -1,9 +1,8 @@
 import _objectDestructuringEmpty from '@babel/runtime/helpers/objectDestructuringEmpty';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
-import { stripHexPrefix } from '@ethereumjs/util';
+import { remove0x } from '@toruslabs/metadata-helpers';
 import { BigNumber } from 'bignumber.js';
-import BN from 'bn.js';
 
 const _excluded = ["aBase", "bBase"],
   _excluded2 = ["aBase", "bBase"],
@@ -15,7 +14,7 @@ const BIG_NUMBER_GWEI_MULTIPLIER = new BigNumber("1000000000");
 const BIG_NUMBER_ETH_MULTIPLIER = new BigNumber("1");
 // Setter Maps
 const toBigNumber = {
-  hex: n => new BigNumber(stripHexPrefix(n), 16),
+  hex: n => new BigNumber(remove0x(n), 16),
   dec: n => new BigNumber(String(n), 10),
   BN: n => new BigNumber(n.toString(16), 16)
 };
@@ -32,7 +31,7 @@ const toSpecifiedDenomination = {
 const baseChange = {
   hex: n => n.toString(16),
   dec: n => new BigNumber(n).toString(10),
-  BN: n => new BN(n.toString(16))
+  BN: n => new BigNumber(n.toString(16))
 };
 
 // Utility function for checking base types

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

@@ -1,16 +1,17 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { addHexPrefix, stripHexPrefix, isValidAddress, toChecksumAddress } from '@ethereumjs/util';
 import { TransactionStatus, formatSmallNumbers, significantDigits, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, addressSlicer } from '@toruslabs/base-controllers';
+import { add0x, remove0x } from '@toruslabs/metadata-helpers';
 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_ERC1155, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ERC20, MAINNET_CHAIN_ID, TEST_CHAINS, METHOD_TYPES, CONTRACT_TYPE_ETH } from './constants.js';
 
 function hexToBn(hex) {
-  return new BigNumber(stripHexPrefix(hex), 16);
+  return new BigNumber(remove0x(hex), 16);
 }
 function BNToHex(bn) {
-  return addHexPrefix(bn.toString(16));
+  return add0x(bn.toString(16));
 }
 function getEtherScanHashLink(txHash, chainId) {
   if (!SUPPORTED_NETWORKS[chainId]) return "";
@@ -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/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 { add0x } from '@toruslabs/metadata-helpers';
 import log from 'loglevel';
+import { recoverTransactionAddress, keccak256 } from 'viem';
 import { METHOD_TYPES } from './constants.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 = add0x(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 };