thirdweb 5.48.2 → 5.48.3-nightly-a8e2bc58c9e8fe5b75d6c27d406e6b80d5d067e2-20240828000339

package/src/react/core/hooks/transaction/useSendAndConfirmTransaction.ts

@@ -40,6 +40,18 @@ export type SendAndConfirmTransactionConfig = {
  *   }
  * });
  * ```
+ *
+ * ### Gasless usage with OpenZeppelin
+ * ```tsx
+ * import { useSendAndConfirmTransaction } from "thirdweb/react";
+ * const mutation = useSendAndConfirmTransaction({
+ *   gasless: {
+ *     provider: "openzeppelin",
+ *     relayerUrl: "https://...",
+ *     relayerForwarderAddress: "0x...",
+ *   }
+ * });
+ * ```
  * @transaction
  */
 export function useSendAndConfirmTransaction(

package/src/react/native/hooks/transaction/useSendTransaction.tsx

@@ -30,6 +30,17 @@ import { useSwitchActiveWalletChain } from "../../../core/hooks/wallets/useSwitc
  *   }
  * });
  * ```
+ *
+ * ### Gasless usage with OpenZeppelin
+ * ```tsx
+ * import { useSendTransaction } from "thirdweb/react";
+ * const mutation = useSendTransaction({
+ *   gasless: {
+ *     provider: "openzeppelin",
+ *     relayerUrl: "https://...",
+ *     relayerForwarderAddress: "0x...",
+ *   }
+ * });
  * @transaction
  */
 export function useSendTransaction(config: SendTransactionConfig = {}) {

package/src/react/web/ui/TransactionButton/index.tsx

@@ -115,6 +115,19 @@ import { Button } from "../components/buttons.js";
  *   ...
  * </TransactionButton>
  * ```
+ *
+ * ### Gasless usage with OpenZeppelin
+ * ```tsx
+ * <TransactionButton
+ *   gasless={{
+ *     provider: "openzeppelin",
+ *     relayerUrl: "https://...",
+ *     relayerForwarderAddress: "0x...",
+ *   }}
+ * >
+ *   ...
+ * </TransactionButton>
+ * ```
  * @component
  */
 export function TransactionButton(props: TransactionButtonProps) {

package/src/transaction/actions/send-and-confirm-transaction.ts

@@ -35,6 +35,19 @@ import { waitForReceipt } from "./wait-for-tx-receipt.js";
  *  }
  * });
  * ```
+ *
+ * ### Gasless usage with OpenZeppelin
+ * ```ts
+ * const transactionReceipt = await sendAndConfirmTransaction({
+ *  account,
+ *  transaction,
+ *  gasless: {
+ *    provider: "openzeppelin",
+ *    relayerUrl: "https://...",
+ *    relayerForwarderAddress: "0x...",
+ *  }
+ * });
+ * ```
  */
 export async function sendAndConfirmTransaction(
   options: SendTransactionOptions,

package/src/transaction/actions/send-transaction.ts

@@ -121,6 +121,19 @@ export interface SendTransactionOptions {
  *  }
  * });
  * ```
