permissionless 0.0.11 → 0.0.13

package/actions/pimlico/getUserOperationGasPrice.ts

@@ -1,4 +1,5 @@
-import type { PimlicoBundlerClient } from "../../clients/pimlico.js"
+import type { Account, Chain, Client, Transport } from "viem"
+import type { PimlicoBundlerRpcSchema } from "../../types/pimlico.js"
 
 export type GetUserOperationGasPriceReturnType = {
     slow: {
@@ -20,7 +21,7 @@ export type GetUserOperationGasPriceReturnType = {
  *
  * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationGasPrice
  *
- * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
+ * @param client that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
  * @returns slow, standard & fast values for maxFeePerGas & maxPriorityFeePerGas
  *
  *
@@ -30,14 +31,18 @@ export type GetUserOperationGasPriceReturnType = {
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
  * })
  *
  * await getUserOperationGasPrice(bundlerClient)
  *
  */
-export const getUserOperationGasPrice = async (
-    client: PimlicoBundlerClient
+export const getUserOperationGasPrice = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, PimlicoBundlerRpcSchema>
 ): Promise<GetUserOperationGasPriceReturnType> => {
     const gasPrices = await client.request({
         method: "pimlico_getUserOperationGasPrice",
@@ -51,7 +56,9 @@ export const getUserOperationGasPrice = async (
         },
         standard: {
             maxFeePerGas: BigInt(gasPrices.standard.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.standard.maxPriorityFeePerGas)
+            maxPriorityFeePerGas: BigInt(
+                gasPrices.standard.maxPriorityFeePerGas
+            )
         },
         fast: {
             maxFeePerGas: BigInt(gasPrices.fast.maxFeePerGas),

package/actions/pimlico/getUserOperationStatus.ts

@@ -1,6 +1,9 @@
-import type { Hash } from "viem"
+import type { Account, Chain, Client, Hash, Transport } from "viem"
 import type { PimlicoBundlerClient } from "../../clients/pimlico.js"
-import type { PimlicoUserOperationStatus } from "../../types/pimlico.js"
+import type {
+    PimlicoBundlerRpcSchema,
+    PimlicoUserOperationStatus
+} from "../../types/pimlico.js"
 
 export type GetUserOperationStatusParameters = {
     hash: Hash
@@ -24,14 +27,18 @@ export type GetUserOperationStatusReturnType = PimlicoUserOperationStatus
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
  * })
  *
  * await getUserOperationStatus(bundlerClient, { hash: userOpHash })
  *
  */
-export const getUserOperationStatus = async (
-    client: PimlicoBundlerClient,
+export const getUserOperationStatus = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, PimlicoBundlerRpcSchema>,
     { hash }: GetUserOperationStatusParameters
 ): Promise<GetUserOperationStatusReturnType> => {
     return client.request({

package/actions/pimlico/sponsorUserOperation.ts

@@ -1,13 +1,19 @@
-import type { Address, Hex } from "viem"
+import type { Account, Address, Chain, Client, Hex, Transport } from "viem"
 import type { PartialBy } from "viem/types/utils"
-import type { PimlicoPaymasterClient } from "../../clients/pimlico.js"
-import type { UserOperation, UserOperationWithBigIntAsHex } from "../../types/userOperation.js"
+import type { PimlicoPaymasterRpcSchema } from "../../types/pimlico.js"
+import type {
+    UserOperation,
+    UserOperationWithBigIntAsHex
+} from "../../types/userOperation.js"
 import { deepHexlify } from "../../utils/deepHexlify.js"
 
 export type SponsorUserOperationParameters = {
     userOperation: PartialBy<
         UserOperation,
-        "callGasLimit" | "preVerificationGas" | "verificationGasLimit" | "paymasterAndData"
+        | "callGasLimit"
+        | "preVerificationGas"
+        | "verificationGasLimit"
+        | "paymasterAndData"
     >
     entryPoint: Address
 }
@@ -44,13 +50,20 @@ export type SponsorUserOperationReturnType = {
  * }})
  *
  */
-export const sponsorUserOperation = async (
-    client: PimlicoPaymasterClient,
+export const sponsorUserOperation = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, PimlicoPaymasterRpcSchema>,
     args: SponsorUserOperationParameters
 ): Promise<SponsorUserOperationReturnType> => {
     const response = await client.request({
         method: "pm_sponsorUserOperation",
-        params: [deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex, args.entryPoint]
+        params: [
+            deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex,
+            args.entryPoint
+        ]
     })
 
     return {

package/actions/pimlico.ts

@@ -13,8 +13,14 @@ import {
     sponsorUserOperation
 } from "./pimlico/sponsorUserOperation.js"
 
-import type { PimlicoBundlerActions, PimlicoPaymasterClientActions } from "../clients/decorators/pimlico.js"
-import { pimlicoBundlerActions, pimlicoPaymasterActions } from "../clients/decorators/pimlico.js"
+import type {
+    PimlicoBundlerActions,
+    PimlicoPaymasterClientActions
+} from "../clients/decorators/pimlico.js"
+import {
+    pimlicoBundlerActions,
+    pimlicoPaymasterActions
+} from "../clients/decorators/pimlico.js"
 
 export type {
     GetUserOperationGasPriceReturnType,

package/actions/public/getAccountNonce.ts

@@ -1,13 +1,19 @@
-import type { Address, PublicClient } from "viem"
+import type { Address, Chain, Client, Transport } from "viem"
+import { readContract } from "viem/actions"
+import { getAction } from "../../utils/getAction.js"
 
-export type GetAccountNonceParams = { sender: Address; entryPoint: Address; key?: bigint }
+export type GetAccountNonceParams = {
+    sender: Address
+    entryPoint: Address
+    key?: bigint
+}
 
 /**
  * Returns the nonce of the account with the entry point.
  *
  * - Docs: https://docs.pimlico.io/permissionless/reference/public-actions/getAccountNonce
  *
- * @param publicClient {@link PublicClient} that you created using viem's createPublicClient.
+ * @param client {@link client} that you created using viem's createPublicClient.
  * @param args {@link GetAccountNonceParams} address, entryPoint & key
  * @returns bigint nonce
  *
@@ -15,12 +21,12 @@ export type GetAccountNonceParams = { sender: Address; entryPoint: Address; key?
  * import { createPublicClient } from "viem"
  * import { getAccountNonce } from "permissionless/actions"
  *
- * const publicClient = createPublicClient({
+ * const client = createPublicClient({
  *      chain: goerli,
  *      transport: http("https://goerli.infura.io/v3/your-infura-key")
  * })
  *
- * const nonce = await getAccountNonce(publicClient, {
+ * const nonce = await getAccountNonce(client, {
  *      address,
  *      entryPoint,
  *      key
@@ -28,11 +34,17 @@ export type GetAccountNonceParams = { sender: Address; entryPoint: Address; key?
  *
  * // Return 0n
  */
-export const getAccountNonce = async (
-    publicClient: PublicClient,
+export const getAccountNonce = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>(
+    client: Client<TTransport, TChain>,
     { sender, entryPoint, key = BigInt(0) }: GetAccountNonceParams
 ): Promise<bigint> => {
-    return await publicClient.readContract({
+    return await getAction(
+        client,
+        readContract
+    )({
         address: entryPoint,
         abi: [
             {

package/actions/public/getSenderAddress.ts

@@ -1,18 +1,26 @@
 import {
     type Address,
     BaseError,
+    type Chain,
+    type Client,
     type ContractFunctionExecutionErrorType,
     type ContractFunctionRevertedErrorType,
     type Hex,
-    type PublicClient
+    type Transport
 } from "viem"
 
+import { simulateContract } from "viem/actions"
+import { getAction } from "../../utils/getAction.js"
+
 export type GetSenderAddressParams = { initCode: Hex; entryPoint: Address }
 
 export class InvalidEntryPointError extends BaseError {
     override name = "InvalidEntryPointError"
 
-    constructor({ cause, entryPoint }: { cause?: BaseError; entryPoint?: Address } = {}) {
+    constructor({
+        cause,
+        entryPoint
+    }: { cause?: BaseError; entryPoint?: Address } = {}) {
         super(
             `The entry point address (\`entryPoint\`${
                 entryPoint ? ` = ${entryPoint}` : ""
@@ -29,8 +37,7 @@ export class InvalidEntryPointError extends BaseError {
  *
  * - Docs: https://docs.pimlico.io/permissionless/reference/public-actions/getSenderAddress
  *
- *
- * @param publicClient {@link PublicClient} that you created using viem's createPublicClient.
+ * @param client {@link Client} that you created using viem's createPublicClient.
  * @param args {@link GetSenderAddressParams} initCode & entryPoint
  * @returns Sender's Address
  *
@@ -50,12 +57,18 @@ export class InvalidEntryPointError extends BaseError {
  *
  * // Return '0x7a88a206ba40b37a8c07a2b5688cf8b287318b63'
  */
-export const getSenderAddress = async (
-    publicClient: PublicClient,
+export const getSenderAddress = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>(
+    client: Client<TTransport, TChain>,
     { initCode, entryPoint }: GetSenderAddressParams
 ): Promise<Address> => {
     try {
-        await publicClient.simulateContract({
+        await getAction(
+            client,
+            simulateContract
+        )({
             address: entryPoint,
             abi: [
                 {
@@ -92,7 +105,11 @@ export const getSenderAddress = async (
         if (err.cause.name === "ContractFunctionRevertedError") {
             const revertError = err.cause as ContractFunctionRevertedErrorType
             const errorName = revertError.data?.errorName ?? ""
-            if (errorName === "SenderAddressResult" && revertError.data?.args && revertError.data?.args[0]) {
+            if (
+                errorName === "SenderAddressResult" &&
+                revertError.data?.args &&
+                revertError.data?.args[0]
+            ) {
                 return revertError.data?.args[0] as Address
             }
         }

package/actions/smartAccount/deployContract.ts

@@ -0,0 +1,110 @@
+import {
+    type Abi,
+    type Chain,
+    type Client,
+    type DeployContractParameters,
+    type DeployContractReturnType,
+    type Transport
+} from "viem"
+import type { SmartAccount } from "../../accounts/types.js"
+import { getAction } from "../../utils/getAction.js"
+import { parseAccount } from "../../utils/index.js"
+import { AccountOrClientNotFoundError } from "../../utils/signUserOperationHashWithECDSA.js"
+import { waitForUserOperationReceipt } from "../bundler/waitForUserOperationReceipt.js"
+import { type SponsorUserOperationMiddleware } from "./prepareUserOperationRequest.js"
+import { sendUserOperation } from "./sendUserOperation.js"
+
+export type DeployContractParametersWithPaymaster<
+    TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[],
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined,
+    TChainOverride extends Chain | undefined = Chain | undefined
+> = DeployContractParameters<TAbi, TChain, TAccount, TChainOverride> &
+    SponsorUserOperationMiddleware
+
+/**
+ * Deploys a contract to the network, given bytecode and constructor arguments.
+ * This function also allows you to sponsor this transaction if sender is a smartAccount
+ *
+ * - Docs: https://viem.sh/docs/contract/deployContract.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/deploying-contracts
+ *
+ * @param client - Client to use
+ * @param parameters - {@link DeployContractParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash. {@link DeployContractReturnType}
+ *
+ * @example
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { deployContract } from 'viem/contract'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const hash = await deployContract(client, {
+ *   abi: [],
+ *   account: '0x…,
+ *   bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
+ * })
+ */
+export async function deployContract<
+    const TAbi extends Abi | readonly unknown[],
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined,
+    TChainOverride extends Chain | undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    {
+        abi,
+        args,
+        bytecode,
+        sponsorUserOperation,
+        ...request
+    }: DeployContractParametersWithPaymaster
+): Promise<DeployContractReturnType> {
+    const { account: account_ = client.account } = request
+
+    if (!account_) {
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/docs/actions/wallet/sendTransaction"
+        })
+    }
+
+    const account = parseAccount(account_) as SmartAccount
+
+    const userOpHash = await getAction(
+        client,
+        sendUserOperation
+    )({
+        userOperation: {
+            sender: account.address,
+            paymasterAndData: "0x",
+            maxFeePerGas: request.maxFeePerGas || 0n,
+            maxPriorityFeePerGas: request.maxPriorityFeePerGas || 0n,
+            callData: await account.encodeDeployCallData({
+                abi,
+                args,
+                bytecode
+            } as unknown as DeployContractParameters<
+                TAbi,
+                TChain,
+                TAccount,
+                TChainOverride
+            >)
+        },
+        account: account,
+        sponsorUserOperation
+    })
+
+    const userOperationReceipt = await getAction(
+        client,
+        waitForUserOperationReceipt
+    )({
+        hash: userOpHash
+    })
+
+    return userOperationReceipt?.receipt.transactionHash
+}

package/actions/smartAccount/prepareUserOperationRequest.ts

@@ -0,0 +1,140 @@
+import type { Address, Chain, Client, Hex, Transport } from "viem"
+import { estimateFeesPerGas } from "viem/actions"
+import type { SmartAccount } from "../../accounts/types.js"
+import type {
+    GetAccountParameter,
+    PartialBy,
+    UserOperation
+} from "../../types/index.js"
+import { getAction } from "../../utils/getAction.js"
+import {
+    AccountOrClientNotFoundError,
+    parseAccount
+} from "../../utils/index.js"
+import { estimateUserOperationGas } from "../bundler/estimateUserOperationGas.js"
+
+export type SponsorUserOperationMiddleware = {
+    sponsorUserOperation?: (args: {
+        userOperation: UserOperation
+        entryPoint: Address
+    }) => Promise<{
+        paymasterAndData: Hex
+        preVerificationGas: bigint
+        verificationGasLimit: bigint
+        callGasLimit: bigint
+    }>
+}
+
+export type PrepareUserOperationRequestParameters<
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined,
+> = {
+    userOperation: PartialBy<
+        UserOperation,
+        | "nonce"
+        | "sender"
+        | "initCode"
+        | "callGasLimit"
+        | "verificationGasLimit"
+        | "preVerificationGas"
+        | "maxFeePerGas"
+        | "maxPriorityFeePerGas"
+        | "paymasterAndData"
+        | "signature"
+    >
+} & GetAccountParameter<TAccount> &
+    SponsorUserOperationMiddleware
+
+export type PrepareUserOperationRequestReturnType = UserOperation
+
+export async function prepareUserOperationRequest<
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+>(
+    client: Client<TTransport, TChain, TAccount>,
+    args: PrepareUserOperationRequestParameters<TAccount>
+): Promise<PrepareUserOperationRequestReturnType> {
+    const {
+        account: account_ = client.account,
+        userOperation: partialUserOperation,
+        sponsorUserOperation
+    } = args
+    if (!account_) throw new AccountOrClientNotFoundError()
+
+    const account = parseAccount(account_) as SmartAccount
+
+    const [sender, nonce, initCode, signature, callData, gasEstimation] =
+        await Promise.all([
+            partialUserOperation.sender || account.address,
+            partialUserOperation.nonce || account.getNonce(),
+            partialUserOperation.initCode || account.getInitCode(),
+            partialUserOperation.signature || account.getDummySignature(),
+            partialUserOperation.callData,
+            !partialUserOperation.maxFeePerGas ||
+            !partialUserOperation.maxPriorityFeePerGas
+                ? estimateFeesPerGas(account.client)
+                : undefined
+        ])
+
+    const userOperation: UserOperation = {
+        sender,
+        nonce,
+        initCode,
+        signature,
+        callData,
+        paymasterAndData: "0x",
+        maxFeePerGas:
+            partialUserOperation.maxFeePerGas ||
+            gasEstimation?.maxFeePerGas ||
+            0n,
+        maxPriorityFeePerGas:
+            partialUserOperation.maxPriorityFeePerGas ||
+            gasEstimation?.maxPriorityFeePerGas ||
+            0n,
+        callGasLimit: partialUserOperation.callGasLimit || 0n,
+        verificationGasLimit: partialUserOperation.verificationGasLimit || 0n,
+        preVerificationGas: partialUserOperation.preVerificationGas || 0n
+    }
+
+    if (sponsorUserOperation) {
+        const {
+            callGasLimit,
+            verificationGasLimit,
+            preVerificationGas,
+            paymasterAndData
+        } = await sponsorUserOperation({
+            userOperation,
+            entryPoint: account.entryPoint
+        })
+        userOperation.paymasterAndData = paymasterAndData
+        userOperation.callGasLimit = userOperation.callGasLimit || callGasLimit
+        userOperation.verificationGasLimit =
+            userOperation.verificationGasLimit || verificationGasLimit
+        userOperation.preVerificationGas =
+            userOperation.preVerificationGas || preVerificationGas
+    } else if (
+        !userOperation.callGasLimit ||
+        !userOperation.verificationGasLimit ||
+        !userOperation.preVerificationGas
+    ) {
+        const gasParameters = await getAction(
+            client,
+            estimateUserOperationGas
+        )({
+            userOperation: {
+                ...userOperation
+            },
+            entryPoint: account.entryPoint
+        })
+
+        userOperation.callGasLimit =
+            userOperation.callGasLimit || gasParameters.callGasLimit
+        userOperation.verificationGasLimit =
+            userOperation.verificationGasLimit ||
+            gasParameters.verificationGasLimit
+        userOperation.preVerificationGas =
+            userOperation.preVerificationGas || gasParameters.preVerificationGas
+    }
+
+    return userOperation
+}

package/actions/smartAccount/sendTransaction.ts

@@ -0,0 +1,138 @@
+import type {
+    Chain,
+    Client,
+    SendTransactionParameters,
+    SendTransactionReturnType,
+    Transport
+} from "viem"
+import { type SmartAccount } from "../../accounts/types.js"
+import { getAction } from "../../utils/getAction.js"
+import {
+    AccountOrClientNotFoundError,
+    parseAccount
+} from "../../utils/index.js"
+import { waitForUserOperationReceipt } from "../bundler/waitForUserOperationReceipt.js"
+import { type SponsorUserOperationMiddleware } from "./prepareUserOperationRequest.js"
+import { sendUserOperation } from "./sendUserOperation.js"
+
+export type SendTransactionWithPaymasterParameters<
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined,
+    TChainOverride extends Chain | undefined = Chain | undefined
+> = SendTransactionParameters<TChain, TAccount, TChainOverride> &
+    SponsorUserOperationMiddleware
+
+/**
+ * Creates, signs, and sends a new transaction to the network.
+ * This function also allows you to sponsor this transaction if sender is a smartAccount
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendTransaction.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/transactions/sending-transactions
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+ *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendTransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash. {@link SendTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
+export async function sendTransaction<
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined,
+    TChainOverride extends Chain | undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    args: SendTransactionWithPaymasterParameters<
+        TChain,
+        TAccount,
+        TChainOverride
+    >
+): Promise<SendTransactionReturnType> {
+    const {
+        account: account_ = client.account,
+        data,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        to,
+        value,
+        nonce,
+        sponsorUserOperation
+    } = args
+
+    if (!account_) {
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/docs/actions/wallet/sendTransaction"
+        })
+    }
+
+    const account = parseAccount(account_) as SmartAccount
+
+    if (!to) throw new Error("Missing to address")
+
+    if (account.type !== "local") {
+        throw new Error("RPC account type not supported")
+    }
+
+    const callData = await account.encodeCallData({
+        to,
+        value: value || 0n,
+        data: data || "0x"
+    })
+
+    const userOpHash = await getAction(
+        client,
+        sendUserOperation
+    )({
+        userOperation: {
+            sender: account.address,
+            paymasterAndData: "0x",
+            maxFeePerGas: maxFeePerGas || 0n,
+            maxPriorityFeePerGas: maxPriorityFeePerGas || 0n,
+            callData: callData,
+            nonce: nonce ? BigInt(nonce) : undefined
+        },
+        account: account,
+        sponsorUserOperation
+    })
+
+    const userOperationReceipt = await getAction(
+        client,
+        waitForUserOperationReceipt
+    )({
+        hash: userOpHash
+    })
+
+    return userOperationReceipt?.receipt.transactionHash
+}