thirdweb 5.74.0 → 5.75.0

package/src/wallets/smart/lib/signing.ts

@@ -0,0 +1,231 @@
+import type * as ox__TypedData from "ox/TypedData";
+import { serializeErc6492Signature } from "../../../auth/serialize-erc6492-signature.js";
+import { verifyHash } from "../../../auth/verify-hash.js";
+import {
+  type ThirdwebContract,
+  getContract,
+} from "../../../contract/contract.js";
+import { encode } from "../../../transaction/actions/encode.js";
+import { readContract } from "../../../transaction/read-contract.js";
+import { encodeAbiParameters } from "../../../utils/abi/encodeAbiParameters.js";
+import type { Hex } from "../../../utils/encoding/hex.js";
+import { hashMessage } from "../../../utils/hashing/hashMessage.js";
+import { hashTypedData } from "../../../utils/hashing/hashTypedData.js";
+import type { SignableMessage } from "../../../utils/types.js";
+import type { SmartAccountOptions } from "../types.js";
+import { prepareCreateAccount } from "./calls.js";
+
+export async function deployAndSignMessage({
+  accountContract,
+  factoryContract,
+  options,
+  message,
+}: {
+  accountContract: ThirdwebContract;
+  factoryContract: ThirdwebContract;
+  options: SmartAccountOptions;
+  message: SignableMessage;
+}) {
+  const originalMsgHash = hashMessage(message);
+  const is712Factory = await checkFor712Factory({
+    factoryContract,
+    accountContract,
+    originalMsgHash,
+  });
+
+  let sig: `0x${string}`;
+  if (is712Factory) {
+    const wrappedMessageHash = encodeAbiParameters(
+      [{ type: "bytes32" }],
+      [originalMsgHash],
+    );
+
+    sig = await options.personalAccount.signTypedData({
+      domain: {
+        name: "Account",
+        version: "1",
+        chainId: options.chain.id,
+        verifyingContract: accountContract.address,
+      },
+      primaryType: "AccountMessage",
+      types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+      message: { message: wrappedMessageHash },
+    });
+  } else {
+    sig = await options.personalAccount.signMessage({ message });
+  }
+
+  const deployTx = prepareCreateAccount({
+    factoryContract,
+    adminAddress: options.personalAccount.address,
+    accountSalt: options.overrides?.accountSalt,
+    createAccountOverride: options.overrides?.createAccount,
+  });
+  if (!deployTx) {
+    throw new Error("Create account override not provided");
+  }
+  const initCode = await encode(deployTx);
+  const erc6492Sig = serializeErc6492Signature({
+    address: factoryContract.address,
+    data: initCode,
+    signature: sig,
+  });
+
+  // check if the signature is valid
+  const isValid = await verifyHash({
+    hash: originalMsgHash,
+    signature: erc6492Sig,
+    address: accountContract.address,
+    chain: accountContract.chain,
+    client: accountContract.client,
+  });
+
+  if (isValid) {
+    return erc6492Sig;
+  }
+  throw new Error(
+    "Unable to verify signature on smart account, please make sure the admin wallet has permissions and the signature is valid.",
+  );
+}
+
+export async function deployAndSignTypedData<
+  const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+>({
+  accountContract,
+  factoryContract,
+  options,
+  typedData,
+}: {
+  accountContract: ThirdwebContract;
+  factoryContract: ThirdwebContract;
+  options: SmartAccountOptions;
+  typedData: ox__TypedData.Definition<typedData, primaryType>;
+}) {
+  const isSelfVerifyingContract =
+    (
+      typedData.domain as ox__TypedData.Domain
+    )?.verifyingContract?.toLowerCase() ===
+    accountContract.address?.toLowerCase();
+
+  if (isSelfVerifyingContract) {
+    // if the contract is self-verifying, we can just sign the message with the EOA (ie. adding a session key)
+    return options.personalAccount.signTypedData(typedData);
+  }
+
+  const originalMsgHash = hashTypedData(typedData);
+  // check if the account contract supports EIP721 domain separator based signing
+  const is712Factory = await checkFor712Factory({
+    factoryContract,
+    accountContract,
+    originalMsgHash,
+  });
+
+  let sig: `0x${string}`;
+  if (is712Factory) {
+    const wrappedMessageHash = encodeAbiParameters(
+      [{ type: "bytes32" }],
+      [originalMsgHash],
+    );
+    sig = await options.personalAccount.signTypedData({
+      domain: {
+        name: "Account",
+        version: "1",
+        chainId: options.chain.id,
+        verifyingContract: accountContract.address,
+      },
+      primaryType: "AccountMessage",
+      types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+      message: { message: wrappedMessageHash },
+    });
+  } else {
+    sig = await options.personalAccount.signTypedData(typedData);
+  }
+
+  const deployTx = prepareCreateAccount({
+    factoryContract,
+    adminAddress: options.personalAccount.address,
+    accountSalt: options.overrides?.accountSalt,
+    createAccountOverride: options.overrides?.createAccount,
+  });
+  if (!deployTx) {
+    throw new Error("Create account override not provided");
+  }
+  const initCode = await encode(deployTx);
+  const erc6492Sig = serializeErc6492Signature({
+    address: factoryContract.address,
+    data: initCode,
+    signature: sig,
+  });
+
+  // check if the signature is valid
+  const isValid = await verifyHash({
+    hash: originalMsgHash,
+    signature: erc6492Sig,
+    address: accountContract.address,
+    chain: accountContract.chain,
+    client: accountContract.client,
+  });
+
+  if (isValid) {
+    return erc6492Sig;
+  }
+  throw new Error(
+    "Unable to verify signature on smart account, please make sure the admin wallet has permissions and the signature is valid.",
+  );
+}
+
+export async function confirmContractDeployment(args: {
+  accountContract: ThirdwebContract;
+}) {
+  const { accountContract } = args;
+  const startTime = Date.now();
+  const timeout = 60000; // wait 1 minute max
+  const { isContractDeployed } = await import(
+    "../../../utils/bytecode/is-contract-deployed.js"
+  );
+  let isDeployed = await isContractDeployed(accountContract);
+  while (!isDeployed) {
+    if (Date.now() - startTime > timeout) {
+      throw new Error(
+        "Timeout: Smart account deployment not confirmed after 1 minute",
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    isDeployed = await isContractDeployed(accountContract);
+  }
+}
+
+async function checkFor712Factory({
+  factoryContract,
+  accountContract,
+  originalMsgHash,
+}: {
+  factoryContract: ThirdwebContract;
+  accountContract: ThirdwebContract;
+  originalMsgHash: Hex;
+}) {
+  try {
+    const implementationAccount = await readContract({
+      contract: factoryContract,
+      method: "function accountImplementation() public view returns (address)",
+    });
+    // check if the account contract supports EIP721 domain separator or modular based signing
+    const is712Factory = await readContract({
+      contract: getContract({
+        address: implementationAccount,
+        chain: accountContract.chain,
+        client: accountContract.client,
+      }),
+      method:
+        "function getMessageHash(bytes32 _hash) public view returns (bytes32)",
+      params: [originalMsgHash],
+    })
+      .then((res) => res !== "0x")
+      .catch(() => false);
+
+    return is712Factory;
+  } catch {
+    return false;
+  }
+}

package/src/wallets/smart/lib/userop.ts

@@ -632,6 +632,7 @@ async function getAccountInitCode(options: {
   accountSalt?: string;
   createAccountOverride?: (
     factoryContract: ThirdwebContract,
+    adminAddress: string,
   ) => PreparedTransaction;
 }): Promise<Hex> {
   const { factoryContract, adminAddress, accountSalt, createAccountOverride } =
@@ -651,7 +652,7 @@ async function getAccountNonce(options: {
   client: ThirdwebClient;
   entrypointAddress?: string;
   getNonceOverride?: (accountContract: ThirdwebContract) => Promise<bigint>;
-}) {
+}): Promise<bigint> {
   const {
     accountContract,
     chain,
@@ -662,7 +663,7 @@ async function getAccountNonce(options: {
   if (getNonceOverride) {
     return getNonceOverride(accountContract);
   }
-  return getNonce({
+  return await getNonce({
     contract: getContract({
       address: entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
       chain,

package/src/wallets/smart/presets/7579.ts

@@ -0,0 +1,269 @@
+import { AbiParameters, Hex } from "ox";
+import { serializeErc6492Signature } from "../../../auth/serialize-erc6492-signature.js";
+import { verifyHash } from "../../../auth/verify-hash.js";
+import { ZERO_ADDRESS } from "../../../constants/addresses.js";
+import {
+  type ThirdwebContract,
+  getContract,
+} from "../../../contract/contract.js";
+import { getNonce } from "../../../extensions/erc4337/__generated__/IEntryPoint/read/getNonce.js";
+import { execute } from "../../../extensions/erc7579/__generated__/IERC7579Account/write/execute.js";
+import { createAccountWithModules } from "../../../extensions/erc7579/__generated__/ModularAccountFactory/write/createAccountWithModules.js";
+import { encode } from "../../../transaction/actions/encode.js";
+import type { PreparedTransaction } from "../../../transaction/prepare-transaction.js";
+import { readContract } from "../../../transaction/read-contract.js";
+import { encodeAbiParameters } from "../../../utils/abi/encodeAbiParameters.js";
+import { getAddress } from "../../../utils/address.js";
+import { hashMessage } from "../../../utils/hashing/hashMessage.js";
+import { hashTypedData } from "../../../utils/hashing/hashTypedData.js";
+import type { Account } from "../../interfaces/wallet.js";
+import { ENTRYPOINT_ADDRESS_v0_7 } from "../lib/constants.js";
+import { generateRandomUint192 } from "../lib/utils.js";
+import type { SmartWalletOptions } from "../types.js";
+
+export type ERC7579Config = SmartWalletOptions & {
+  validatorAddress: string;
+  factoryAddress: string;
+};
+
+/**
+ * Config for a ERC7579 modular smart wallet.
+ *
+ * This configuration is in BETA, expect breaking changes.
+ *
+ * @param options - Optional overrides for the smart wallet.
+ * @returns The smart wallet options.
+ *
+ * @example
+ * ```typescript
+ * import { sepolia } from "thirdweb/chains";
+ * import { smartWallet, Config } from "thirdweb/wallets/smart";
+ *
+ * const modularSmartWallet = smartWallet(
+ *   Config.erc7579({
+ *     chain: sepolia,
+ *     sponsorGas: true,
+ *     factoryAddress: "0x...", // the 7579 factory address
+ *     validatorAddress: "0x...", // the default validator module address
+ *   }),
+ * });
+ * ```
+ *
+ * @wallet
+ * @extension ERC7579
+ * @beta
+ */
+export function erc7579(options: ERC7579Config): SmartWalletOptions {
+  const saltHex =
+    options.overrides?.accountSalt &&
+    Hex.validate(options.overrides.accountSalt)
+      ? options.overrides.accountSalt
+      : Hex.fromString(options.overrides?.accountSalt ?? "");
+  const defaultValidator = getAddress(options.validatorAddress);
+  const modularAccountOptions: SmartWalletOptions = {
+    ...options,
+    factoryAddress: options.factoryAddress,
+    overrides: {
+      entrypointAddress: ENTRYPOINT_ADDRESS_v0_7,
+      createAccount(factoryContract, admin) {
+        // TODO (msa) - let ppl pass whatever modules they want here
+        return createAccountWithModules({
+          contract: factoryContract,
+          asyncParams: async () => {
+            // default validator
+            const modules = [
+              {
+                moduleTypeId: 1n, // validator type id
+                module: defaultValidator,
+                initData: Hex.fromString(""),
+              },
+            ];
+            return {
+              owner: admin,
+              salt: saltHex,
+              modules,
+            };
+          },
+        });
+      },
+      async predictAddress(factoryContract, admin) {
+        return readContract({
+          contract: factoryContract,
+          method:
+            "function getAddress(address owner, bytes salt) returns (address)",
+          params: [admin, saltHex],
+        });
+      },
+      execute(accountContract, transaction) {
+        return execute({
+          contract: accountContract,
+          async asyncParams() {
+            return {
+              mode: Hex.padRight("0x00", 32), // single execution
+              executionCalldata: AbiParameters.encodePacked(
+                ["address", "uint256", "bytes"],
+                [
+                  transaction.to || ZERO_ADDRESS,
+                  transaction.value || 0n,
+                  transaction.data || "0x",
+                ],
+              ),
+            };
+          },
+        });
+      },
+      executeBatch(accountContract, transactions) {
+        return execute({
+          contract: accountContract,
+          async asyncParams() {
+            return {
+              mode: Hex.padRight("0x01", 32), // batch execution
+              executionCalldata: AbiParameters.encode(
+                [
+                  {
+                    type: "tuple[]",
+                    components: [
+                      { type: "address", name: "to" },
+                      { type: "uint256", name: "value" },
+                      { type: "bytes", name: "data" },
+                    ],
+                  },
+                ],
+                [
+                  transactions.map((t) => ({
+                    to: t.to || ZERO_ADDRESS,
+                    value: t.value || 0n,
+                    data: t.data || "0x",
+                  })),
+                ],
+              ),
+            };
+          },
+        });
+      },
+      async getAccountNonce(accountContract) {
+        const entryPointNonce = await getNonce({
+          contract: getContract({
+            address: ENTRYPOINT_ADDRESS_v0_7,
+            chain: accountContract.chain,
+            client: accountContract.client,
+          }),
+          key: generateRandomUint192(),
+          sender: accountContract.address,
+        });
+        // TODO (msa) - could be different if validator for the deployed account is different
+        const withValidator = Hex.from(
+          `${defaultValidator}${Hex.fromNumber(entryPointNonce).slice(42)}`,
+        );
+        return Hex.toBigInt(withValidator);
+      },
+      async signMessage(options) {
+        const { accountContract, factoryContract, adminAccount, message } =
+          options;
+        const originalMsgHash = hashMessage(message);
+        const createAccount = modularAccountOptions.overrides?.createAccount;
+        if (!createAccount) {
+          throw new Error("Create account override not provided");
+        }
+        return generateSignature({
+          accountContract,
+          factoryContract,
+          adminAccount,
+          originalMsgHash,
+          defaultValidator,
+          createAccount,
+        });
+      },
+      async signTypedData(options) {
+        const { accountContract, factoryContract, adminAccount, typedData } =
+          options;
+        const originalMsgHash = hashTypedData(typedData);
+        const createAccount = modularAccountOptions.overrides?.createAccount;
+        if (!createAccount) {
+          throw new Error("Create account override not provided");
+        }
+        return generateSignature({
+          accountContract,
+          factoryContract,
+          adminAccount,
+          originalMsgHash,
+          defaultValidator,
+          createAccount,
+        });
+      },
+      ...options.overrides,
+    },
+  };
+  return modularAccountOptions;
+}
+
+async function generateSignature(options: {
+  accountContract: ThirdwebContract;
+  factoryContract: ThirdwebContract;
+  adminAccount: Account;
+  originalMsgHash: Hex.Hex;
+  defaultValidator: string;
+  createAccount: (
+    factoryContract: ThirdwebContract,
+    admin: string,
+  ) => PreparedTransaction;
+}) {
+  const {
+    accountContract,
+    factoryContract,
+    adminAccount,
+    originalMsgHash,
+    defaultValidator,
+    createAccount,
+  } = options;
+  const wrappedMessageHash = encodeAbiParameters(
+    [{ type: "bytes32" }],
+    [originalMsgHash],
+  );
+
+  const rawSig = await adminAccount.signTypedData({
+    domain: {
+      // TODO (msa) - assumes our default validator here
+      name: "DefaultValidator",
+      version: "1",
+      chainId: accountContract.chain.id,
+      verifyingContract: defaultValidator,
+    },
+    primaryType: "AccountMessage",
+    types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+    message: { message: wrappedMessageHash },
+  });
+
+  // add the validator address to the signature
+  const sig = encodeAbiParameters(
+    [{ type: "address" }, { type: "bytes" }],
+    [defaultValidator, rawSig],
+  );
+
+  const deployTx = createAccount(factoryContract, adminAccount.address);
+  if (!deployTx) {
+    throw new Error("Create account override not provided");
+  }
+  const initCode = await encode(deployTx);
+  const erc6492Sig = serializeErc6492Signature({
+    address: factoryContract.address,
+    data: initCode,
+    signature: sig,
+  });
+
+  // check if the signature is valid
+  const isValid = await verifyHash({
+    hash: originalMsgHash,
+    signature: erc6492Sig,
+    address: accountContract.address,
+    chain: accountContract.chain,
+    client: accountContract.client,
+  });
+
+  if (!isValid) {
+    throw new Error(
+      `Something went wrong generating the signature for modular smart account: ${accountContract.address} on chain ${accountContract.chain.id}`,
+    );
+  }
+  return erc6492Sig;
+}

package/src/wallets/smart/presets/index.ts

@@ -0,0 +1 @@
+export { erc7579, type ERC7579Config } from "./7579.js";

package/src/wallets/smart/smart-wallet-dev.test.ts

@@ -1,5 +1,6 @@
 import { beforeAll, describe, expect, it } from "vitest";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
 import { defineChain } from "../../chains/utils.js";
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { balanceOf } from "../../extensions/erc1155/__generated__/IERC1155/read/balanceOf.js";
@@ -12,7 +13,6 @@ import type { Address } from "../../utils/address.js";
 import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
 import { setThirdwebDomains } from "../../utils/domains.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
-import { generateAccount } from "../utils/generateAccount.js";
 import { smartWallet } from "./smart-wallet.js";
 
 let wallet: Wallet;
@@ -41,9 +41,10 @@ describe.runIf(process.env.TW_SECRET_KEY).skip.sequential(
         storage: "storage.thirdweb-dev.com",
         bundler: "bundler.thirdweb-dev.com",
       });
-      personalAccount = await generateAccount({
-        client,
-      });
+      personalAccount = TEST_ACCOUNT_A;
+      // personalAccount = await generateAccount({
+      //   client,
+      // });
       wallet = smartWallet({
         chain,
         gasless: true,