+ *
+ * ### Gasless usage with OpenZeppelin
+ * ```ts
+ * const { transactionHash } = await sendTransaction({
+ *  account,
+ *  transaction,
+ *  gasless: {
+ *    provider: "openzeppelin",
+ *    relayerUrl: "https://...",
+ *    relayerForwarderAddress: "0x...",
+ *  }
+ * });
+ * ```
  */
 export async function sendTransaction(
   options: SendTransactionOptions,

package/src/transaction/actions/zksync/send-eip712-transaction.ts

@@ -131,7 +131,7 @@ export async function populateEip712Transaction(
     const baseFee = toBigInt(result.max_fee_per_gas);
     maxFeePerGas = baseFee * 2n; // bumping the base fee per gas to ensure fast inclusion
     maxPriorityFeePerGas = toBigInt(result.max_priority_fee_per_gas) || 1n;
-    gasPerPubdata = toBigInt(result.gas_per_pubdata_limit);
+    gasPerPubdata = toBigInt(result.gas_per_pubdata_limit) * 2n; // doubling for fast inclusion;
   }
 
   // serialize the transaction (with fees, gas, nonce)

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.48.2";
+export const version = "5.48.3-nightly-a8e2bc58c9e8fe5b75d6c27d406e6b80d5d067e2-20240828000339";

package/src/wallets/in-app/web/lib/in-app-account.ts

@@ -304,6 +304,7 @@ export class IFrameWallet {
         return signedMessage as Hex;
       },
       async signTypedData(_typedData) {
+        console.log("signTypedData", _typedData);
         const parsedTypedData = parseTypedData(_typedData);
         // deleting EIP712 Domain as it results in ambiguous primary type on some cases
         // this happens when going from viem to ethers via the iframe
@@ -312,8 +313,11 @@ export class IFrameWallet {
         }
         const domain = parsedTypedData.domain as TypedDataDefinition["domain"];
         const chainId = domain?.chainId;
+        const verifyingContract = domain?.verifyingContract
+          ? { verifyingContract: domain?.verifyingContract }
+          : {};
         const domainData = {
-          verifyingContract: domain?.verifyingContract,
+          ...verifyingContract,
           name: domain?.name,
           version: domain?.version,
         };

package/src/wallets/in-app/web/utils/iFrameCommunication/IframeCommunicator.ts

@@ -23,6 +23,7 @@ const iframeBaseStyle = {
   right: "0px",
   zIndex: "2147483646",
   display: "none",
+  pointerEvents: "all",
 };
 
 // Global var to help track iframe state

package/src/wallets/smart/index.ts

@@ -42,7 +42,7 @@ import {
   prepareBatchExecute,
   prepareExecute,
 } from "./lib/calls.js";
-import { DEFAULT_ACCOUNT_FACTORY } from "./lib/constants.js";
+import { getDefaultAccountFactory } from "./lib/constants.js";
 import {
   createUnsignedUserOp,
   signUserOp,
@@ -50,11 +50,13 @@ import {
 } from "./lib/userop.js";
 import { isNativeAAChain } from "./lib/utils.js";
 import type {
+  BundlerOptions,
   PaymasterResult,
   SmartAccountOptions,
   SmartWalletConnectionOptions,
   SmartWalletOptions,
-  UserOperation,
+  UserOperationV06,
+  UserOperationV07,
 } from "./types.js";
 
 /**
@@ -95,7 +97,9 @@ export async function connectSmartWallet(
   }
 
   const options = creationOptions;
-  const factoryAddress = options.factoryAddress ?? DEFAULT_ACCOUNT_FACTORY;
+  const factoryAddress =
+    options.factoryAddress ??
+    getDefaultAccountFactory(creationOptions.overrides?.entrypointAddress);
   const chain = connectChain ?? options.chain;
   const sponsorGas =
     "gasless" in options ? options.gasless : options.sponsorGas;
@@ -182,7 +186,9 @@ async function createSmartAccount(
       const erc20Paymaster = options.overrides?.erc20Paymaster;
       let paymasterOverride:
         | undefined
-        | ((userOp: UserOperation) => Promise<PaymasterResult>) = undefined;
+        | ((
+            userOp: UserOperationV06 | UserOperationV07,
+          ) => Promise<PaymasterResult>) = undefined;
       if (erc20Paymaster) {
         await approveERC20({
           accountContract,
@@ -195,6 +201,9 @@ async function createSmartAccount(
               erc20Paymaster.address as Hex,
               erc20Paymaster?.token as Hex,
             ]),
+            // for 0.7 compatibility
+            paymaster: erc20Paymaster.address as Hex,
+            paymasterData: "0x",
           };
         };
         paymasterOverride = options.overrides?.paymaster || paymasterCallback;
@@ -567,13 +576,20 @@ async function _sendUserOp(args: {
     overrides: options.overrides,
   });
   const signedUserOp = await signUserOp({
+    client: options.client,
     chain: options.chain,
     adminAccount: options.personalAccount,
     entrypointAddress: options.overrides?.entrypointAddress,
     userOp: unsignedUserOp,
   });
+  const bundlerOptions: BundlerOptions = {
+    chain: options.chain,
+    client: options.client,
+    bundlerUrl: options.overrides?.bundlerUrl,
+    entrypointAddress: options.overrides?.entrypointAddress,
+  };
   const userOpHash = await bundleUserOp({
-    options,
+    options: bundlerOptions,
     userOp: signedUserOp,
   });
   // wait for tx receipt rather than return the userOp hash

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

@@ -1,6 +1,7 @@
 import { type TransactionSerializable, decodeErrorResult } from "viem";
 import { parseEventLogs } from "../../../event/actions/parse-logs.js";
 import { userOperationRevertReasonEvent } from "../../../extensions/erc4337/__generated__/IEntryPoint/events/UserOperationRevertReason.js";
+import { postOpRevertReasonEvent } from "../../../extensions/erc4337/__generated__/IEntryPoint_v07/events/PostOpRevertReason.js";
 import type { TransactionReceipt } from "../../../transaction/types.js";
 import { type Hex, hexToBigInt } from "../../../utils/encoding/hex.js";
 import { getClientFetch } from "../../../utils/fetch.js";
@@ -10,8 +11,9 @@ import {
   type EstimationResult,
   type GasPriceResult,
   type PmTransactionData,
-  type UserOperation,
   type UserOperationReceipt,
+  type UserOperationV06,
+  type UserOperationV07,
   formatUserOperationReceipt,
 } from "../types.js";
 import {
@@ -19,6 +21,7 @@ import {
   ENTRYPOINT_ADDRESS_v0_6,
   MANAGED_ACCOUNT_GAS_BUFFER,
   getDefaultBundlerUrl,
+  getEntryPointVersion,
 } from "./constants.js";
 import { hexlifyUserOp } from "./utils.js";
 
@@ -38,7 +41,7 @@ import { hexlifyUserOp } from "./utils.js";
  * @walletUtils
  */
 export async function bundleUserOp(args: {
-  userOp: UserOperation;
+  userOp: UserOperationV06 | UserOperationV07;
   options: BundlerOptions;
 }): Promise<Hex> {
   return sendBundlerRequest({
@@ -67,7 +70,7 @@ export async function bundleUserOp(args: {
  * @walletUtils
  */
 export async function estimateUserOpGas(args: {
-  userOp: UserOperation;
+  userOp: UserOperationV06 | UserOperationV07;
   options: BundlerOptions;
 }): Promise<EstimationResult> {
   const res = await sendBundlerRequest({
@@ -85,6 +88,14 @@ export async function estimateUserOpGas(args: {
     verificationGas: hexToBigInt(res.verificationGas),
     verificationGasLimit: hexToBigInt(res.verificationGasLimit),
     callGasLimit: hexToBigInt(res.callGasLimit) + MANAGED_ACCOUNT_GAS_BUFFER,
+    paymasterVerificationGasLimit:
+      res.paymasterVerificationGasLimit !== undefined
+        ? hexToBigInt(res.paymasterVerificationGasLimit)
+        : undefined,
+    paymasterPostOpGasLimit:
+      res.paymasterPostOpGasLimit !== undefined
+        ? hexToBigInt(res.paymasterPostOpGasLimit)
+        : undefined,
   };
 }
 
@@ -147,7 +158,7 @@ export async function getUserOpReceipt(
   if (res.success === false) {
     // parse revert reason
     const logs = parseEventLogs({
-      events: [userOperationRevertReasonEvent()],
+      events: [userOperationRevertReasonEvent(), postOpRevertReasonEvent()],
       logs: res.logs,
     });
     const revertReason = logs[0]?.args?.revertReason;
@@ -258,7 +269,12 @@ async function sendBundlerRequest(args: {
     console.debug(`>>> sending ${operation} with payload:`, params);
   }
 
-  const bundlerUrl = options.bundlerUrl ?? getDefaultBundlerUrl(options.chain);
+  const entryPointVersion = getEntryPointVersion(
+    options.entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+  );
+  const bundlerVersion = entryPointVersion === "v0.6" ? "v1" : "v2";
+  const bundlerUrl =
+    options.bundlerUrl ?? getDefaultBundlerUrl(options.chain, bundlerVersion);
   const fetchWithHeaders = getClientFetch(options.client);
   const response = await fetchWithHeaders(bundlerUrl, {
     method: "POST",

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

@@ -1,4 +1,5 @@
 import type { Chain } from "../../../chains/types.js";
+import { getAddress } from "../../../utils/address.js";
 import { getThirdwebDomains } from "../../../utils/domains.js";
 
 // dev only
@@ -7,31 +8,49 @@ export const DEBUG = false;
 export const DUMMY_SIGNATURE =
   "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
 
-export const DEFAULT_ACCOUNT_FACTORY =
+export const DEFAULT_ACCOUNT_FACTORY_V0_6 =
   "0x85e23b94e7F5E9cC1fF78BCe78cfb15B81f0DF00";
+export const DEFAULT_ACCOUNT_FACTORY_V0_7 =
+  "0x4be0ddfebca9a5a4a617dee4dece99e7c862dceb";
 
 export const ENTRYPOINT_ADDRESS_v0_6 =
   "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789"; // v0.6
+export const ENTRYPOINT_ADDRESS_v0_7 =
+  "0x0000000071727De22E5E9d8BAf0edAc6f37da032"; // v0.7
+
 export const MANAGED_ACCOUNT_GAS_BUFFER = 50000n;
 
-/**
+/*
  * @internal
  */
-export const getDefaultBundlerUrl = (chain: Chain) => {
-  const domain = getThirdwebDomains().bundler;
-  if (domain.startsWith("localhost:")) {
-    return `http://${domain}?chain=${chain.id}`;
+export const getDefaultAccountFactory = (entryPointAddress?: string) => {
+  const version = getEntryPointVersion(
+    entryPointAddress || ENTRYPOINT_ADDRESS_v0_6,
+  );
+  if (version === "v0.7") {
+    return DEFAULT_ACCOUNT_FACTORY_V0_7;
   }
-  return `https://${chain.id}.${domain}/`;
+  return DEFAULT_ACCOUNT_FACTORY_V0_6;
 };
 
 /**
  * @internal
  */
-export const getDefaultPaymasterUrl = (chain: Chain) => {
+export const getDefaultBundlerUrl = (chain: Chain, version: "v1" | "v2") => {
   const domain = getThirdwebDomains().bundler;
   if (domain.startsWith("localhost:")) {
-    return `http://${domain}?chain=${chain.id}`;
+    return `http://${domain}/${version ?? "v1"}?chain=${chain.id}`;
+  }
+  return `https://${chain.id}.${domain}/${version ?? "v1"}`;
+};
+
+export const getEntryPointVersion = (address: string): "v0.6" | "v0.7" => {
+  const checksummedAddress = getAddress(address);
+  if (checksummedAddress === ENTRYPOINT_ADDRESS_v0_6) {
+    return "v0.6";
+  }
+  if (checksummedAddress === ENTRYPOINT_ADDRESS_v0_7) {
+    return "v0.7";
   }
-  return `https://${chain.id}.${domain}/`;
+  throw new Error("Unknown paymaster version");
 };

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

@@ -0,0 +1,79 @@
+import { type Hex, concat, pad, slice, toHex } from "viem";
+import type { PackedUserOperation, UserOperationV07 } from "../types.js";
+
+export function getInitCode(unpackedUserOperation: UserOperationV07) {
+  return unpackedUserOperation.factory
+    ? concat([
+        unpackedUserOperation.factory as Hex,
+        unpackedUserOperation.factoryData || ("0x" as Hex),
+      ])
+    : "0x";
+}
+
+export function getAccountGasLimits(unpackedUserOperation: UserOperationV07) {
+  return concat([
+    pad(toHex(unpackedUserOperation.verificationGasLimit), {
+      size: 16,
+    }),
+    pad(toHex(unpackedUserOperation.callGasLimit), { size: 16 }),
+  ]) as Hex;
+}
+
+export function unpackAccountGasLimits(accountGasLimits: Hex) {
+  return {
+    verificationGasLimit: BigInt(slice(accountGasLimits, 0, 16)),
+    callGasLimit: BigInt(slice(accountGasLimits, 16)),
+  };
+}
+
+export function getGasLimits(unpackedUserOperation: UserOperationV07) {
+  return concat([
+    pad(toHex(unpackedUserOperation.maxPriorityFeePerGas), {
+      size: 16,
+    }),
+    pad(toHex(unpackedUserOperation.maxFeePerGas), { size: 16 }),
+  ]) as Hex;
+}
+
+export function unpackGasLimits(gasLimits: Hex) {
+  return {
+    maxPriorityFeePerGas: BigInt(slice(gasLimits, 0, 16)),
+    maxFeePerGas: BigInt(slice(gasLimits, 16)),
+  };
+}
+
+export function getPaymasterAndData(unpackedUserOperation: UserOperationV07) {
+  return unpackedUserOperation.paymaster
+    ? concat([
+        unpackedUserOperation.paymaster as Hex,
+        pad(
+          toHex(
+            unpackedUserOperation.paymasterVerificationGasLimit || BigInt(0),
+          ),
+          {
+            size: 16,
+          },
+        ),
+        pad(toHex(unpackedUserOperation.paymasterPostOpGasLimit || BigInt(0)), {
+          size: 16,
+        }),
+        unpackedUserOperation.paymasterData || ("0x" as Hex),
+      ])
+    : "0x";
+}
+
+export const getPackedUserOperation = (
+  userOperation: UserOperationV07,
+): PackedUserOperation => {
+  return {
+    sender: userOperation.sender,
+    nonce: userOperation.nonce,
+    initCode: getInitCode(userOperation),
+    callData: userOperation.callData,
+    accountGasLimits: getAccountGasLimits(userOperation),
+    preVerificationGas: userOperation.preVerificationGas,
+    gasFees: getGasLimits(userOperation),
+    paymasterAndData: getPaymasterAndData(userOperation),
+    signature: userOperation.signature,
+  };
+};

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

@@ -2,11 +2,16 @@ import type { Chain } from "../../../chains/types.js";
 import type { ThirdwebClient } from "../../../client/client.js";
 import { hexToBigInt } from "../../../utils/encoding/hex.js";
 import { getClientFetch } from "../../../utils/fetch.js";
-import type { PaymasterResult, UserOperation } from "../types.js";
+import type {
+  PaymasterResult,
+  UserOperationV06,
+  UserOperationV07,
+} from "../types.js";
 import {
   DEBUG,
   ENTRYPOINT_ADDRESS_v0_6,
-  getDefaultPaymasterUrl,
+  getDefaultBundlerUrl,
+  getEntryPointVersion,
 } from "./constants.js";
 import { hexlifyUserOp } from "./utils.js";
 
@@ -29,11 +34,13 @@ import { hexlifyUserOp } from "./utils.js";
  * @walletUtils
  */
 export async function getPaymasterAndData(args: {
-  userOp: UserOperation;
+  userOp: UserOperationV06 | UserOperationV07;
   client: ThirdwebClient;
   chain: Chain;
   entrypointAddress?: string;
-  paymasterOverride?: (userOp: UserOperation) => Promise<PaymasterResult>;
+  paymasterOverride?: (
+    userOp: UserOperationV06 | UserOperationV07,
+  ) => Promise<PaymasterResult>;
 }): Promise<PaymasterResult> {
   const { userOp, paymasterOverride, client, chain, entrypointAddress } = args;
 
@@ -45,8 +52,10 @@ export async function getPaymasterAndData(args: {
     "Content-Type": "application/json",
   };
 
-  const paymasterUrl = getDefaultPaymasterUrl(chain);
   const entrypoint = entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6;
+  const entrypointVersion = getEntryPointVersion(entrypoint);
+  const paymasterVersion = entrypointVersion === "v0.6" ? "v1" : "v2";
+  const paymasterUrl = getDefaultBundlerUrl(chain, paymasterVersion);
 
   // Ask the paymaster to sign the transaction and return a valid paymasterAndData value.
   const fetchWithHeaders = getClientFetch(client);
@@ -95,6 +104,14 @@ Code: ${code}`,
       callGasLimit: res.result.callGasLimit
         ? hexToBigInt(res.result.callGasLimit)
         : undefined,
+      paymaster: res.result.paymaster,
+      paymasterData: res.result.paymasterData,
+      paymasterVerificationGasLimit: res.result.paymasterVerificationGasLimit
+        ? hexToBigInt(res.result.paymasterVerificationGasLimit)
+        : undefined,
+      paymasterPostOpGasLimit: res.result.paymasterPostOpGasLimit
+        ? hexToBigInt(res.result.paymasterPostOpGasLimit)
+        : undefined,
     };
   }
   const error =