permissionless 0.0.6 → 0.0.7

package/actions/bundler/sendUserOperation.ts

@@ -0,0 +1,45 @@
+import type { Address, Hash } from "viem"
+import type { BundlerClient } from "../../clients/bundler.js"
+import type { UserOperation, UserOperationWithBigIntAsHex } from "../../types/userOperation.js"
+import { deepHexlify } from "../utils.js"
+
+export type SendUserOperationParameters = {
+    userOperation: UserOperation
+    entryPoint: Address
+}
+
+/**
+ * Sends user operation to the bundler
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/bundler-actions/sendUserOperation
+ *
+ * @param client {@link BundlerClient} that you created using viem's createClient and extended it with bundlerActions.
+ * @param args {@link SendUserOperationParameters}.
+ * @returns UserOpHash that you can use to track user operation as {@link Hash}.
+ *
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { sendUserOperation } from "permissionless/actions"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http(BUNDLER_URL)
+ * })
+ *
+ * const userOpHash = sendUserOperation(bundlerClient, {
+ *      userOperation: signedUserOperation,
+ *      entryPoint: entryPoint
+ * })
+ *
+ * // Return '0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34'
+ *
+ */
+export const sendUserOperation = async (client: BundlerClient, args: SendUserOperationParameters): Promise<Hash> => {
+    const { userOperation, entryPoint } = args
+
+    return client.request({
+        method: "eth_sendUserOperation",
+        params: [deepHexlify(userOperation) as UserOperationWithBigIntAsHex, entryPoint as Address]
+    })
+}

package/actions/bundler/supportedEntryPoints.ts

@@ -0,0 +1,31 @@
+import type { Address } from "viem"
+import type { BundlerClient } from "../../clients/bundler.js"
+
+/**
+ * Returns the supported entrypoints by the bundler service
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/bundler-actions/supportedEntryPoints
+ *
+ * @param client {@link BundlerClient} that you created using viem's createClient and extended it with bundlerActions.
+ * @returns Supported entryPoints
+ *
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { supportedEntryPoints } from "permissionless/actions"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http(BUNDLER_URL)
+ * })
+ *
+ * const entryPointsSupported = supportedEntryPoints(bundlerClient)
+ * // Return ['0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789']
+ *
+ */
+export const supportedEntryPoints = async (client: BundlerClient): Promise<Address[]> => {
+    return client.request({
+        method: "eth_supportedEntryPoints",
+        params: []
+    })
+}

package/actions/index.ts

@@ -1,26 +1,26 @@
 import type {
     EstimateUserOperationGasParameters,
-    EstimateUserOperationGasReturnType,
-    GetUserOperationByHashParameters,
-    GetUserOperationByHashReturnType,
+    EstimateUserOperationGasReturnType
+} from "./bundler/estimateUserOperationGas.js"
+import type { GetUserOperationByHashParameters } from "./bundler/getUserOperationByHash.js"
+import type { GetUserOperationByHashReturnType } from "./bundler/getUserOperationByHash.js"
+import type {
     GetUserOperationReceiptParameters,
-    GetUserOperationReceiptReturnType,
-    SendUserOperationParameters
-} from "./bundler"
-
-import {
-    bundlerActions,
-    chainId,
-    estimateUserOperationGas,
-    getUserOperationByHash,
-    getUserOperationReceipt,
-    sendUserOperation,
-    supportedEntryPoints
-} from "./bundler"
+    GetUserOperationReceiptReturnType
+} from "./bundler/getUserOperationReceipt.js"
+import type { SendUserOperationParameters } from "./bundler/sendUserOperation.js"
 
-import type { GetSenderAddressParams } from "./public"
+import type { GetSenderAddressParams } from "./public/getSenderAddress.js"
+import { InvalidEntryPointError, getSenderAddress } from "./public/getSenderAddress.js"
 
