viem 0.2.0-canary.20230316T020523 → 0.2.0-jxom-async-verify-message.20230321T000803

package/dist/{chunk-MWJLP6MO.mjs → chunk-FEPL5HFW.mjs}

@@ -20,7 +20,7 @@ import "abitype";
 var package_default = {
   name: "viem",
   description: "TypeScript Interface for Ethereum",
-  version: "0.1.20",
+  version: "0.1.21",
   scripts: {
     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",
@@ -218,7 +218,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 +521,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 }) {
@@ -572,7 +591,7 @@ var ChainMismatchError = class extends BaseError {
     currentChainId
   }) {
     super(
-      `The current chain (id: ${currentChainId}) does not match the chain passed to the request (id: ${chain.id} \u2013 ${chain.name}).`,
+      `The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} \u2013 ${chain.name}).`,
       {
         metaMessages: [
           `Current Chain ID:  ${currentChainId}`,
@@ -583,6 +602,17 @@ 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");
+  }
+};
 
 // src/constants/abis.ts
 var multicall3Abi = [
@@ -713,7 +743,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 +808,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 +820,7 @@ var CallExecutionError = class extends BaseError {
     to,
     value
   }) {
+    const account = account_ ? parseAccount(account_) : void 0;
     const prettyArgs = prettyPrint({
       from: account?.address,
       to,
@@ -1032,7 +1063,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,
@@ -2829,19 +2860,30 @@ function formatAbiItemWithArgs({
 }
 
 // src/utils/account.ts
-function getAccount(account) {
-  if (typeof account === "string") {
-    if (!isAddress(account))
-      throw new InvalidAddressError({ address: account });
-    return { address: account, type: "json-rpc" };
+function getAccount(source) {
+  if (typeof source === "string") {
+    if (!isAddress(source))
+      throw new InvalidAddressError({ address: source });
+    return {
+      address: source,
+      type: "json-rpc"
+    };
   }
-  if (!isAddress(account.address))
-    throw new InvalidAddressError({ address: account.address });
+  if (!isAddress(source.address))
+    throw new InvalidAddressError({ address: source.address });
   return {
-    ...account,
+    address: source.address,
+    signMessage: source.signMessage,
+    signTransaction: source.signTransaction,
+    signTypedData: source.signTypedData,
     type: "local"
   };
 }
+function parseAccount(account) {
+  if (typeof account === "string")
+    return { address: account, type: "json-rpc" };
+  return account;
+}
 
 // src/utils/promise/withCache.ts
 var promiseCache = /* @__PURE__ */ new Map();
@@ -3507,15 +3549,172 @@ ${messageBytes.length}`
   return keccak256(concat([prefixBytes, messageBytes]), to_);
 }
 
+// src/utils/signature/hashTypedData.ts
+function hashTypedData({
+  domain,
+  message,
+  primaryType,
+  types: types_
+}) {
+  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_
+  };
+  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 +3727,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))
@@ -3565,7 +3811,7 @@ function assertRequest(args) {
 // src/actions/public/call.ts
 async function call(client, args) {
   const {
-    account,
+    account: account_,
     blockNumber,
     blockTag = "latest",
     accessList,
@@ -3579,6 +3825,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 +3859,7 @@ async function call(client, args) {
   } catch (err) {
     throw getCallError(err, {
       ...args,
+      account,
       chain: client.chain
     });
   }
@@ -3625,6 +3873,7 @@ async function simulateContract(client, {
   functionName,
   ...callRequest
 }) {
+  const account = callRequest.account ? parseAccount(callRequest.account) : void 0;
   const calldata = encodeFunctionData({
     abi,
     args,
@@ -3659,7 +3908,7 @@ async function simulateContract(client, {
       args,
       docsPath: "/docs/contract/simulateContract",
       functionName,
-      sender: callRequest.account?.address
+      sender: account?.address
     });
   }
 }
@@ -3751,9 +4000,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 +4019,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 +4050,7 @@ async function estimateGas(client, args) {
   } catch (err) {
     throw getEstimateGasError(err, {
       ...args,
+      account,
       chain: client.chain
     });
   }
@@ -3810,6 +4064,7 @@ async function estimateContractGas(client, {
   functionName,
   ...request
 }) {
+  const account = parseAccount(request.account);
   const data = encodeFunctionData({
     abi,
     args,
@@ -3829,7 +4084,7 @@ async function estimateContractGas(client, {
       args,
       docsPath: "/docs/contract/simulateContract",
       functionName,
-      sender: request.account?.address
+      sender: account?.address
     });
   }
 }
@@ -4980,7 +5235,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 +5281,9 @@ async function requestPermissions(client, permissions) {
 // src/actions/wallet/sendTransaction.ts
 async function sendTransaction(client, args) {
   const {
-    account,
-    chain,
+    account: account_ = client.account,
+    chain = client.chain,
     accessList,
-    assertChain = true,
     data,
     gas,
     gasPrice,
@@ -5035,13 +5294,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,12 +5356,25 @@ 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_);
@@ -5107,12 +5386,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" },
@@ -5262,7 +5546,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")
@@ -5482,6 +5776,7 @@ export {
   parseAbiParameter,
   parseAbiParameters,
   getAccount,
+  parseAccount,
   isDeterministicError,
   buildRequest,
   defineChain,
@@ -5507,9 +5802,12 @@ export {
   getSocket,
   rpc,
   hashMessage,
+  hashTypedData,
   recoverAddress,
   recoverMessageAddress,
+  recoverTypedDataAddress,
   verifyMessage,
+  verifyTypedData,
   assertRequest,
   call,
   simulateContract,
@@ -5593,4 +5891,4 @@ export {
   formatGwei,
   parseEther
 };
-//# sourceMappingURL=chunk-MWJLP6MO.mjs.map
+//# sourceMappingURL=chunk-FEPL5HFW.mjs.map