permissionless 0.0.2 → 0.0.4

package/actions/bundler.ts

@@ -1,10 +1,10 @@
 import type { Address } from "abitype"
-import type { Client, Hash } from "viem"
+import type { Client, Hash, Hex } from "viem"
 import type { PartialBy } from "viem/types/utils"
-import type { UserOperation, UserOperationReceipt } from "../types"
-import type { BundlerClient } from "../types/bundler"
-import type { UserOperationWithBigIntAsHex } from "../types/userOperation"
-import { deepHexlify } from "./utils"
+import type { BundlerClient } from "../clients/bundler"
+import type { UserOperation } from "../types"
+import type { TStatus, UserOperationWithBigIntAsHex } from "../types/userOperation"
+import { deepHexlify, transactionReceiptStatus } from "./utils"
 
 export type SendUserOperationParameters = {
     userOperation: UserOperation
@@ -22,14 +22,55 @@ export type EstimateUserOperationGasReturnType = {
     callGasLimit: bigint
 }
 
-export type GetUserOperationByHash = {
+export type GetUserOperationByHashParameters = {
     hash: Hash
 }
 
-export type GetUserOperationReceipt = {
+export type GetUserOperationByHashReturnType = {
+    userOperation: UserOperation
+    entryPoint: Address
+    transactionHash: Hash
+    blockHash: Hash
+    blockNumber: bigint
+} | null
+
+export type GetUserOperationReceiptParameters = {
     hash: Hash
 }
 
+export type GetUserOperationReceiptReturnType = {
+    userOpHash: Hash
+    sender: Address
+    nonce: bigint
+    actualGasUsed: bigint
+    actualGasCost: bigint
+    success: boolean
+    receipt: {
+        transactionHash: Hex
+        transactionIndex: bigint
+        blockHash: Hash
+        blockNumber: bigint
+        from: Address
+        to: Address | null
+        cumulativeGasUsed: bigint
+        status: TStatus
+        gasUsed: bigint
+        contractAddress: Address | null
+        logsBloom: Hex
+        effectiveGasPrice: bigint
+    }
+    logs: {
+        data: Hex
+        blockNumber: bigint
+        blockHash: Hash
+        transactionHash: Hash
+        logIndex: bigint
+        transactionIndex: bigint
+        address: Address
+        topics: Hex[]
+    }[]
+} | null
+
 /**
  * Sends user operation to the bundler
  *
@@ -78,7 +119,7 @@ export const sendUserOperation = async (client: BundlerClient, args: SendUserOpe
  *
  * @example
  * import { createClient } from "viem"
- * import { sendUserOperation } from "permissionless/actions"
+ * import { estimateUserOperationGas } from "permissionless/actions"
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
@@ -122,7 +163,7 @@ export const estimateUserOperationGas = async (
  *
  * @example
  * import { createClient } from "viem"
- * import { sendUserOperation } from "permissionless/actions"
+ * import { supportedEntryPoints } from "permissionless/actions"
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
@@ -151,19 +192,19 @@ export const supportedEntryPoints = async (client: BundlerClient): Promise<Addre
  *
  * @example
  * import { createClient } from "viem"
- * import { sendUserOperation } from "permissionless/actions"
+ * import { chainId } from "permissionless/actions"
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
  *      transport: http(BUNDLER_URL)
  * })
  *
- * const chainId = chainId(bundlerClient)
+ * const bundlerChainId = chainId(bundlerClient)
  * // Return 5n for Goerli
  *
  */
 export const chainId = async (client: BundlerClient) => {
-    return BigInt(
+    return Number(
         await client.request({
             method: "eth_chainId",
             params: []
@@ -177,13 +218,13 @@ export const chainId = async (client: BundlerClient) => {
  * - Docs: https://docs.pimlico.io/permissionless/reference/bundler-actions/getUserOperationByHash
  *
  * @param client {@link BundlerClient} that you created using viem's createClient and extended it with bundlerActions.
- * @param args {@link GetUserOperationByHash} UserOpHash that was returned by {@link sendUserOperation}
+ * @param args {@link GetUserOperationByHashParameters} UserOpHash that was returned by {@link sendUserOperation}
  * @returns userOperation along with entryPoint, transactionHash, blockHash, blockNumber if found or null
  *
  *
  * @example
  * import { createClient } from "viem"
- * import { sendUserOperation } from "permissionless/actions"
+ * import { getUserOperationByHash } from "permissionless/actions"
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
@@ -195,7 +236,7 @@ export const chainId = async (client: BundlerClient) => {
  */
 export const getUserOperationByHash = async (
     client: BundlerClient,
-    { hash }: GetUserOperationByHash
+    { hash }: GetUserOperationByHashParameters
 ): Promise<{
     userOperation: UserOperation
     entryPoint: Address
@@ -237,13 +278,13 @@ export const getUserOperationByHash = async (
  * - Docs: https://docs.pimlico.io/permissionless/reference/bundler-actions/getUserOperationReceipt
  *
  * @param client {@link BundlerClient} that you created using viem's createClient and extended it with bundlerActions.
- * @param args {@link GetUserOperationReceipt} UserOpHash that was returned by {@link sendUserOperation}
- * @returns user operation receipt {@link UserOperationReceipt} if found or null
+ * @param args {@link GetUserOperationReceiptParameters} UserOpHash that was returned by {@link sendUserOperation}
+ * @returns user operation receipt {@link GetUserOperationReceiptReturnType} if found or null
  *
  *
  * @example
  * import { createClient } from "viem"
- * import { sendUserOperation } from "permissionless/actions"
+ * import { getUserOperationReceipt } from "permissionless/actions"
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
@@ -253,17 +294,17 @@ export const getUserOperationByHash = async (
  * getUserOperationReceipt(bundlerClient, {hash: userOpHash})
  *
  */
-const getUserOperationReceipt = async (client: BundlerClient, { hash }: GetUserOperationReceipt) => {
+export const getUserOperationReceipt = async (client: BundlerClient, { hash }: GetUserOperationReceiptParameters) => {
     const params: [Hash] = [hash]
 
-    const response: UserOperationReceipt = await client.request({
+    const response = await client.request({
         method: "eth_getUserOperationReceipt",
         params
     })
 
     if (!response) return null
 
-    const userOperationReceipt: UserOperationReceipt = {
+    const userOperationReceipt: GetUserOperationReceiptReturnType = {
         userOpHash: response.userOpHash,
         sender: response.sender,
         nonce: BigInt(response.nonce),
@@ -278,7 +319,7 @@ const getUserOperationReceipt = async (client: BundlerClient, { hash }: GetUserO
             from: response.receipt.from,
             to: response.receipt.to,
             cumulativeGasUsed: BigInt(response.receipt.cumulativeGasUsed),
-            status: response.receipt.status ? BigInt(response.receipt.status) : null,
+            status: transactionReceiptStatus[response.receipt.status],
             gasUsed: BigInt(response.receipt.gasUsed),
             contractAddress: response.receipt.contractAddress,
             logsBloom: response.receipt.logsBloom,
@@ -299,7 +340,7 @@ const getUserOperationReceipt = async (client: BundlerClient, { hash }: GetUserO
     return userOperationReceipt
 }
 
-const bundlerActions = (client: Client) => ({
+export type BundlerActions = {
     /**
      *
      * Sends user operation to the bundler
@@ -315,7 +356,7 @@ const bundlerActions = (client: Client) => ({
      *
      * const bundlerClient = createClient({
      *      chain: goerli,
-     *      transport: http(BUNDLER_URL)
+     *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
      * }).extend(bundlerActions)
      *
      * const userOpHash = await bundlerClient.sendUserOperation({
@@ -325,8 +366,7 @@ const bundlerActions = (client: Client) => ({
      *
      * // Return '0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34'
      */
-    sendUserOperation: async (args: SendUserOperationParameters): Promise<Hash> =>
-        sendUserOperation(client as BundlerClient, args),
+    sendUserOperation: (args: SendUserOperationParameters) => Promise<Hash>
     /**
      *
      * Estimates preVerificationGas, verificationGasLimit and callGasLimit for user operation
@@ -352,8 +392,7 @@ const bundlerActions = (client: Client) => ({
      *
      * // Return {preVerificationGas: 43492n, verificationGasLimit: 59436n, callGasLimit: 9000n}
      */
-    estimateUserOperationGas: (args: EstimateUserOperationGasParameters) =>
-        estimateUserOperationGas(client as BundlerClient, args),
+    estimateUserOperationGas: (args: EstimateUserOperationGasParameters) => Promise<EstimateUserOperationGasReturnType>
     /**
      *
      * Returns the supported entrypoints by the bundler service
@@ -375,7 +414,7 @@ const bundlerActions = (client: Client) => ({
      *
      * // Return ['0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789']
      */
-    supportedEntryPoints: (): Promise<Address[]> => supportedEntryPoints(client as BundlerClient),
+    supportedEntryPoints: () => Promise<Address[]>
     /**
      *
      * Returns the supported chain id by the bundler service
@@ -396,7 +435,7 @@ const bundlerActions = (client: Client) => ({
      * const chainId = await bundlerClient.chainId()
      * // Return 5n for Goerli
      */
-    chainId: () => chainId(client as BundlerClient),
+    chainId: () => Promise<number>
     /**
      *
      * Returns the user operation from userOpHash
@@ -418,15 +457,15 @@ const bundlerActions = (client: Client) => ({
      * await bundlerClient.getUserOperationByHash(userOpHash)
      *
      */
-    getUserOperationByHash: (args: GetUserOperationByHash) => getUserOperationByHash(client as BundlerClient, args),
+    getUserOperationByHash: (args: GetUserOperationByHashParameters) => Promise<GetUserOperationByHashReturnType>
     /**
      *
      * Returns the user operation receipt from userOpHash
      *
      * - Docs: https://docs.pimlico.io/permissionless/reference/bundler-actions/getUserOperationReceipt
      *
-     * @param args {@link GetUserOperationReceipt} UserOpHash that was returned by {@link sendUserOperation}
-     * @returns user operation receipt {@link UserOperationReceipt} if found or null
+     * @param args {@link GetUserOperationReceiptParameters} UserOpHash that was returned by {@link sendUserOperation}
+     * @returns user operation receipt {@link GetUserOperationReceiptReturnType} if found or null
      *
      * @example
      * import { createClient } from "viem"
@@ -440,7 +479,20 @@ const bundlerActions = (client: Client) => ({
      * await bundlerClient.getUserOperationReceipt({hash: userOpHash})
      *
      */
-    getUserOperationReceipt: (args: GetUserOperationReceipt) => getUserOperationReceipt(client as BundlerClient, args)
+    getUserOperationReceipt: (args: GetUserOperationReceiptParameters) => Promise<GetUserOperationReceiptReturnType>
+}
+
+const bundlerActions = (client: Client): BundlerActions => ({
+    sendUserOperation: async (args: SendUserOperationParameters): Promise<Hash> =>
+        sendUserOperation(client as BundlerClient, args),
+    estimateUserOperationGas: (args: EstimateUserOperationGasParameters) =>
+        estimateUserOperationGas(client as BundlerClient, args),
+    supportedEntryPoints: (): Promise<Address[]> => supportedEntryPoints(client as BundlerClient),
+    chainId: () => chainId(client as BundlerClient),
+    getUserOperationByHash: (args: GetUserOperationByHashParameters) =>
+        getUserOperationByHash(client as BundlerClient, args),
+    getUserOperationReceipt: (args: GetUserOperationReceiptParameters) =>
+        getUserOperationReceipt(client as BundlerClient, args)
 })
 
-export default bundlerActions
+export { bundlerActions }

package/actions/index.ts

@@ -1,22 +1,39 @@
-import bundlerActions, {
-    type EstimateUserOperationGasParameters,
-    type EstimateUserOperationGasReturnType,
-    type SendUserOperationParameters,
+import type {
+    EstimateUserOperationGasParameters,
+    EstimateUserOperationGasReturnType,
+    GetUserOperationByHashParameters,
+    GetUserOperationByHashReturnType,
+    GetUserOperationReceiptParameters,
+    GetUserOperationReceiptReturnType,
+    SendUserOperationParameters
+} from "./bundler"
+
+import {
+    bundlerActions,
     chainId,
     estimateUserOperationGas,
     getUserOperationByHash,
+    getUserOperationReceipt,
     sendUserOperation,
     supportedEntryPoints
 } from "./bundler"
 
+export type {
+    SendUserOperationParameters,
+    EstimateUserOperationGasParameters,
+    EstimateUserOperationGasReturnType,
+    GetUserOperationByHashParameters,
+    GetUserOperationByHashReturnType,
+    GetUserOperationReceiptParameters,
+    GetUserOperationReceiptReturnType
+}
+
 export {
     bundlerActions,
-    type SendUserOperationParameters,
-    type EstimateUserOperationGasParameters,
-    type EstimateUserOperationGasReturnType,
     sendUserOperation,
     estimateUserOperationGas,
     supportedEntryPoints,
     chainId,
-    getUserOperationByHash
+    getUserOperationByHash,
+    getUserOperationReceipt
 }

package/actions/pimlico.ts

@@ -0,0 +1,252 @@
+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)
+        }
+    }
+}
+
+/**
+ * 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/utils.ts

@@ -1,5 +1,10 @@
 import { toHex } from "viem"
 
+export const transactionReceiptStatus = {
+    "0x0": "reverted",
+    "0x1": "success"
+} as const
+
 // biome-ignore lint/suspicious/noExplicitAny: it's a recursive function, so it's hard to type
 export function deepHexlify(obj: any): any {
     if (typeof obj === "function") {

package/clients/bundler.ts

@@ -0,0 +1,38 @@
+import type { Account, Chain, Client, PublicClientConfig, Transport } from "viem"
+import { createClient } from "viem"
+import { bundlerActions } from "../actions"
+import type { BundlerActions } from "../actions/bundler"
+import type { BundlerRpcSchema } from "../types/bundler"
+
+export type BundlerClient = Client<Transport, Chain | undefined, Account | undefined, BundlerRpcSchema, BundlerActions>
+/**
+ * Creates a EIP-4337 compliant Bundler Client with a given [Transport](https://viem.sh/docs/clients/intro.html) configured for a [Chain](https://viem.sh/docs/clients/chains.html).
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/clients/bundlerClient
+ *
+ * A Bundler Client is an interface to "erc 4337" [JSON-RPC API](https://eips.ethereum.org/EIPS/eip-4337#rpc-methods-eth-namespace) methods such as sending user operation, estimating gas for a user operation, get user operation receipt, etc through Bundler Actions.
+ *
+ * @param config - {@link PublicClientConfig}
+ * @returns A Bundler Client. {@link BundlerClient}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ *
+ * const bundlerClient = createBundlerClient({
+ *   chain: mainnet,
+ *   transport: http(BUNDLER_URL),
+ * })
+ */
+export const createBundlerClient = <transport extends Transport, chain extends Chain | undefined = undefined>(
+    parameters: PublicClientConfig<transport, chain>
+): BundlerClient => {
+    const { key = "public", name = "Bundler Client" } = parameters
+    const client = createClient({
+        ...parameters,
+        key,
+        name,
+        type: "bundlerClient"
+    })
+    return client.extend(bundlerActions)
+}

package/clients/index.ts

@@ -0,0 +1,3 @@
+import { type BundlerClient, createBundlerClient } from "./bundler"
+
+export { createBundlerClient, type BundlerClient }