@toruslabs/ethereum-controllers 8.17.1 → 9.1.0

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

@@ -2,15 +2,25 @@ import { Implementation, toMetaMaskSmartAccount } from "@metamask/smart-accounts
 import { BASE_TX_EVENT_TYPE, BaseBlockTrackerState, BaseControllerEvents, BaseFormattedTransactionActivity, BaseTokenInfo, BaseTransactionEvents, MESSAGE_EVENTS, MessageStatus, NetworkConfig, NetworkState, PaymentTransaction, PollingBlockTrackerConfig, PopupWhitelabelData, ProviderConfig, TRANSACTION_TYPE, TransactionMeta, TransactionState, TransactionStatus, TX_CONFIRMED_EVENT_TYPE, TX_DROPPED_EVENT_TYPE, TX_EVENTS, TX_FAILED_EVENT_TYPE, TX_WARNING_EVENT_TYPE, User } from "@toruslabs/base-controllers";
 import { JRPCRequest, Json } from "@web3auth/auth";
 import { MutexInterface } from "async-mutex";
-import { AccessList, TypedDataDomain, TypedDataField } from "ethers";
 import { ToBiconomySmartAccountParameters, toEcdsaKernelSmartAccount, ToLightSmartAccountParameters, ToNexusSmartAccountParameters, toSafeSmartAccount, toSimpleSmartAccount, toTrustSmartAccount } from "permissionless/accounts";
-import { Client, Hex, WalletClient } from "viem";
+import { Client, Hex, Signature, WalletClient } from "viem";
 import { createBundlerClient, createPaymasterClient, SmartAccount, UserOperationReceipt, WebAuthnAccount } from "viem/account-abstraction";
 import { METHOD_TYPES, SMART_ACCOUNT, TRANSACTION_ENVELOPE_TYPES } from "./constants";
 import { NestedTransactionMetadata } from "./eip5792Types";
 import { Authorization } from "./eip7702Types";
 export type { BatchTransactionParams, NestedTransactionMetadata, TransactionBatchRequest, TransactionBatchSingleRequest } from "./eip5792Types";
 export type { Authorization, Eip7702Params, Eip7702WalletGetUpgradeStatusResponse, SignedAuthorization } from "./eip7702Types";
