viem 0.1.23 → 0.2.0-0-2-0.20230328T054201

package/dist/{chunk-JG6MI5ZV.mjs → chunk-HYEOQX7O.mjs}

@@ -25,7 +25,7 @@ var package_default = {
     anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
     bench: "vitest bench --no-threads",
     "bench:ci": "CI=true vitest bench --no-threads",
-    build: "tsup",
+    build: "tsup && size-limit",
     changeset: "changeset",
     "changeset:release": "pnpm build && changeset publish",
     "changeset:version": "changeset version && pnpm install --lockfile-only",
@@ -53,6 +53,7 @@ var package_default = {
     entry: [
       "src/index.ts",
       "src/abi.ts",
+      "src/accounts/index.ts",
       "src/chains.ts",
       "src/contract.ts",
       "src/ens.ts",
@@ -66,6 +67,7 @@ var package_default = {
   },
   files: [
     "/abi",
+    "/accounts",
     "/dist",
     "/chains",
     "/contract",
@@ -88,6 +90,11 @@ var package_default = {
       module: "./dist/abi.mts",
       default: "./dist/abi.js"
     },
+    "./accounts": {
+      types: "./dist/accounts/index.d.ts",
+      module: "./dist/accounts/index.mts",
+      default: "./dist/accounts/index.js"
+    },
     "./chains": {
       types: "./dist/chains.d.ts",
       module: "./dist/chains.mts",
@@ -142,6 +149,8 @@ var package_default = {
   dependencies: {
     "@noble/hashes": "^1.1.2",
     "@noble/secp256k1": "^1.7.1",
+    "@scure/bip32": "^1.2.0",
+    "@scure/bip39": "^1.1.1",
     "@wagmi/chains": "~0.2.11",
     abitype: "~0.7.1",
     "idna-uts46-hx": "^4.1.2",
@@ -154,6 +163,7 @@ var package_default = {
     "@adraffy/ens-normalize": "^1.8.9",
     "@changesets/changelog-github": "^0.4.5",
     "@changesets/cli": "^2.23.2",
+    "@size-limit/preset-big-lib": "^8.2.4",
     "@types/dedent": "^0.7.0",
     "@types/fs-extra": "^9.0.13",
     "@types/node": "^17.0.45",
@@ -171,6 +181,7 @@ var package_default = {
     rimraf: "^4.1.2",
     rome: "^11.0.0",
     "simple-git-hooks": "^2.8.1",
+    "size-limit": "^8.2.4",
     tsup: "^6.6.0",
     typescript: "^4.9.4",
     vite: "^4.1.4",
@@ -189,6 +200,11 @@ var package_default = {
     "wallet",
     "web3"
   ],
+  "size-limit": [
+    {
+      path: "dist/index.js"
+    }
+  ],
   "simple-git-hooks": {
     "pre-commit": "pnpm format && pnpm lint:fix"
   },
@@ -218,7 +234,9 @@ var BaseError = class extends Error {
       shortMessage || "An error occurred.",
       "",
       ...args.metaMessages ? [...args.metaMessages, ""] : [],
-      ...docsPath6 ? [`Docs: https://viem.sh${docsPath6}.html`] : [],
+      ...docsPath6 ? [
+        `Docs: https://viem.sh${docsPath6}.html${args.docsSlug ? `#${args.docsSlug}` : ""}`
+      ] : [],
       ...details ? [`Details: ${details}`] : [],
       `Version: ${getVersion()}`
     ].join("\n");
@@ -519,6 +537,23 @@ var UnsupportedPackedAbiType = class extends BaseError {
   }
 };
 
+// src/errors/account.ts
+var AccountNotFoundError = class extends BaseError {
+  constructor({ docsPath: docsPath6 } = {}) {
+    super(
+      [
+        "Could not find an Account to execute with this Action.",
+        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the WalletClient."
+      ].join("\n"),
+      {
+        docsPath: docsPath6,
+        docsSlug: "account"
+      }
+    );
+    __publicField(this, "name", "AccountNotFoundError");
+  }
+};
+
 // src/errors/address.ts
 var InvalidAddressError = class extends BaseError {
   constructor({ address }) {
@@ -583,6 +618,23 @@ var ChainMismatchError = class extends BaseError {
     __publicField(this, "name", "ChainMismatchError");
   }
 };
+var ChainNotFoundError = class extends BaseError {
+  constructor() {
+    super(
+      [
+        "No chain was provided to the request.",
+        "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
+      ].join("\n")
+    );
+    __publicField(this, "name", "ChainNotFoundError");
+  }
+};
+var InvalidChainIdError = class extends BaseError {
+  constructor({ chainId }) {
+    super(`Chain ID "${chainId}" is invalid.`);
+    __publicField(this, "name", "InvalidChainIdError");
+  }
+};
 
 // src/constants/abis.ts
 var multicall3Abi = [
@@ -697,6 +749,69 @@ var FeeConflictError = class extends BaseError {
     __publicField(this, "name", "FeeConflictError");
   }
 };
+var InvalidLegacyVError = class extends BaseError {
+  constructor({ v }) {
+    super(`Invalid \`v\` value "${v}". Expected 27 or 28.`);
+    __publicField(this, "name", "InvalidLegacyVError");
+  }
+};
+var InvalidSerializableTransactionError = class extends BaseError {
+  constructor({ transaction }) {
+    super("Cannot infer a transaction type from provided transaction.", {
+      metaMessages: [
+        "Provided Transaction:",
+        "{",
+        prettyPrint(transaction),
+        "}",
+        "",
+        "To infer the type, either provide:",
+        "- a `type` to the Transaction, or",
+        "- an EIP-1559 Transaction with `maxFeePerGas`, or",
+        "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
+        "- a Legacy Transaction with `gasPrice`"
+      ]
+    });
+    __publicField(this, "name", "InvalidSerializableTransactionError");
+  }
+};
+var InvalidSerializedTransactionTypeError = class extends BaseError {
+  constructor({ serializedType }) {
+    super(`Serialized transaction type "${serializedType}" is invalid.`);
+    __publicField(this, "name", "InvalidSerializedTransactionType");
+    __publicField(this, "serializedType");
+    this.serializedType = serializedType;
+  }
+};
+var InvalidSerializedTransactionError = class extends BaseError {
+  constructor({
+    attributes,
+    serializedTransaction,
+    type
+  }) {
+    const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
+    super(`Invalid serialized transaction of type "${type}" was provided.`, {
+      metaMessages: [
+        `Serialized Transaction: "${serializedTransaction}"`,
+        missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""
+      ].filter(Boolean)
+    });
+    __publicField(this, "name", "InvalidSerializedTransactionError");
+    __publicField(this, "serializedTransaction");
+    __publicField(this, "type");
+    this.serializedTransaction = serializedTransaction;
+    this.type = type;
+  }
+};
+var InvalidStorageKeySizeError = class extends BaseError {
+  constructor({ storageKey }) {
+    super(
+      `Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor(
+        (storageKey.length - 2) / 2
+      )} bytes.`
+    );
+    __publicField(this, "name", "InvalidStorageKeySizeError");
+  }
+};
 var TransactionExecutionError = class extends BaseError {
   constructor(cause, {
     account,
@@ -713,7 +828,7 @@ var TransactionExecutionError = class extends BaseError {
   }) {
     const prettyArgs = prettyPrint({
       chain: chain && `${chain?.name} (id: ${chain?.id})`,
-      from: account.address,
+      from: account?.address,
       to,
       value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
       data,
@@ -778,7 +893,7 @@ var WaitForTransactionReceiptTimeoutError = class extends BaseError {
 // src/errors/contract.ts
 var CallExecutionError = class extends BaseError {
   constructor(cause, {
-    account,
+    account: account_,
     docsPath: docsPath6,
     chain,
     data,
@@ -790,6 +905,7 @@ var CallExecutionError = class extends BaseError {
     to,
     value
   }) {
+    const account = account_ ? parseAccount(account_) : void 0;
     const prettyArgs = prettyPrint({
       from: account?.address,
       to,
@@ -1032,7 +1148,7 @@ var EstimateGasExecutionError = class extends BaseError {
     value
   }) {
     const prettyArgs = prettyPrint({
-      from: account.address,
+      from: account?.address,
       to,
       value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
       data,
@@ -1921,6 +2037,11 @@ var getEventSelector = (event) => hashFunction(event);
 // src/utils/hash/getFunctionSelector.ts
 var getFunctionSelector = (fn) => slice(hashFunction(fn), 0, 4);
 
+// src/utils/hash/isHash.ts
+function isHash(hash2) {
+  return hash2.startsWith("0x") && size(hash2) === 32;
+}
+
 // src/utils/address/isAddress.ts
 var addressRegex = /^0x[a-fA-F0-9]{40}$/;
 function isAddress(address) {
@@ -2828,19 +2949,11 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
-// src/utils/account.ts
-function getAccount(account) {
-  if (typeof account === "string") {
-    if (!isAddress(account))
-      throw new InvalidAddressError({ address: account });
+// src/accounts/utils/parseAccount.ts
+function parseAccount(account) {
+  if (typeof account === "string")
     return { address: account, type: "json-rpc" };
-  }
-  if (!isAddress(account.address))
-    throw new InvalidAddressError({ address: account.address });
-  return {
-    ...account,
-    type: "local"
-  };
+  return account;
 }
 
 // src/utils/promise/withCache.ts
@@ -3507,15 +3620,224 @@ ${messageBytes.length}`
   return keccak256(concat([prefixBytes, messageBytes]), to_);
 }
 
+// src/utils/typedData.ts
+function validateTypedData({
+  domain,
+  message,
+  primaryType,
+  types: types_
+}) {
+  const types = types_;
+  const validateData = (struct, value_) => {
+    for (const param of struct) {
+      const { name, type: type_ } = param;
+      const type = type_;
+      const value = value_[name];
+      const integerMatch = type.match(integerRegex);
+      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
+        const [_type, base, size_] = integerMatch;
+        numberToHex(value, {
+          signed: base === "int",
+          size: parseInt(size_) / 8
+        });
+      }
+      if (type === "address" && typeof value === "string" && !isAddress(value))
+        throw new InvalidAddressError({ address: value });
+      const bytesMatch = type.match(bytesRegex);
+      if (bytesMatch) {
+        const [_type, size_] = bytesMatch;
+        if (size_ && size(value) !== parseInt(size_))
+          throw new BytesSizeMismatchError({
+            expectedSize: parseInt(size_),
+            givenSize: size(value)
+          });
+      }
+      const struct2 = types[type];
+      if (struct2)
+        validateData(struct2, value);
+    }
+  };
+  if (types["EIP712Domain"] && domain)
+    validateData(types["EIP712Domain"], domain);
+  if (primaryType !== "EIP712Domain") {
+    const type = types[primaryType];
+    validateData(type, message);
+  }
+}
+
+// src/utils/signature/hashTypedData.ts
+function hashTypedData({
+  domain: domain_,
+  message,
+  primaryType,
+  types: types_
+}) {
+  const domain = typeof domain_ === "undefined" ? {} : domain_;
+  const types = {
+    EIP712Domain: [
+      domain?.name && { name: "name", type: "string" },
+      domain?.version && { name: "version", type: "string" },
+      domain?.chainId && { name: "chainId", type: "uint256" },
+      domain?.verifyingContract && {
+        name: "verifyingContract",
+        type: "address"
+      },
+      domain?.salt && { name: "salt", type: "bytes32" }
+    ].filter(Boolean),
+    ...types_
+  };
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types
+  });
+  let parts = ["0x1901"];
+  if (domain)
+    parts.push(
+      hashDomain({
+        domain,
+        types
+      })
+    );
+  if (primaryType !== "EIP712Domain") {
+    parts.push(
+      hashStruct({
+        data: message,
+        primaryType,
+        types
+      })
+    );
+  }
+  return keccak256(concat(parts));
+}
+function hashDomain({
+  domain,
+  types
+}) {
+  return hashStruct({
+    data: domain,
+    primaryType: "EIP712Domain",
+    types
+  });
+}
+function hashStruct({
+  data,
+  primaryType,
+  types
+}) {
+  const encoded = encodeData({
+    data,
+    primaryType,
+    types
+  });
+  return keccak256(encoded);
+}
+function encodeData({
+  data,
+  primaryType,
+  types
+}) {
+  let encodedTypes = [{ type: "bytes32" }];
+  const encodedValues = [hashType({ primaryType, types })];
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name]
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+  return encodeAbiParameters(encodedTypes, encodedValues);
+}
+function hashType({
+  primaryType,
+  types
+}) {
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
+}
+function encodeType({
+  primaryType,
+  types
+}) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+  }
+  return result;
+}
+function findTypeDependencies({
+  primaryType: primaryType_,
+  types
+}, results = /* @__PURE__ */ new Set()) {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0];
+  if (results.has(primaryType) || types[primaryType] === void 0) {
+    return results;
+  }
+  results.add(primaryType);
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+function encodeField({
+  types,
+  name,
+  type,
+  value
+}) {
+  if (types[type] !== void 0) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types }))
+    ];
+  }
+  if (type === "bytes") {
+    const prepend = value.length % 2 ? "0" : "";
+    value = `0x${prepend + value.slice(2)}`;
+    return [{ type: "bytes32" }, keccak256(value)];
+  }
+  if (type === "string")
+    return [{ type: "bytes32" }, keccak256(toHex(value))];
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    const typeValuePairs = value.map(
+      (item) => encodeField({
+        name,
+        type: parsedType,
+        types,
+        value: item
+      })
+    );
+    return [
+      { type: "bytes32" },
+      keccak256(
+        encodeAbiParameters(
+          typeValuePairs.map(([t]) => t),
+          typeValuePairs.map(([, v]) => v)
+        )
+      )
+    ];
+  }
+  return [{ type }, value];
+}
+
 // src/utils/signature/recoverAddress.ts
-import { recoverPublicKey } from "@noble/secp256k1";
-function recoverAddress({
+async function recoverAddress({
   hash: hash2,
   signature
 }) {
   const signatureHex = isHex(signature) ? signature : toHex(signature);
   const hashHex = isHex(hash2) ? hash2 : toHex(hash2);
   const v = hexToNumber(`0x${signatureHex.slice(130)}`);
+  const { recoverPublicKey } = await import("@noble/secp256k1");
   const publicKey = toHex(
     recoverPublicKey(
       hashHex.substring(2),
@@ -3528,28 +3850,75 @@ function recoverAddress({
 }
 
 // src/utils/signature/recoverMessageAddress.ts
-function recoverMessageAddress({
+async function recoverMessageAddress({
   message,
   signature
 }) {
   return recoverAddress({ hash: hashMessage(message), signature });
 }
 
+// src/utils/signature/recoverTypedDataAddress.ts
+async function recoverTypedDataAddress({
+  domain,
+  message,
+  primaryType,
+  signature,
+  types
+}) {
+  return recoverAddress({
+    hash: hashTypedData({
+      domain,
+      message,
+      primaryType,
+      types
+    }),
+    signature
+  });
+}
+
 // src/utils/signature/verifyMessage.ts
-function verifyMessage({
+async function verifyMessage({
   address,
   message,
   signature
 }) {
   return isAddressEqual(
     getAddress(address),
-    recoverMessageAddress({ message, signature })
+    await recoverMessageAddress({ message, signature })
+  );
+}
+
+// src/utils/signature/verifyTypedData.ts
+async function verifyTypedData({
+  address,
+  domain,
+  message,
+  primaryType,
+  signature,
+  types
+}) {
+  return isAddressEqual(
+    getAddress(address),
+    await recoverTypedDataAddress({
+      domain,
+      message,
+      primaryType,
+      signature,
+      types
+    })
   );
 }
 
 // src/utils/transaction/assertRequest.ts
 function assertRequest(args) {
-  const { account, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
+  const {
+    account: account_,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    to
+  } = args;
+  const account = account_ ? parseAccount(account_) : void 0;
   if (account && !isAddress(account.address))
     throw new InvalidAddressError({ address: account.address });
   if (to && !isAddress(to))
@@ -3562,10 +3931,36 @@ function assertRequest(args) {
     throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
 }
 
+// src/utils/transaction/getSerializedTransactionType.ts
+function getSerializedTransactionType(serializedTransaction) {
+  const serializedType = sliceHex(serializedTransaction, 0, 1);
+  if (serializedType === "0x02")
+    return "eip1559";
+  if (serializedType === "0x01")
+    return "eip2930";
+  if (serializedType !== "0x" && hexToNumber(serializedType) >= 192)
+    return "legacy";
+  throw new InvalidSerializedTransactionTypeError({ serializedType });
+}
+
+// src/utils/transaction/getTransactionType.ts
+function getTransactionType(transaction) {
+  if (transaction.type)
+    return transaction.type;
+  if ("maxFeePerGas" in transaction || "maxPriorityFeePerGas" in transaction)
+    return "eip1559";
+  if ("gasPrice" in transaction) {
+    if ("accessList" in transaction)
+      return "eip2930";
+    return "legacy";
+  }
+  throw new InvalidSerializableTransactionError({ transaction });
+}
+
 // src/actions/public/call.ts
 async function call(client, args) {
   const {
-    account,
+    account: account_,
     blockNumber,
     blockTag = "latest",
     accessList,
@@ -3579,6 +3974,7 @@ async function call(client, args) {
     value,
     ...rest
   } = args;
+  const account = account_ ? parseAccount(account_) : void 0;
   try {
     assertRequest(args);
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
@@ -3612,6 +4008,7 @@ async function call(client, args) {
   } catch (err) {
     throw getCallError(err, {
       ...args,
+      account,
       chain: client.chain
     });
   }
@@ -3625,6 +4022,7 @@ async function simulateContract(client, {
   functionName,
   ...callRequest
 }) {
+  const account = callRequest.account ? parseAccount(callRequest.account) : void 0;
   const calldata = encodeFunctionData({
     abi,
     args,
@@ -3659,7 +4057,7 @@ async function simulateContract(client, {
       args,
       docsPath: "/docs/contract/simulateContract",
       functionName,
-      sender: callRequest.account?.address
+      sender: account?.address
     });
   }
 }
@@ -3751,9 +4149,13 @@ async function createContractEventFilter(client, {
 
 // src/actions/public/estimateGas.ts
 async function estimateGas(client, args) {
+  if (!args.account)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/public/estimateGas"
+    });
+  const account = parseAccount(args.account);
   try {
     const {
-      account,
       accessList,
       blockNumber,
       blockTag = "latest",
@@ -3766,7 +4168,7 @@ async function estimateGas(client, args) {
       to,
       value,
       ...rest
-    } = args.account.type === "local" ? await prepareRequest(client, args) : args;
+    } = account.type === "local" ? await prepareRequest(client, args) : args;
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
     assertRequest(args);
     const formatter = client.chain?.formatters?.transactionRequest;
@@ -3797,6 +4199,7 @@ async function estimateGas(client, args) {
   } catch (err) {
     throw getEstimateGasError(err, {
       ...args,
+      account,
       chain: client.chain
     });
   }
@@ -3810,6 +4213,7 @@ async function estimateContractGas(client, {
   functionName,
   ...request
 }) {
+  const account = parseAccount(request.account);
   const data = encodeFunctionData({
     abi,
     args,
@@ -3829,7 +4233,7 @@ async function estimateContractGas(client, {
       args,
       docsPath: "/docs/contract/simulateContract",
       functionName,
-      sender: request.account?.address
+      sender: account?.address
     });
   }
 }
@@ -4320,6 +4724,7 @@ async function waitForTransactionReceipt(client, {
         const unwatch = watchBlockNumber(client, {
           emitMissed: true,
           emitOnBegin: true,
+          poll: true,
           pollingInterval,
           async onBlockNumber(blockNumber) {
             const done = async (fn) => {
@@ -4412,47 +4817,79 @@ function watchBlockNumber(client, {
   emitMissed = false,
   onBlockNumber,
   onError,
+  poll: poll_,
   pollingInterval = client.pollingInterval
 }) {
-  const observerId = JSON.stringify([
-    "watchBlockNumber",
-    client.uid,
-    emitOnBegin,
-    emitMissed,
-    pollingInterval
-  ]);
+  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
   let prevBlockNumber;
-  return observe(
-    observerId,
-    { onBlockNumber, onError },
-    (emit) => poll(
-      async () => {
-        try {
-          const blockNumber = await getBlockNumber(client, { maxAge: 0 });
-          if (prevBlockNumber) {
-            if (blockNumber === prevBlockNumber)
-              return;
-            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
-              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
-                emit.onBlockNumber(i, prevBlockNumber);
-                prevBlockNumber = i;
+  const pollBlockNumber = () => {
+    const observerId = JSON.stringify([
+      "watchBlockNumber",
+      client.uid,
+      emitOnBegin,
+      emitMissed,
+      pollingInterval
+    ]);
+    return observe(
+      observerId,
+      { onBlockNumber, onError },
+      (emit) => poll(
+        async () => {
+          try {
+            const blockNumber = await getBlockNumber(client, { maxAge: 0 });
+            if (prevBlockNumber) {
+              if (blockNumber === prevBlockNumber)
+                return;
+              if (blockNumber - prevBlockNumber > 1 && emitMissed) {
+                for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
+                  emit.onBlockNumber(i, prevBlockNumber);
+                  prevBlockNumber = i;
+                }
               }
             }
+            if (!prevBlockNumber || blockNumber > prevBlockNumber) {
+              emit.onBlockNumber(blockNumber, prevBlockNumber);
+              prevBlockNumber = blockNumber;
+            }
+          } catch (err) {
+            emit.onError?.(err);
           }
-          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
-            emit.onBlockNumber(blockNumber, prevBlockNumber);
+        },
+        {
+          emitOnBegin,
+          interval: pollingInterval
+        }
+      )
+    );
+  };
+  const subscribeBlockNumber = () => {
+    let active = true;
+    let unsubscribe = () => active = false;
+    (async () => {
+      try {
+        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+          params: ["newHeads"],
+          onData(data) {
+            if (!active)
+              return;
+            const blockNumber = hexToBigInt(data.result?.number);
+            onBlockNumber(blockNumber, prevBlockNumber);
             prevBlockNumber = blockNumber;
+          },
+          onError(error) {
+            onError?.(error);
           }
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin,
-        interval: pollingInterval
+        });
+        unsubscribe = unsubscribe_;
+        if (!active)
+          unsubscribe();
+      } catch (err) {
+        onError?.(err);
       }
-    )
-  );
+    })();
+    return unsubscribe;
+  };
+  return enablePolling ? pollBlockNumber() : subscribeBlockNumber();
 }
 
 // src/actions/public/watchBlocks.ts
@@ -4463,61 +4900,93 @@ function watchBlocks(client, {
   onBlock,
   onError,
   includeTransactions = false,
+  poll: poll_,
   pollingInterval = client.pollingInterval
 }) {
-  const observerId = JSON.stringify([
-    "watchBlocks",
-    client.uid,
-    emitMissed,
-    emitOnBegin,
-    includeTransactions,
-    pollingInterval
-  ]);
+  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
   let prevBlock;
-  return observe(
-    observerId,
-    { onBlock, onError },
-    (emit) => poll(
-      async () => {
-        try {
-          const block = await getBlock(client, {
-            blockTag,
-            includeTransactions
-          });
-          if (block.number && prevBlock?.number) {
-            if (block.number === prevBlock.number)
-              return;
-            if (block.number - prevBlock.number > 1 && emitMissed) {
-              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
-                const block2 = await getBlock(client, {
-                  blockNumber: i,
-                  includeTransactions
-                });
-                emit.onBlock(block2, prevBlock);
-                prevBlock = block2;
+  const pollBlocks = () => {
+    const observerId = JSON.stringify([
+      "watchBlocks",
+      client.uid,
+      emitMissed,
+      emitOnBegin,
+      includeTransactions,
+      pollingInterval
+    ]);
+    return observe(
+      observerId,
+      { onBlock, onError },
+      (emit) => poll(
+        async () => {
+          try {
+            const block = await getBlock(client, {
+              blockTag,
+              includeTransactions
+            });
+            if (block.number && prevBlock?.number) {
+              if (block.number === prevBlock.number)
+                return;
+              if (block.number - prevBlock.number > 1 && emitMissed) {
+                for (let i = prevBlock?.number + 1n; i < block.number; i++) {
+                  const block2 = await getBlock(client, {
+                    blockNumber: i,
+                    includeTransactions
+                  });
+                  emit.onBlock(block2, prevBlock);
+                  prevBlock = block2;
+                }
               }
             }
+            if (
+              // If no previous block exists, emit.
+              !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
+              blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
+              // We don't want to emit blocks in the past.
+              block.number && block.number > prevBlock.number
+            ) {
+              emit.onBlock(block, prevBlock);
+              prevBlock = block;
+            }
+          } catch (err) {
+            emit.onError?.(err);
           }
-          if (
-            // If no previous block exists, emit.
-            !prevBlock?.number || // If the block tag is "pending" with no block number, emit.
-            blockTag === "pending" && !block?.number || // If the next block number is greater than the previous block number, emit.
-            // We don't want to emit blocks in the past.
-            block.number && block.number > prevBlock.number
-          ) {
-            emit.onBlock(block, prevBlock);
+        },
+        {
+          emitOnBegin,
+          interval: pollingInterval
+        }
+      )
+    );
+  };
+  const subscribeBlocks = () => {
+    let active = true;
+    let unsubscribe = () => active = false;
+    (async () => {
+      try {
+        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+          params: ["newHeads"],
+          onData(data) {
+            if (!active)
+              return;
+            const block = data.result;
+            onBlock(block, prevBlock);
             prevBlock = block;
+          },
+          onError(error) {
+            onError?.(error);
           }
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin,
-        interval: pollingInterval
+        });
+        unsubscribe = unsubscribe_;
+        if (!active)
+          unsubscribe();
+      } catch (err) {
+        onError?.(err);
       }
-    )
-  );
+    })();
+    return unsubscribe;
+  };
+  return enablePolling ? pollBlocks() : subscribeBlocks();
 }
 
 // src/actions/public/watchContractEvent.ts
@@ -4688,50 +5157,81 @@ function watchPendingTransactions(client, {
   batch = true,
   onError,
   onTransactions,
+  poll: poll_,
   pollingInterval = client.pollingInterval
 }) {
-  const observerId = JSON.stringify([
-    "watchPendingTransactions",
-    client.uid,
-    batch,
-    pollingInterval
-  ]);
-  return observe(observerId, { onTransactions, onError }, (emit) => {
-    let filter;
-    const unwatch = poll(
-      async () => {
-        try {
-          if (!filter) {
-            try {
-              filter = await createPendingTransactionFilter(client);
-              return;
-            } catch (err) {
-              unwatch();
-              throw err;
+  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
+  const pollPendingTransactions = () => {
+    const observerId = JSON.stringify([
+      "watchPendingTransactions",
+      client.uid,
+      batch,
+      pollingInterval
+    ]);
+    return observe(observerId, { onTransactions, onError }, (emit) => {
+      let filter;
+      const unwatch = poll(
+        async () => {
+          try {
+            if (!filter) {
+              try {
+                filter = await createPendingTransactionFilter(client);
+                return;
+              } catch (err) {
+                unwatch();
+                throw err;
+              }
             }
+            const hashes = await getFilterChanges(client, { filter });
+            if (hashes.length === 0)
+              return;
+            if (batch)
+              emit.onTransactions(hashes);
+            else
+              hashes.forEach((hash2) => emit.onTransactions([hash2]));
+          } catch (err) {
+            emit.onError?.(err);
           }
-          const hashes = await getFilterChanges(client, { filter });
-          if (hashes.length === 0)
-            return;
-          if (batch)
-            emit.onTransactions(hashes);
-          else
-            hashes.forEach((hash2) => emit.onTransactions([hash2]));
-        } catch (err) {
-          emit.onError?.(err);
+        },
+        {
+          emitOnBegin: true,
+          interval: pollingInterval
         }
-      },
-      {
-        emitOnBegin: true,
-        interval: pollingInterval
+      );
+      return async () => {
+        if (filter)
+          await uninstallFilter(client, { filter });
+        unwatch();
+      };
+    });
+  };
+  const subscribePendingTransactions = () => {
+    let active = true;
+    let unsubscribe = () => active = false;
+    (async () => {
+      try {
+        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+          params: ["newPendingTransactions"],
+          onData(data) {
+            if (!active)
+              return;
+            const transaction = data.result;
+            onTransactions([transaction]);
+          },
+          onError(error) {
+            onError?.(error);
+          }
+        });
+        unsubscribe = unsubscribe_;
+        if (!active)
+          unsubscribe();
+      } catch (err) {
+        onError?.(err);
       }
-    );
-    return async () => {
-      if (filter)
-        await uninstallFilter(client, { filter });
-      unwatch();
-    };
-  });
+    })();
+    return unsubscribe;
+  };
+  return enablePolling ? pollPendingTransactions() : subscribePendingTransactions();
 }
 
 // src/actions/test/dropTransaction.ts
@@ -4980,7 +5480,12 @@ async function addChain(client, { chain }) {
 }
 
 // src/actions/wallet/deployContract.ts
-function deployContract(walletClient, { abi, args, bytecode, ...request }) {
+function deployContract(walletClient, {
+  abi,
+  args,
+  bytecode,
+  ...request
+}) {
   const calldata = encodeDeployData({
     abi,
     args,
@@ -5021,10 +5526,9 @@ async function requestPermissions(client, permissions) {
 // src/actions/wallet/sendTransaction.ts
 async function sendTransaction(client, args) {
   const {
-    account,
+    account: account_ = client.account,
     chain = client.chain,
     accessList,
-    assertChain = true,
     data,
     gas,
     gasPrice,
@@ -5035,13 +5539,20 @@ async function sendTransaction(client, args) {
     value,
     ...rest
   } = args;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransaction"
+    });
+  const account = parseAccount(account_);
   try {
     assertRequest(args);
-    const currentChainId = await getChainId(client);
-    if (assertChain && chain && currentChainId !== chain?.id)
-      throw new ChainMismatchError({ chain, currentChainId });
+    const chainId = await getChainId(client);
+    if (chain !== null && chainId !== chain?.id) {
+      if (!chain)
+        throw new ChainNotFoundError();
+      throw new ChainMismatchError({ chain, currentChainId: chainId });
+    }
     if (account.type === "local") {
-      const chainId = chain?.id ?? currentChainId;
       const request2 = await prepareRequest(client, {
         account,
         accessList,
@@ -5090,15 +5601,28 @@ async function sendTransaction(client, args) {
       params: [request]
     });
   } catch (err) {
-    throw getTransactionError(err, args);
+    throw getTransactionError(err, {
+      ...args,
+      account,
+      chain: args.chain || void 0
+    });
   }
 }
 
 // src/actions/wallet/signMessage.ts
-async function signMessage(client, { account, data, message }) {
+async function signMessage(client, {
+  account: account_ = client.account,
+  data,
+  message
+}) {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const account = parseAccount(account_);
   const message_ = message || data;
   if (account.type === "local")
-    return account.signMessage(message_);
+    return account.signMessage({ message: message_ });
   return client.request({
     method: "personal_sign",
     params: [toHex(message_), account.address]
@@ -5107,12 +5631,17 @@ async function signMessage(client, { account, data, message }) {
 
 // src/actions/wallet/signTypedData.ts
 async function signTypedData(client, {
-  account,
+  account: account_ = client.account,
   domain,
   message,
   primaryType,
   types: types_
 }) {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signTypedData"
+    });
+  const account = parseAccount(account_);
   const types = {
     EIP712Domain: [
       domain?.name && { name: "name", type: "string" },
@@ -5148,47 +5677,6 @@ async function signTypedData(client, {
     params: [account.address, typedData]
   });
 }
-function validateTypedData({
-  domain,
-  message,
-  primaryType,
-  types: types_
-}) {
-  const types = types_;
-  const validateData = (struct, value_) => {
-    for (const param of struct) {
-      const { name, type: type_ } = param;
-      const type2 = type_;
-      const value = value_[name];
-      const integerMatch = type2.match(integerRegex);
-      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
-        const [_type, base, size_] = integerMatch;
-        numberToHex(value, {
-          signed: base === "int",
-          size: parseInt(size_) / 8
-        });
-      }
-      if (type2 === "address" && typeof value === "string" && !isAddress(value))
-        throw new InvalidAddressError({ address: value });
-      const bytesMatch = type2.match(bytesRegex);
-      if (bytesMatch) {
-        const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== parseInt(size_))
-          throw new BytesSizeMismatchError({
-            expectedSize: parseInt(size_),
-            givenSize: size(value)
-          });
-      }
-      const struct2 = types[type2];
-      if (struct2)
-        validateData(struct2, value);
-    }
-  };
-  if (types["EIP712Domain"] && domain)
-    validateData(types["EIP712Domain"], domain);
-  const type = types[primaryType];
-  validateData(type, message);
-}
 
 // src/actions/wallet/switchChain.ts
 async function switchChain(client, { id: id2 }) {
@@ -5262,7 +5750,17 @@ function parseGwei(ether, unit = "wei") {
 // src/utils/transaction/prepareRequest.ts
 var defaultTip = parseGwei("1.5");
 async function prepareRequest(client, args) {
-  const { account, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce } = args;
+  const {
+    account: account_,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce
+  } = args;
+  if (!account_)
+    throw new AccountNotFoundError();
+  const account = parseAccount(account_);
   const block = await getBlock(client, { blockTag: "latest" });
   const request = { ...args, from: account.address };
   if (typeof nonce === "undefined")
@@ -5299,6 +5797,400 @@ async function prepareRequest(client, args) {
   return request;
 }
 
+// src/utils/transaction/assertTransaction.ts
+function assertTransactionEIP1559(transaction) {
+  const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
+  if (chainId <= 0)
+    throw new InvalidChainIdError({ chainId });
+  if (to && !isAddress(to))
+    throw new InvalidAddressError({ address: to });
+  if (gasPrice)
+    throw new BaseError(
+      "`gasPrice` is not a valid EIP-1559 Transaction attribute."
+    );
+  if (maxFeePerGas && maxFeePerGas > 2n ** 256n - 1n)
+    throw new FeeCapTooHighError({ maxFeePerGas });
+  if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
+}
+function assertTransactionEIP2930(transaction) {
+  const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
+  if (chainId <= 0)
+    throw new InvalidChainIdError({ chainId });
+  if (to && !isAddress(to))
+    throw new InvalidAddressError({ address: to });
+  if (maxPriorityFeePerGas || maxFeePerGas)
+    throw new BaseError(
+      "`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute."
+    );
+  if (gasPrice && gasPrice > 2n ** 256n - 1n)
+    throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+}
+function assertTransactionLegacy(transaction) {
+  const {
+    chainId,
+    maxPriorityFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    to,
+    accessList
+  } = transaction;
+  if (to && !isAddress(to))
+    throw new InvalidAddressError({ address: to });
+  if (typeof chainId !== "undefined" && chainId <= 0)
+    throw new InvalidChainIdError({ chainId });
+  if (maxPriorityFeePerGas || maxFeePerGas)
+    throw new BaseError(
+      "`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute."
+    );
+  if (gasPrice && gasPrice > 2n ** 256n - 1n)
+    throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+  if (accessList)
+    throw new BaseError(
+      "`accessList` is not a valid Legacy Transaction attribute."
+    );
+}
+
+// src/utils/transaction/parseTransaction.ts
+function parseTransaction(serializedTransaction) {
+  const type = getSerializedTransactionType(serializedTransaction);
+  if (type === "eip1559")
+    return parseTransactionEIP1559(
+      serializedTransaction
+    );
+  if (type === "eip2930")
+    return parseTransactionEIP2930(
+      serializedTransaction
+    );
+  return parseTransactionLegacy(
+    serializedTransaction
+  );
+}
+function parseTransactionEIP1559(serializedTransaction) {
+  const transactionArray = fromRlp(
+    `0x${serializedTransaction.slice(4)}`,
+    "hex"
+  );
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    to,
+    value,
+    data,
+    accessList,
+    v,
+    r,
+    s
+  ] = transactionArray;
+  if (!(transactionArray.length === 9 || transactionArray.length === 12))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        ...transactionArray.length > 9 ? {
+          v,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "eip1559"
+    });
+  let transaction = {
+    chainId: hexToNumber(chainId),
+    type: "eip1559"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce) && nonce !== "0x")
+    transaction.nonce = hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(maxFeePerGas) && maxFeePerGas !== "0x")
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas);
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== "0x")
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas);
+  if (accessList.length !== 0 && accessList !== "0x")
+    transaction.accessList = parseAccessList(accessList);
+  assertTransactionEIP1559(transaction);
+  const signature = transactionArray.length === 12 ? parseEIP155Signature(transactionArray) : void 0;
+  return { ...signature, ...transaction };
+}
+function parseTransactionEIP2930(serializedTransaction) {
+  const transactionArray = fromRlp(
+    `0x${serializedTransaction.slice(4)}`,
+    "hex"
+  );
+  const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] = transactionArray;
+  if (!(transactionArray.length === 8 || transactionArray.length === 11))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        gasPrice,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        ...transactionArray.length > 8 ? {
+          v,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "eip2930"
+    });
+  let transaction = {
+    chainId: hexToNumber(chainId),
+    type: "eip2930"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce) && nonce !== "0x")
+    transaction.nonce = hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(gasPrice) && gasPrice !== "0x")
+    transaction.gasPrice = hexToBigInt(gasPrice);
+  if (accessList.length !== 0 && accessList !== "0x")
+    transaction.accessList = parseAccessList(accessList);
+  assertTransactionEIP2930(transaction);
+  const signature = transactionArray.length === 11 ? parseEIP155Signature(transactionArray) : void 0;
+  return { ...signature, ...transaction };
+}
+function parseTransactionLegacy(serializedTransaction) {
+  const transactionArray = fromRlp(serializedTransaction, "hex");
+  const [nonce, gasPrice, gas, to, value, data, chainIdOrV_, r, s] = transactionArray;
+  if (!(transactionArray.length === 6 || transactionArray.length === 9))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        nonce,
+        gasPrice,
+        gas,
+        to,
+        value,
+        data,
+        ...transactionArray.length > 6 ? {
+          v: chainIdOrV_,
+          r,
+          s
+        } : {}
+      },
+      serializedTransaction,
+      type: "legacy"
+    });
+  let transaction = {
+    type: "legacy"
+  };
+  if (isHex(to) && to !== "0x")
+    transaction.to = to;
+  if (isHex(gas) && gas !== "0x")
+    transaction.gas = hexToBigInt(gas);
+  if (isHex(data) && data !== "0x")
+    transaction.data = data;
+  if (isHex(nonce) && nonce !== "0x")
+    transaction.nonce = hexToNumber(nonce);
+  if (isHex(value) && value !== "0x")
+    transaction.value = hexToBigInt(value);
+  if (isHex(gasPrice) && gasPrice !== "0x")
+    transaction.gasPrice = hexToBigInt(gasPrice);
+  assertTransactionLegacy(transaction);
+  if (transactionArray.length === 6)
+    return transaction;
+  const chainIdOrV = isHex(chainIdOrV_) && chainIdOrV_ !== "0x" ? hexToBigInt(chainIdOrV_) : 0n;
+  if (s === "0x" && r === "0x") {
+    if (chainIdOrV > 0)
+      transaction.chainId = Number(chainIdOrV);
+    return transaction;
+  }
+  const v = chainIdOrV;
+  let chainId = Number((v - 35n) / 2n);
+  if (chainId > 0)
+    transaction.chainId = chainId;
+  else if (v !== 27n && v !== 28n)
+    throw new InvalidLegacyVError({ v });
+  transaction.v = v;
+  transaction.s = s;
+  transaction.r = r;
+  return transaction;
+}
+function parseAccessList(accessList_) {
+  let accessList = [];
+  for (let i = 0; i < accessList_.length; i++) {
+    const [address, storageKeys] = accessList_[i];
+    if (!isAddress(address))
+      throw new InvalidAddressError({ address });
+    accessList.push({
+      address,
+      storageKeys: storageKeys.map((key) => isHash(key) ? key : trim(key))
+    });
+  }
+  return accessList;
+}
+function parseEIP155Signature(transactionArray) {
+  const signature = transactionArray.slice(-3);
+  const v = signature[0] === "0x" || hexToBigInt(signature[0]) === 0n ? 27n : 28n;
+  return {
+    r: padHex(signature[1], { size: 32 }),
+    s: padHex(signature[2], { size: 32 }),
+    v,
+    yParity: v === 27n ? 0 : 1
+  };
+}
+
+// src/utils/transaction/serializeTransaction.ts
+function serializeTransaction(transaction, signature) {
+  const type = getTransactionType(transaction);
+  if (type === "eip1559")
+    return serializeTransactionEIP1559(
+      transaction,
+      signature
+    );
+  if (type === "eip2930")
+    return serializeTransactionEIP2930(
+      transaction,
+      signature
+    );
+  return serializeTransactionLegacy(
+    transaction,
+    signature
+  );
+}
+function serializeTransactionEIP1559(transaction, signature) {
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    data
+  } = transaction;
+  assertTransactionEIP1559(transaction);
+  const serializedAccessList = serializeAccessList(accessList);
+  const serializedTransaction = [
+    toHex(chainId),
+    typeof nonce !== "undefined" ? toHex(nonce) : "0x",
+    typeof maxPriorityFeePerGas !== "undefined" ? toHex(maxPriorityFeePerGas) : "0x",
+    typeof maxFeePerGas !== "undefined" ? toHex(maxFeePerGas) : "0x",
+    typeof gas !== "undefined" ? toHex(gas) : "0x",
+    to ?? "0x",
+    typeof value !== "undefined" ? toHex(value) : "0x",
+    data ?? "0x",
+    serializedAccessList
+  ];
+  if (signature)
+    serializedTransaction.push(
+      signature.v === 27n ? "0x" : toHex(1),
+      // yParity
+      signature.r,
+      signature.s
+    );
+  return concatHex([
+    "0x02",
+    toRlp(serializedTransaction)
+  ]);
+}
+function serializeTransactionEIP2930(transaction, signature) {
+  const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
+  assertTransactionEIP2930(transaction);
+  const serializedAccessList = serializeAccessList(accessList);
+  const serializedTransaction = [
+    toHex(chainId),
+    typeof nonce !== "undefined" ? toHex(nonce) : "0x",
+    typeof gasPrice !== "undefined" ? toHex(gasPrice) : "0x",
+    typeof gas !== "undefined" ? toHex(gas) : "0x",
+    to ?? "0x",
+    typeof value !== "undefined" ? toHex(value) : "0x",
+    data ?? "0x",
+    serializedAccessList
+  ];
+  if (signature)
+    serializedTransaction.push(
+      signature.v === 27n ? "0x" : toHex(1),
+      // yParity
+      signature.r,
+      signature.s
+    );
+  return concatHex([
+    "0x01",
+    toRlp(serializedTransaction)
+  ]);
+}
+function serializeTransactionLegacy(transaction, signature) {
+  const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
+  assertTransactionLegacy(transaction);
+  let serializedTransaction = [
+    typeof nonce !== "undefined" ? toHex(nonce) : "0x",
+    typeof gasPrice !== "undefined" ? toHex(gasPrice) : "0x",
+    typeof gas !== "undefined" ? toHex(gas) : "0x",
+    to ?? "0x",
+    typeof value !== "undefined" ? toHex(value) : "0x",
+    data ?? "0x"
+  ];
+  if (signature) {
+    let v = 27n + (signature.v === 27n ? 0n : 1n);
+    if (chainId > 0)
+      v = BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
+    else if (signature.v !== v)
+      throw new InvalidLegacyVError({ v: signature.v });
+    serializedTransaction = [
+      ...serializedTransaction,
+      toHex(v),
+      signature.r,
+      signature.s
+    ];
+  } else if (chainId > 0) {
+    serializedTransaction = [
+      ...serializedTransaction,
+      toHex(chainId),
+      "0x",
+      "0x"
+    ];
+  }
+  return toRlp(serializedTransaction);
+}
+function serializeAccessList(accessList) {
+  if (!accessList || accessList.length === 0)
+    return [];
+  let serializedAccessList = [];
+  for (let i = 0; i < accessList.length; i++) {
+    const { address, storageKeys } = accessList[i];
+    for (let j = 0; j < storageKeys.length; j++) {
+      if (storageKeys[j].length - 2 !== 64) {
+        throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
+      }
+    }
+    if (!isAddress(address)) {
+      throw new InvalidAddressError({ address });
+    }
+    serializedAccessList.push([address, storageKeys]);
+  }
+  return serializedAccessList;
+}
+
 // src/utils/unit/formatUnits.ts
 function formatUnits(value, decimals) {
   let display = value.toString();
@@ -5354,11 +6246,13 @@ export {
   InvalidAddressError,
   BlockNotFoundError,
   ChainDoesNotSupportContract,
+  InvalidChainIdError,
   multicall3Abi,
   panicReasons,
   etherUnits,
   gweiUnits,
   weiUnits,
+  InvalidLegacyVError,
   TransactionExecutionError,
   TransactionNotFoundError,
   TransactionReceiptNotFoundError,
@@ -5453,7 +6347,9 @@ export {
   keccak256,
   getEventSelector,
   getFunctionSelector,
+  isHash,
   isAddress,
+  checksumAddress,
   getAddress,
   getContractAddress2 as getContractAddress,
   getCreateAddress,
@@ -5481,7 +6377,7 @@ export {
   parseAbiItem,
   parseAbiParameter,
   parseAbiParameters,
-  getAccount,
+  parseAccount,
   isDeterministicError,
   buildRequest,
   defineChain,
@@ -5507,10 +6403,16 @@ export {
   getSocket,
   rpc,
   hashMessage,
+  validateTypedData,
+  hashTypedData,
   recoverAddress,
   recoverMessageAddress,
+  recoverTypedDataAddress,
   verifyMessage,
+  verifyTypedData,
   assertRequest,
+  getSerializedTransactionType,
+  getTransactionType,
   call,
   simulateContract,
   createPendingTransactionFilter,
@@ -5588,9 +6490,14 @@ export {
   parseUnits,
   parseGwei,
   prepareRequest,
+  assertTransactionEIP1559,
+  assertTransactionEIP2930,
+  assertTransactionLegacy,
+  parseTransaction,
+  serializeTransaction,
   formatUnits,
   formatEther,
   formatGwei,
   parseEther
 };
-//# sourceMappingURL=chunk-JG6MI5ZV.mjs.map
+//# sourceMappingURL=chunk-HYEOQX7O.mjs.map