read contract err

Author: joaquim-verges

packages/thirdweb/src/transaction/read-contract.ts

@@ -25,6 +25,7 @@ import {
   prepareMethod,
 } from "../utils/abi/prepare-method.js";
 import type { Hex } from "../utils/encoding/hex.js";
+import { extractError } from "./extract-error.js";
 
 export type ReadContractResult<outputs extends readonly AbiParameter[]> = // if the outputs are 0 length, return never, invalid case
   outputs extends { length: 0 }
@@ -211,16 +212,20 @@ export async function readContract<
     client: contract.client,
   });
 
-  const result = await eth_call(rpcRequest, {
-    data: encodedData,
-    to: contract.address,
-    from: options.from,
-  });
-  // use the prepared method to decode the result
-  const decoded = decodeAbiParameters(resolvedPreparedMethod[2], result);
-  if (Array.isArray(decoded) && decoded.length === 1) {
-    return decoded[0];
-  }
+  try {
+    const result = await eth_call(rpcRequest, {
+      data: encodedData,
+      to: contract.address,
+      from: options.from,
+    });
+    // use the prepared method to decode the result
+    const decoded = decodeAbiParameters(resolvedPreparedMethod[2], result);
+    if (Array.isArray(decoded) && decoded.length === 1) {
+      return decoded[0];
+    }
 
-  return decoded as ReadContractResult<TPreparedMethod[2]>;
+    return decoded as ReadContractResult<TPreparedMethod[2]>;
+  } catch (err) {
+    throw await extractError({ error: err, contract });
+  }
 }

packages/thirdweb/src/wallets/smart/index.ts

@@ -312,16 +312,15 @@ async function createSmartAccount(
 
       const originalMsgHash = hashMessage(message);
       // check if the account contract supports EIP721 domain separator or modular based signing
-      const [messageHash, isModularFactory] = await Promise.all([
+      const [is712Factory, isModularFactory] = await Promise.all([
         readContract({
           contract: accountContract,
           method:
             "function getMessageHash(bytes32 _hash) public view returns (bytes32)",
           params: [originalMsgHash],
-        }).catch((err) => {
-          console.error(err);
-          return undefined;
-        }),
+        })
+          .catch(() => false)
+          .then(() => true),
         readContract({
           contract: accountContract,
           method: "function canInstall(address) public view returns (bool)",
@@ -331,30 +330,15 @@ async function createSmartAccount(
           .then(() => true),
       ]);
 
-      console.log("factoryType", messageHash, isModularFactory);
+      console.log("factoryType", is712Factory, isModularFactory);
 
       let sig: `0x${string}`;
-      if (messageHash) {
+      if (is712Factory || isModularFactory) {
         const wrappedMessageHash = encodeAbiParameters(
           [{ type: "bytes32" }],
           [originalMsgHash],
         );
 
-        const hasheTypedData = hashTypedData({
-          domain: {
-            name: isModularFactory ? "DefaultValidator" : "Account",
-            version: "1",
-            chainId: options.chain.id,
-            verifyingContract: accountContract.address,
-          },
-          primaryType: "AccountMessage",
-          types: { AccountMessage: [{ name: "message", type: "bytes" }] },
-          message: { message: wrappedMessageHash },
-        });
-
-        console.log("hasheTypedData", hasheTypedData);
-        console.log("equal", messageHash === hasheTypedData);
-
         sig = await options.personalAccount.signTypedData({
           domain: {
             name: isModularFactory ? "DefaultValidator" : "Account",
@@ -368,13 +352,16 @@ async function createSmartAccount(
         });
         if (isModularFactory) {
           // add validator address
-          sig = concatHex([ZERO_ADDRESS, sig]);
+          sig = encodeAbiParameters(
+            [{ type: "address" }, { type: "bytes" }],
+            [ZERO_ADDRESS, sig],
+          );
         }
       } else {
         sig = await options.personalAccount.signMessage({ message });
       }
 
-      console.log(sig);
+      console.log("sig", sig);
 
       const isValid = await verifyContractWalletSignature({
         address: accountContract.address,

packages/thirdweb/src/wallets/smart/smart-wallet-modular.test.ts

@@ -7,9 +7,8 @@ import { prepareTransaction } from "../../transaction/prepare-transaction.js";
 import type { Address } from "../../utils/address.js";
 import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
-import { generateAccount } from "../utils/generateAccount.js";
 import { smartWallet } from "./smart-wallet.js";
-
+import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
 let wallet: Wallet;
 let smartAccount: Account;
 let smartWalletAddress: Address;
@@ -28,9 +27,10 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
   },
   () => {
     beforeAll(async () => {
-      personalAccount = await generateAccount({
-        client,
-      });
+      personalAccount = TEST_ACCOUNT_A;
+      // personalAccount = await generateAccount({
+      //   client,
+      //  });
       wallet = smartWallet({
         chain,
         gasless: true,
@@ -52,9 +52,9 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(smartWalletAddress).toHaveLength(42);
 
       // const d = decodeErrorResult({
-      //   data: "0x79bd117bb61d27f600000000000000000000000000000000000000000000000000000000",
+      //   data: "0xb927fe5e0000000000000000000000000000000000000000db72e07d8a92f3d9d30e3843",
       //   abi: await resolveContractAbi({
-      //     address: ENTRYPOINT_ADDRESS_v0_7,
+      //     address: smartWalletAddress,
       //     client,
       //     chain,
       //   }),