+export type TypedDataField = {
+    name: string;
+    type: string;
+};
+export type TypedDataDomain = {
+    name?: string;
+    version?: string;
+    chainId?: number | string;
+    verifyingContract?: string;
+    salt?: string;
+};
 export type CustomTokenInfo = BaseTokenInfo & {
     erc20: boolean;
     customTokenId?: string;
@@ -61,6 +71,7 @@ export interface Message extends AbstractMessage {
     messageParams: MessageParams;
 }
 export type SignTypedDataMessageV4 = {
+    primaryType: string;
     types: Record<string, TypedDataField[]>;
     domain: TypedDataDomain;
     message: Record<string, unknown>;
@@ -219,7 +230,7 @@ export interface TransactionReceipt {
 }
 export type BlockTag = "earliest" | "finalized" | "safe" | "latest" | "pending";
 export type BlockParams = string | BlockTag;
-export interface TransactionRPCMeta {
+export interface TransactionRPCMeta extends Record<string, unknown> {
     v: string;
     r: string;
     s: string;
@@ -493,7 +504,7 @@ export type AccountAbstractionMultiChainConfig = {
         smartAccountConfig?: SmartAccountConfig;
     }[];
 };
-export interface UserOperationGas {
+export interface UserOperationGas extends Record<string, string> {
     callGasLimit: string;
     preVerificationGas: string;
     verificationGasLimit: string;
@@ -504,3 +515,195 @@ export interface UserOperationGas {
  * Type Def for function to query the deployment bytecode of an address. (eth_getCode)
  */
 export type GetEthCodeFn = (address: `0x${string}`, chainId: `0x${string}`) => Promise<`0x${string}`>;
+/**
+ *  A [[HexString]] whose length is even, which ensures it is a valid
+ *  representation of binary data.
+ */
+export type DataHexString = Hex;
+/**
+ *  An object that can be used to represent binary data.
+ */
+export type BytesLike = DataHexString | Uint8Array;
+/**
+ *  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.
+ */
+export type BlobLike = BytesLike | {
+    data: BytesLike;
+    proof: BytesLike;
+    commitment: BytesLike;
+};
+/**
+ *  A KZG Library with the necessary functions to compute
+ *  BLOb commitments and proofs.
+ */
+export interface KzgLibrary {
+    blobToKzgCommitment: (blob: Uint8Array) => Uint8Array;
+    computeBlobKzgProof: (blob: Uint8Array, commitment: Uint8Array) => Uint8Array;
+}
+/**
+ *  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.
+ */
+export type KzgLibraryLike = KzgLibrary | {
+    blobToKZGCommitment: (blob: string) => string;
+    computeBlobKZGProof: (blob: string, commitment: string) => string;
+} | {
+    blobToKzgCommitment: (blob: string) => string | Uint8Array;
+    computeBlobProof: (blob: string, commitment: string) => string | Uint8Array;
+};
+/**
+ *  Any type that can be used where a numeric value is needed.
+ */
+export type Numeric = number | bigint;
+/**
+ *  Any type that can be used where a big number is needed.
+ */
+export type BigNumberish = string | Numeric;
+/**
+ *  A SignatureLike
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+export type SignatureLike = Signature | string | {
+    r: string;
+    s: string;
+    v: BigNumberish;
+    yParity?: 0 | 1;
+    yParityAndS?: string;
+} | {
+    r: string;
+    yParityAndS: string;
+    yParity?: 0 | 1;
+    s?: string;
+    v?: number;
+} | {
+    r: string;
+    s: string;
+    yParity: 0 | 1;
+    v?: BigNumberish;
+    yParityAndS?: string;
+};
+/**
+ *  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.
+ */
+export type AccessListEntry = {
+    address: string;
+    storageKeys: Array<string>;
+};
+/**
+ *  An ordered collection of [[AccessList]] entries.
+ */
+export type AccessList = Array<AccessListEntry>;
+/**
+ *  Any ethers-supported access list structure.
+ */
+export type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
+export interface AuthorizationLike {
+    address: string;
+    nonce: bigint;
+    chainId: bigint;
+    signature: SignatureLike;
+}
+export interface TransactionLike<A = string> {
+    /**
+     *  The type.
+     */
+    type?: null | number;
+    /**
+     *  The recipient address or ``null`` for an ``init`` transaction.
+     */
+    to?: null | A;
+    /**
+     *  The sender.
+     */
+    from?: null | A;
+    /**
+     *  The nonce.
+     */
+    nonce?: null | number;
+    /**
+     *  The maximum amount of gas that can be used.
+     */
+    gasLimit?: null | BigNumberish;
+    /**
+     *  The gas price for legacy and berlin transactions.
+     */
+    gasPrice?: null | BigNumberish;
+    /**
+     *  The maximum priority fee per gas for london transactions.
+     */
+    maxPriorityFeePerGas?: null | BigNumberish;
+    /**
+     *  The maximum total fee per gas for london transactions.
+     */
+    maxFeePerGas?: null | BigNumberish;
+    /**
+     *  The data.
+     */
+    data?: null | string;
+    /**
+     *  The value (in wei) to send.
+     */
+    value?: null | BigNumberish;
+    /**
+     *  The chain ID the transaction is valid on.
+     */
+    chainId?: null | BigNumberish;
+    /**
+     *  The transaction hash.
+     */
+    hash?: null | string;
+    /**
+     *  The signature provided by the sender.
+     */
+    signature?: null | SignatureLike;
+    /**
+     *  The access list for berlin and london transactions.
+     */
+    accessList?: null | AccessListish;
+    /**
+     *  The maximum fee per blob gas (see [[link-eip-4844]]).
+     */
+    maxFeePerBlobGas?: null | BigNumberish;
+    /**
+     *  The versioned hashes (see [[link-eip-4844]]).
+     */
+    blobVersionedHashes?: null | Array<string>;
+    /**
+     *  The blobs (if any) attached to this transaction (see [[link-eip-4844]]).
+     */
+    blobs?: null | Array<BlobLike>;
+    /**
+     *  An external library for computing the KZG commitments and
+     *  proofs necessary for EIP-4844 transactions (see [[link-eip-4844]]).
+     *
+     *  This is generally ``null``, unless you are creating BLOb
+     *  transactions.
+     */
+    kzg?: null | KzgLibraryLike;
+    /**
+     *  The [[link-eip-7594]] BLOb Wrapper Version used for PeerDAS.
+     *
+     *  For networks that use EIP-7594, this property is required to
+     *  serialize the sidecar correctly.
+     */
+    blobWrapperVersion?: null | number;
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    authorizationList?: null | Array<AuthorizationLike>;
+}

package/dist/lib.cjs/types/utils/transaction.d.ts

@@ -3,4 +3,4 @@ import { JRPCRequest } from "@web3auth/auth";
  * Transaction decoder for analytics.
  * Decodes eth_sendRawTransaction and eth_sendUserOperation requests.
  */
-export declare const transactionDecoder: (req: JRPCRequest<unknown>, chainId: string) => [string, string];
+export declare const transactionDecoder: (req: JRPCRequest<unknown>, chainId: string) => Promise<[sender: string, txHash: string]>;

package/dist/lib.cjs/types/utils/viem.d.ts

@@ -0,0 +1,8 @@
+import { TransactionSerializable } from "viem";
+import { TransactionLike } from "./interfaces";
+/**
+ * Prepare transaction params for signing.
+ * @param tx - The transaction to prepare.
+ * @returns The prepared transaction.
+ */
+export declare function prepareViemTx(tx: TransactionLike): TransactionSerializable;

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

@@ -9,6 +9,7 @@ const erc20Abi = [{
     type: "string"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -25,6 +26,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -35,6 +37,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -54,6 +57,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -64,6 +68,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: true,
@@ -77,6 +82,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: true,
@@ -87,6 +93,7 @@ const erc20Abi = [{
     type: "string"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -103,6 +110,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: false,
@@ -122,6 +130,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -138,6 +147,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   inputs: [{
@@ -153,9 +163,11 @@ const erc20Abi = [{
     name: "_tokenSymbol",
     type: "string"
   }],
+  stateMutability: "nonpayable",
   type: "constructor"
 }, {
   payable: false,
+  stateMutability: "nonpayable",
   type: "fallback"
 }];
 const erc721Abi = [{

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

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

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

@@ -1,18 +1,19 @@
 'use strict';
 
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var util = require('@ethereumjs/util');
 var baseControllers = require('@toruslabs/base-controllers');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var bignumber_js = require('bignumber.js');
 var log = require('loglevel');
+var viem = require('viem');
 var TransactionUtils = require('../Transaction/TransactionUtils.js');
 var constants = require('./constants.js');
 
 function hexToBn(hex) {
-  return new bignumber_js.BigNumber(util.stripHexPrefix(hex), 16);
+  return new bignumber_js.BigNumber(metadataHelpers.remove0x(hex), 16);
 }
 function BNToHex(bn) {
-  return util.addHexPrefix(bn.toString(16));
+  return metadataHelpers.add0x(bn.toString(16));
 }
 function getEtherScanHashLink(txHash, chainId) {
   if (!constants.SUPPORTED_NETWORKS[chainId]) return "";
@@ -94,18 +95,18 @@ function formatTime(time) {
 }
 function isAddressByChainId(address, _chainId) {
   // TOOD: add rsk network checks.
-  return util.isValidAddress(address);
+  return viem.isAddress(address);
 }
 function toChecksumAddressByChainId(address, chainId) {
   // TOOD: add rsk network checks.
   if (!isAddressByChainId(address)) return address;
-  return util.toChecksumAddress(address);
+  return viem.getAddress(address);
 }
 const GAS_LIMITS = {
   // maximum gasLimit of a simple send
-  SIMPLE: util.addHexPrefix(21000 .toString(16)),
+  SIMPLE: viem.toHex(21000),
   // a base estimate for token transfers.
-  BASE_TOKEN_ESTIMATE: util.addHexPrefix(100000 .toString(16))
+  BASE_TOKEN_ESTIMATE: viem.toHex(100000)
 };
 function bnLessThan(a, b) {
   if (a === null || a === undefined || b === null || b === undefined) {

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

@@ -1,29 +1,25 @@
 'use strict';
 
-var common = require('@ethereumjs/common');
-var tx = require('@ethereumjs/tx');
-var util = require('@ethereumjs/util');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var log = require('loglevel');
+var viem = require('viem');
 var constants = require('./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 === constants.METHOD_TYPES.ETH_SEND_RAW_TRANSACTION) {
       const rawTx = req.params[0];
-      const txBytes = util.hexToBytes(util.addHexPrefix(rawTx));
-      const tx$1 = tx.createTxFromRLP(txBytes, {
-        common: common.createCustomCommon({
-          chainId
-        }, common.Mainnet)
+      const normalizedRawTx = metadataHelpers.add0x(rawTx);
+      sender = await viem.recoverTransactionAddress({
+        serializedTransaction: normalizedRawTx
       });
-      sender = tx$1.getSenderAddress().toString();
-      txHash = util.bytesToHex(tx$1.hash());
+      txHash = viem.keccak256(normalizedRawTx);
     } else if (req.method === constants.METHOD_TYPES.ETH_SEND_USER_OPERATION) {
       const userOpReq = req;
       sender = userOpReq.params.map(p => p.sender).join(",");

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;