thirdweb 5.35.0-nightly-39b329a56e9eb031e1799524d827fdf69a92c854-20240717000718 → 5.35.1-nightly-0a5af48f70a76fc060909b853e20c927328c31c3-20240717194138

package/src/wallets/smart/index.ts

@@ -4,10 +4,14 @@ import {
   type TypedDataDefinition,
   type TypedDataDomain,
   hashTypedData,
+  maxUint96,
 } from "viem";
 import type { Chain } from "../../chains/types.js";
 import { getCachedChain } from "../../chains/utils.js";
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
+import { allowance } from "../../extensions/erc20/__generated__/IERC20/read/allowance.js";
+import { approve } from "../../extensions/erc20/write/approve.js";
+import { toSerializableTransaction } from "../../transaction/actions/to-serializable-transaction.js";
 import type { WaitForReceiptOptions } from "../../transaction/actions/wait-for-tx-receipt.js";
 import {
   populateEip712Transaction,
@@ -15,6 +19,8 @@ import {
 } from "../../transaction/actions/zksync/send-eip712-transaction.js";
 import type { PreparedTransaction } from "../../transaction/prepare-transaction.js";
 import { getAddress } from "../../utils/address.js";
+import { concatHex } from "../../utils/encoding/helpers/concat-hex.js";
+import type { Hex } from "../../utils/encoding/hex.js";
 import { parseTypedData } from "../../utils/signatures/helpers/parseTypedData.js";
 import type {
   Account,
@@ -44,9 +50,11 @@ import {
 } from "./lib/userop.js";
 import { isNativeAAChain } from "./lib/utils.js";
 import type {
+  PaymasterResult,
   SmartAccountOptions,
   SmartWalletConnectionOptions,
   SmartWalletOptions,
+  UserOperation,
 } from "./types.js";
 
 /**
@@ -170,6 +178,27 @@ async function createSmartAccount(
   const account: Account = {
     address: getAddress(accountContract.address),
     async sendTransaction(transaction: SendTransactionOption) {
+      // if erc20 paymaster - check allowance and approve if needed
+      const erc20Paymaster = options.overrides?.erc20Paymaster;
+      let paymasterOverride:
+        | undefined
+        | ((userOp: UserOperation) => Promise<PaymasterResult>) = undefined;
+      if (erc20Paymaster) {
+        await approveERC20({
+          accountContract,
+          erc20Paymaster,
+          options,
+        });
+        const paymasterCallback = async (): Promise<PaymasterResult> => {
+          return {
+            paymasterAndData: concatHex([
+              erc20Paymaster.address as Hex,
+              erc20Paymaster?.token as Hex,
+            ]),
+          };
+        };
+        paymasterOverride = options.overrides?.paymaster || paymasterCallback;
+      }
       const executeTx = prepareExecute({
         accountContract,
         transaction,
@@ -177,7 +206,13 @@ async function createSmartAccount(
       });
       return _sendUserOp({
         executeTx,
-        options,
+        options: {
+          ...options,
+          overrides: {
+            ...options.overrides,
+            paymaster: paymasterOverride,
+          },
+        },
       });
     },
     async sendBatchTransaction(transactions: SendTransactionOption[]) {
@@ -362,6 +397,57 @@ async function createSmartAccount(
   return account;
 }
 
+async function approveERC20(args: {
+  accountContract: ThirdwebContract;
+  options: SmartAccountOptions;
+  erc20Paymaster: {
+    address: string;
+    token: string;
+  };
+}) {
+  const { accountContract, erc20Paymaster, options } = args;
+  const tokenAddress = erc20Paymaster.token;
+  const tokenContract = getContract({
+    address: tokenAddress,
+    chain: accountContract.chain,
+    client: accountContract.client,
+  });
+  const accountAllowance = await allowance({
+    contract: tokenContract,
+    owner: accountContract.address,
+    spender: erc20Paymaster.address,
+  });
+
+  if (accountAllowance > 0n) {
+    return;
+  }
+
+  const approveTx = approve({
+    contract: tokenContract,
+    spender: erc20Paymaster.address,
+    amountWei: maxUint96 - 1n,
+  });
+  const transaction = await toSerializableTransaction({
+    transaction: approveTx,
+    from: accountContract.address,
+  });
+  const executeTx = prepareExecute({
+    accountContract,
+    transaction,
+    executeOverride: options.overrides?.execute,
+  });
+  await _sendUserOp({
+    executeTx,
+    options: {
+      ...options,
+      overrides: {
+        ...options.overrides,
+        erc20Paymaster: undefined,
+      },
+    },
+  });
+}
+
 function createZkSyncAccount(args: {
   creationOptions: SmartWalletOptions;
   connectionOptions: SmartWalletConnectionOptions;

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

@@ -5,12 +5,14 @@ import type { TransactionReceipt } from "../../../transaction/types.js";
 import { type Hex, hexToBigInt } from "../../../utils/encoding/hex.js";
 import { getClientFetch } from "../../../utils/fetch.js";
 import { stringify } from "../../../utils/json.js";
-import type {
-  BundlerOptions,
-  EstimationResult,
-  GasPriceResult,
-  PmTransactionData,
-  UserOperation,
+import {
+  type BundlerOptions,
+  type EstimationResult,
+  type GasPriceResult,
+  type PmTransactionData,
+  type UserOperation,
+  type UserOperationReceipt,
+  formatUserOperationReceipt,
 } from "../types.js";
 import {
   DEBUG,
@@ -136,14 +138,12 @@ export async function getUserOpReceipt(
     userOpHash: Hex;
   },
 ): Promise<TransactionReceipt | undefined> {
-  const res = await sendBundlerRequest({
-    options: args,
-    operation: "eth_getUserOperationReceipt",
-    params: [args.userOpHash],
-  });
+  const res = await getUserOpReceiptRaw(args);
+
   if (!res) {
     return undefined;
   }
+
   if (res.success === false) {
     // parse revert reason
     const logs = parseEventLogs({
@@ -152,20 +152,54 @@ export async function getUserOpReceipt(
     });
     const revertReason = logs[0]?.args?.revertReason;
     if (!revertReason) {
-      throw new Error(`UserOp failed at txHash: ${res.transactionHash}`);
+      throw new Error(
+        `UserOp failed at txHash: ${res.receipt.transactionHash}`,
+      );
     }
     const revertMsg = decodeErrorResult({
       data: revertReason,
     });
     throw new Error(
       `UserOp failed with reason: '${revertMsg.args.join(",")}' at txHash: ${
-        res.transactionHash
+        res.receipt.transactionHash
       }`,
     );
   }
   return res.receipt;
 }
 
+/**
+ * Get the receipt of a user operation.
+ * @param args - The options for getting the receipt of a user operation.
+ * @returns The raw receipt of the user operation.
+ * @example
+ * ```ts
+ * import { getUserOpReceiptRaw } from "thirdweb/wallets/smart";
+ *
+ * const receipt = await getUserOpReceiptRaw({
+ *  client,
+ *  chain,
+ *  userOpHash,
+ * });
+ * ```
+ * @walletUtils
+ */
+export async function getUserOpReceiptRaw(
+  args: BundlerOptions & {
+    userOpHash: Hex;
+  },
+): Promise<UserOperationReceipt | undefined> {
+  const res = await sendBundlerRequest({
+    options: args,
+    operation: "eth_getUserOperationReceipt",
+    params: [args.userOpHash],
+  });
+  if (!res) {
+    return undefined;
+  }
+  return formatUserOperationReceipt(res as UserOperationReceipt);
+}
+
 /**
  * @internal
  */

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

@@ -11,8 +11,22 @@ import {
 import { hexlifyUserOp } from "./utils.js";
 
 /**
- * TODO Docs
- * @internal
+ * Get paymaster and data details for a user operation.
+ * @param args - The userOp and options
+ * @returns - The paymaster and data details for the user operation.
+ * @example
+ * ```ts
+ * import { getPaymasterAndData } from "thirdweb/wallets/smart";
+ *
+ * const userOp = createUnsignedUserOp(...);
+ *
+ * const paymasterAndData = await getPaymasterAndData({
+ *  userOp,
+ *  client,
+ *  chain,
+ * });
+ * ```
+ * @walletUtils
  */
 export async function getPaymasterAndData(args: {
   userOp: UserOperation;

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

@@ -81,7 +81,9 @@ export async function waitForUserOpReceipt(
  *
  * const userOp = await createUnsignedUserOp({
  *  transaction,
+ *  factoryContract,
  *  accountContract,
+ *  adminAddress,
  *  sponsorGas,
  *  overrides,
  * });
@@ -246,7 +248,8 @@ export async function createUnsignedUserOp(args: {
  *
  * const signedUserOp = await signUserOp({
  *  userOp,
- *  options,
+ *  chain,
+ *  adminAccount,
  * });
  * ```
  * @walletUtils

package/src/wallets/smart/types.ts

@@ -3,6 +3,7 @@ import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
 import type { ThirdwebContract } from "../../contract/contract.js";
 import type { PreparedTransaction } from "../../transaction/prepare-transaction.js";
+import type { TransactionReceipt } from "../../transaction/types.js";
 import type { Hex } from "../../utils/encoding/hex.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import type { Account, SendTransactionOption } from "../interfaces/wallet.js";
@@ -16,6 +17,10 @@ export type SmartWalletOptions = Prettify<
       accountAddress?: string;
       accountSalt?: string;
       entrypointAddress?: string;
+      erc20Paymaster?: {
+        address: string;
+        token: string;
+      };
       paymaster?: (userOp: UserOperation) => Promise<PaymasterResult>;
       predictAddress?: (factoryContract: ThirdwebContract) => Promise<string>;
       createAccount?: (
@@ -119,3 +124,62 @@ export type PmTransactionData = {
   paymaster: Address;
   paymasterInput: Hex;
 };
+
+export type UserOperationReceipt = {
+  receipt: TransactionReceipt;
+  logs: TransactionReceipt["logs"];
+  userOpHash: Hex;
+  entryPoint: Address;
+  sender: Address;
+  nonce: bigint;
+  paymaster: Address;
+  actualGasUsed: bigint;
+  actualGasCost: bigint;
+  success: boolean;
+};
+
+export function formatUserOperationReceipt(
+  userOpReceiptRaw: UserOperationReceipt,
+) {
+  const { receipt: transactionReceipt } = userOpReceiptRaw;
+
+  const receipt = {
+    ...transactionReceipt,
+    transactionHash: transactionReceipt.transactionHash,
+    blockNumber: transactionReceipt.blockNumber
+      ? BigInt(transactionReceipt.blockNumber)
+      : null,
+    contractAddress: transactionReceipt.contractAddress
+      ? transactionReceipt.contractAddress
+      : null,
+    cumulativeGasUsed: transactionReceipt.cumulativeGasUsed
+      ? BigInt(transactionReceipt.cumulativeGasUsed)
+      : null,
+    effectiveGasPrice: transactionReceipt.effectiveGasPrice
+      ? BigInt(transactionReceipt.effectiveGasPrice)
+      : null,
+    gasUsed: transactionReceipt.gasUsed
+      ? BigInt(transactionReceipt.gasUsed)
+      : null,
+    logs: transactionReceipt.logs,
+    to: transactionReceipt.to ? transactionReceipt.to : null,
+    transactionIndex: transactionReceipt.transactionIndex,
+    status: transactionReceipt.status,
+    type: transactionReceipt.type,
+  } as TransactionReceipt;
+
+  if (transactionReceipt.blobGasPrice)
+    receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
+  if (transactionReceipt.blobGasUsed)
+    receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
+
+  const userOpReceipt = {
+    ...userOpReceiptRaw,
+    receipt,
+    userOpHash: userOpReceiptRaw.userOpHash,
+    actualGasCost: BigInt(userOpReceiptRaw.actualGasCost),
+    actualGasUsed: BigInt(userOpReceiptRaw.actualGasUsed),
+    nonce: BigInt(userOpReceiptRaw.nonce),
+  } as UserOperationReceipt;
+  return userOpReceipt;
+}