-import { getAccountNonce, getSenderAddress } from "./public"
+import { chainId } from "./bundler/chainId.js"
+import { estimateUserOperationGas } from "./bundler/estimateUserOperationGas.js"
+import { getUserOperationByHash } from "./bundler/getUserOperationByHash.js"
+import { getUserOperationReceipt } from "./bundler/getUserOperationReceipt.js"
+import { sendUserOperation } from "./bundler/sendUserOperation.js"
+import { supportedEntryPoints } from "./bundler/supportedEntryPoints.js"
+import type { GetAccountNonceParams } from "./public/getAccountNonce.js"
+import { getAccountNonce } from "./public/getAccountNonce.js"
 
 export type {
     SendUserOperationParameters,
@@ -30,11 +30,11 @@ export type {
     GetUserOperationByHashReturnType,
     GetUserOperationReceiptParameters,
     GetUserOperationReceiptReturnType,
-    GetSenderAddressParams
+    GetSenderAddressParams,
+    GetAccountNonceParams
 }
 
 export {
-    bundlerActions,
     sendUserOperation,
     estimateUserOperationGas,
     supportedEntryPoints,
@@ -42,5 +42,6 @@ export {
     getUserOperationByHash,
     getUserOperationReceipt,
     getSenderAddress,
-    getAccountNonce
+    getAccountNonce,
+    InvalidEntryPointError
 }

package/actions/pimlico/getUserOperationGasPrice.ts

@@ -0,0 +1,61 @@
+import type { PimlicoBundlerClient } from "../../clients/pimlico.js"
+
+export type GetUserOperationGasPriceReturnType = {
+    slow: {
+        maxFeePerGas: bigint
+        maxPriorityFeePerGas: bigint
+    }
+    standard: {
+        maxFeePerGas: bigint
+        maxPriorityFeePerGas: bigint
+    }
+    fast: {
+        maxFeePerGas: bigint
+        maxPriorityFeePerGas: bigint
+    }
+}
+
+/**
+ * Returns the live gas prices that you can use to send a user operation.
+ *
+ * - 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.
+ * @returns slow, standard & fast values for maxFeePerGas & maxPriorityFeePerGas
+ *
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { getUserOperationGasPrice } from "permissionless/actions/pimlico"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ * })
+ *
+ * await getUserOperationGasPrice(bundlerClient)
+ *
+ */
+export const getUserOperationGasPrice = async (
+    client: PimlicoBundlerClient
+): Promise<GetUserOperationGasPriceReturnType> => {
+    const gasPrices = await client.request({
+        method: "pimlico_getUserOperationGasPrice",
+        params: []
+    })
+
+    return {
+        slow: {
+            maxFeePerGas: BigInt(gasPrices.slow.maxFeePerGas),
+            maxPriorityFeePerGas: BigInt(gasPrices.slow.maxPriorityFeePerGas)
+        },
+        standard: {
+            maxFeePerGas: BigInt(gasPrices.standard.maxFeePerGas),
+            maxPriorityFeePerGas: BigInt(gasPrices.standard.maxPriorityFeePerGas)
+        },
+        fast: {
+            maxFeePerGas: BigInt(gasPrices.fast.maxFeePerGas),
+            maxPriorityFeePerGas: BigInt(gasPrices.fast.maxPriorityFeePerGas)
+        }
+    }
+}

package/actions/pimlico/getUserOperationStatus.ts

@@ -0,0 +1,41 @@
+import type { Hash } from "viem"
+import type { PimlicoBundlerClient } from "../../clients/pimlico.js"
+import type { PimlicoUserOperationStatus } from "../../types/pimlico.js"
+
+export type GetUserOperationStatusParameters = {
+    hash: Hash
+}
+
+export type GetUserOperationStatusReturnType = PimlicoUserOperationStatus
+
+/**
+ * Returns the status of the userOperation that is pending in the mempool.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationStatus
+ *
+ * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
+ * @param hash {@link Hash} UserOpHash that you must have received from sendUserOperation.
+ * @returns status & transaction hash if included {@link GetUserOperationStatusReturnType}
+ *
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { getUserOperationStatus } from "permissionless/actions/pimlico"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ * })
+ *
+ * await getUserOperationStatus(bundlerClient, { hash: userOpHash })
+ *
+ */
+export const getUserOperationStatus = async (
+    client: PimlicoBundlerClient,
+    { hash }: GetUserOperationStatusParameters
+): Promise<GetUserOperationStatusReturnType> => {
+    return client.request({
+        method: "pimlico_getUserOperationStatus",
+        params: [hash]
+    })
+}

package/actions/pimlico/sponsorUserOperation.ts

@@ -0,0 +1,62 @@
+import type { Address, Hex } 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 { deepHexlify } from "../utils.js"
+
+export type SponsorUserOperationParameters = {
+    userOperation: PartialBy<
+        UserOperation,
+        "callGasLimit" | "preVerificationGas" | "verificationGasLimit" | "paymasterAndData"
+    >
+    entryPoint: Address
+}
+
+export type SponsorUserOperationReturnType = {
+    paymasterAndData: Hex
+    preVerificationGas: bigint
+    verificationGasLimit: bigint
+    callGasLimit: bigint
+}
+
+/**
+ * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-paymaster-actions/sponsorUserOperation
+ *
+ * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
+ * @param args {@link sponsorUserOperationParameters} UserOperation you want to sponsor & entryPoint.
+ * @returns paymasterAndData & updated gas parameters, see {@link SponsorUserOperationReturnType}
+ *
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { sponsorUserOperation } from "permissionless/actions/pimlico"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ * })
+ *
+ * await sponsorUserOperation(bundlerClient, {
+ *      userOperation: userOperationWithDummySignature,
+ *      entryPoint: entryPoint
+ * }})
+ *
+ */
+export const sponsorUserOperation = async (
+    client: PimlicoPaymasterClient,
+    args: SponsorUserOperationParameters
+): Promise<SponsorUserOperationReturnType> => {
+    const response = await client.request({
+        method: "pm_sponsorUserOperation",
+        params: [deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex, args.entryPoint]
+    })
+
+    return {
+        paymasterAndData: response.paymasterAndData,
+        preVerificationGas: BigInt(response.preVerificationGas),
+        verificationGasLimit: BigInt(response.verificationGasLimit),
+        callGasLimit: BigInt(response.callGasLimit)
+    }
+}

package/actions/pimlico.ts

@@ -1,252 +1,35 @@
-import type { Address, Client, Hash, Hex } from "viem"
-import type { PartialBy } from "viem/types/utils"
-import type { PimlicoBundlerClient, PimlicoPaymasterClient } from "../clients/pimlico"
-import type { PimlicoUserOperationStatus } from "../types/pimlico"
-import type { UserOperation, UserOperationWithBigIntAsHex } from "../types/userOperation"
-import { deepHexlify } from "./utils"
-
-export type SponsorUserOperationParameters = {
-    userOperation: PartialBy<
-        UserOperation,
-        "callGasLimit" | "preVerificationGas" | "verificationGasLimit" | "paymasterAndData"
-    >
-    entryPoint: Address
-}
-
-export type SponsorUserOperationReturnType = {
-    paymasterAndData: Hex
-    preVerificationGas: bigint
-    verificationGasLimit: bigint
-    callGasLimit: bigint
-}
-
-export type GetUserOperationGasPriceReturnType = {
-    slow: {
-        maxFeePerGas: bigint
-        maxPriorityFeePerGas: bigint
-    }
-    standard: {
-        maxFeePerGas: bigint
-        maxPriorityFeePerGas: bigint
-    }
-    fast: {
-        maxFeePerGas: bigint
-        maxPriorityFeePerGas: bigint
-    }
-}
-
-export type GetUserOperationStatusParameters = {
-    hash: Hash
-}
-
-export type GetUserOperationStatusReturnType = PimlicoUserOperationStatus
-
-/**
- * Returns the live gas prices that you can use to send a user operation.
- *
- * - 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.
- * @returns slow, standard & fast values for maxFeePerGas & maxPriorityFeePerGas
- *
- *
- * @example
- * import { createClient } from "viem"
- * import { getUserOperationGasPrice } from "permissionless/actions"
- *
- * const bundlerClient = createClient({
- *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
- * })
- *
- * await getUserOperationGasPrice(bundlerClient)
- *
- */
-export const getUserOperationGasPrice = async (
-    client: PimlicoBundlerClient
-): Promise<GetUserOperationGasPriceReturnType> => {
-    const gasPrices = await client.request({
-        method: "pimlico_getUserOperationGasPrice",
-        params: []
-    })
-
-    return {
-        slow: {
-            maxFeePerGas: BigInt(gasPrices.slow.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.slow.maxPriorityFeePerGas)
-        },
-        standard: {
-            maxFeePerGas: BigInt(gasPrices.standard.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.standard.maxPriorityFeePerGas)
-        },
-        fast: {
-            maxFeePerGas: BigInt(gasPrices.fast.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.fast.maxPriorityFeePerGas)
-        }
-    }
+import {
+    type GetUserOperationGasPriceReturnType,
+    getUserOperationGasPrice
+} from "./pimlico/getUserOperationGasPrice.js"
+import {
+    type GetUserOperationStatusParameters,
+    type GetUserOperationStatusReturnType,
+    getUserOperationStatus
+} from "./pimlico/getUserOperationStatus.js"
+import {
+    type SponsorUserOperationParameters,
+    type SponsorUserOperationReturnType,
+    sponsorUserOperation
+} from "./pimlico/sponsorUserOperation.js"
+
+import type { PimlicoBundlerActions, PimlicoPaymasterClientActions } from "../clients/decorators/pimlico.js"
+import { pimlicoBundlerActions, pimlicoPaymasterActions } from "../clients/decorators/pimlico.js"
+
+export type {
+    GetUserOperationGasPriceReturnType,
+    GetUserOperationStatusParameters,
+    GetUserOperationStatusReturnType,
+    SponsorUserOperationParameters,
+    SponsorUserOperationReturnType,
+    PimlicoBundlerActions,
+    PimlicoPaymasterClientActions
+}
+
+export {
+    getUserOperationGasPrice,
+    getUserOperationStatus,
+    sponsorUserOperation,
+    pimlicoBundlerActions,
+    pimlicoPaymasterActions
 }
-
-/**
- * Returns the status of the userOperation that is pending in the mempool.
- *
- * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationStatus
- *
- * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
- * @param hash {@link Hash} UserOpHash that you must have received from sendUserOperation.
- * @returns status & transaction hash if included {@link GetUserOperationStatusReturnType}
- *
- *
- * @example
- * import { createClient } from "viem"
- * import { getUserOperationStatus } from "permissionless/actions"
- *
- * const bundlerClient = createClient({
- *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
- * })
- *
- * await getUserOperationStatus(bundlerClient, { hash: userOpHash })
- *
- */
-export const getUserOperationStatus = async (
-    client: PimlicoBundlerClient,
-    { hash }: GetUserOperationStatusParameters
-): Promise<GetUserOperationStatusReturnType> => {
-    return client.request({
-        method: "pimlico_getUserOperationStatus",
-        params: [hash]
-    })
-}
-
-export type PimlicoBundlerActions = {
-    /**
-     * Returns the live gas prices that you can use to send a user operation.
-     *
-     * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationGasPrice
-     *
-     * @returns slow, standard & fast values for maxFeePerGas & maxPriorityFeePerGas {@link GetUserOperationGasPriceReturnType}
-     *
-     * @example
-     *
-     * import { createClient } from "viem"
-     * import { pimlicoBundlerActions } from "permissionless/actions"
-     *
-     * const bundlerClient = createClient({
-     *      chain: goerli,
-     *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
-     * }).extend(pimlicoBundlerActions)
-     *
-     * await bundlerClient.getUserOperationGasPrice()
-     */
-    getUserOperationGasPrice: () => Promise<GetUserOperationGasPriceReturnType>
-    /**
-     * Returns the status of the userOperation that is pending in the mempool.
-     *
-     * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationStatus
-     *
-     * @param hash {@link Hash} UserOpHash that you must have received from sendUserOperation.
-     * @returns status & transaction hash if included {@link GetUserOperationStatusReturnType}
-     *
-     * @example
-     * import { createClient } from "viem"
-     * import { pimlicoBundlerActions } from "permissionless/actions"
-     *
-     * const bundlerClient = createClient({
-     *      chain: goerli,
-     *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
-     * }).extend(pimlicoBundlerActions)
-     *
-     * await bundlerClient.getUserOperationStatus({ hash: userOpHash })
-     */
-    getUserOperationStatus: (args: GetUserOperationStatusParameters) => Promise<GetUserOperationStatusReturnType>
-}
-
-export const pimlicoBundlerActions = (client: Client): PimlicoBundlerActions => ({
-    getUserOperationGasPrice: async () => getUserOperationGasPrice(client as PimlicoBundlerClient),
-    getUserOperationStatus: async (args: GetUserOperationStatusParameters) =>
-        getUserOperationStatus(client as PimlicoBundlerClient, args)
-})
-
-/**
- * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
- *
- * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-paymaster-actions/sponsorUserOperation
- *
- * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
- * @param args {@link sponsorUserOperationParameters} UserOperation you want to sponsor & entryPoint.
- * @returns paymasterAndData & updated gas parameters, see {@link SponsorUserOperationReturnType}
- *
- *
- * @example
- * import { createClient } from "viem"
- * import { sponsorUserOperation } from "permissionless/actions"
- *
- * const bundlerClient = createClient({
- *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
- * })
- *
- * await sponsorUserOperation(bundlerClient, {
- *      userOperation: userOperationWithDummySignature,
- *      entryPoint: entryPoint
- * }})
- *
- */
-export const sponsorUserOperation = async (
-    client: PimlicoPaymasterClient,
-    args: SponsorUserOperationParameters
-): Promise<SponsorUserOperationReturnType> => {
-    const response = await client.request({
-        method: "pm_sponsorUserOperation",
-        params: [deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex, args.entryPoint]
-    })
-
-    return {
-        paymasterAndData: response.paymasterAndData,
-        preVerificationGas: BigInt(response.preVerificationGas),
-        verificationGasLimit: BigInt(response.verificationGasLimit),
-        callGasLimit: BigInt(response.callGasLimit)
-    }
-}
-
-export type PimlicoPaymasterClientActions = {
-    /**
-     * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
-     *
-     * https://docs.pimlico.io/permissionless/reference/pimlico-paymaster-actions/sponsorUserOperation
-     *
-     * @param args {@link SponsorUserOperationParameters} UserOperation you want to sponsor & entryPoint.
-     * @returns paymasterAndData & updated gas parameters, see {@link SponsorUserOperationReturnType}
-     *
-     * @example
-     * import { createClient } from "viem"
-     * import { sponsorUserOperation } from "permissionless/actions"
-     *
-     * const bundlerClient = createClient({
-     *      chain: goerli,
-     *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
-     * }).extend(pimlicoPaymasterActions)
-     *
-     * await bundlerClient.sponsorUserOperation(bundlerClient, {
-     *      userOperation: userOperationWithDummySignature,
-     *      entryPoint: entryPoint
-     * }})
-     *
-     */
-    sponsorUserOperation: (args: SponsorUserOperationParameters) => Promise<SponsorUserOperationReturnType>
-}
-
-export const pimlicoPaymasterActions = (client: Client): PimlicoPaymasterClientActions => ({
-    sponsorUserOperation: async (args: SponsorUserOperationParameters) =>
-        sponsorUserOperation(client as PimlicoPaymasterClient, args)
-})
-
-/**
- * TODO: Add support for pimlicoActions after we support all the actions of v1 in v2 of the Pimlico API.
- */
-// export const pimlicoActions = (client: Client) => {
-//     return {
-//         ...pimlicoBundlerActions(client),
-//         ...pimlicoPaymasterActions(client)
-//     }
-// }

package/actions/public/getAccountNonce.ts

@@ -0,0 +1,63 @@
+import type { Address, PublicClient } from "viem"
+
+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 args {@link GetAccountNonceParams} address, entryPoint & key
+ * @returns bigint nonce
+ *
+ * @example
+ * import { createPublicClient } from "viem"
+ * import { getAccountNonce } from "permissionless/actions"
+ *
+ * const publicClient = createPublicClient({
+ *      chain: goerli,
+ *      transport: http("https://goerli.infura.io/v3/your-infura-key")
+ * })
+ *
+ * const nonce = await getAccountNonce(publicClient, {
+ *      address,
+ *      entryPoint,
+ *      key
+ * })
+ *
+ * // Return 0n
+ */
+export const getAccountNonce = async (
+    publicClient: PublicClient,
+    { sender, entryPoint, key = BigInt(0) }: GetAccountNonceParams
+): Promise<bigint> => {
+    return await publicClient.readContract({
+        address: entryPoint,
+        abi: [
+            {
+                inputs: [
+                    {
+                        name: "sender",
+                        type: "address"
+                    },
+                    {
+                        name: "key",
+                        type: "uint192"
+                    }
+                ],
+                name: "getNonce",
+                outputs: [
+                    {
+                        name: "nonce",
+                        type: "uint256"
+                    }
+                ],
+                stateMutability: "view",
+                type: "function"
+            }
+        ],
+        functionName: "getNonce",
+        args: [sender, key]
+    })
+}