permissionless 0.0.35 → 0.1.0

package/clients/decorators/bundler.ts

@@ -1,4 +1,3 @@
-import type { Address } from "viem"
 import type { Client, Hash } from "viem"
 import { chainId } from "../../actions/bundler/chainId"
 import {
@@ -27,9 +26,10 @@ import {
 } from "../../actions/bundler/waitForUserOperationReceipt"
 import type { Prettify } from "../../types/"
 import type { StateOverrides } from "../../types/bundler"
+import type { EntryPoint } from "../../types/entrypoint"
 import type { BundlerClient } from "../createBundlerClient"
 
-export type BundlerActions = {
+export type BundlerActions<entryPoint extends EntryPoint> = {
     /**
      *
      * Sends user operation to the bundler
@@ -56,7 +56,9 @@ export type BundlerActions = {
      * // Return '0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34'
      */
     sendUserOperation: (
-        args: Prettify<SendUserOperationParameters>
+        args: Prettify<
+            Omit<SendUserOperationParameters<entryPoint>, "entryPoint">
+        >
     ) => Promise<Hash>
     /**
      *
@@ -84,9 +86,11 @@ export type BundlerActions = {
      * // Return {preVerificationGas: 43492n, verificationGasLimit: 59436n, callGasLimit: 9000n}
      */
     estimateUserOperationGas: (
-        args: Prettify<EstimateUserOperationGasParameters>,
+        args: Prettify<
+            Omit<EstimateUserOperationGasParameters<entryPoint>, "entryPoint">
+        >,
         stateOverrides?: StateOverrides
-    ) => Promise<Prettify<EstimateUserOperationGasReturnType>>
+    ) => Promise<Prettify<EstimateUserOperationGasReturnType<entryPoint>>>
     /**
      *
      * Returns the supported entrypoints by the bundler service
@@ -108,7 +112,7 @@ export type BundlerActions = {
      *
      * // Return ['0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789']
      */
-    supportedEntryPoints: () => Promise<Address[]>
+    supportedEntryPoints: () => Promise<EntryPoint[]>
     /**
      *
      * Returns the supported chain id by the bundler service
@@ -153,7 +157,7 @@ export type BundlerActions = {
      */
     getUserOperationByHash: (
         args: Prettify<GetUserOperationByHashParameters>
-    ) => Promise<Prettify<GetUserOperationByHashReturnType> | null>
+    ) => Promise<Prettify<GetUserOperationByHashReturnType<entryPoint>> | null>
     /**
      *
      * Returns the user operation receipt from userOpHash
@@ -205,25 +209,45 @@ export type BundlerActions = {
     ) => Promise<Prettify<GetUserOperationReceiptReturnType>>
 }
 
-const bundlerActions = (client: Client): BundlerActions => ({
-    sendUserOperation: async (
-        args: SendUserOperationParameters
-    ): Promise<Hash> => sendUserOperation(client as BundlerClient, args),
-    estimateUserOperationGas: (
-        args: EstimateUserOperationGasParameters,
-        stateOverrides
-    ) =>
-        estimateUserOperationGas(client as BundlerClient, args, stateOverrides),
-    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),
-    waitForUserOperationReceipt: (
-        args: WaitForUserOperationReceiptParameters
-    ) => waitForUserOperationReceipt(client as BundlerClient, args)
-})
+const bundlerActions =
+    <entryPoint extends EntryPoint>(entryPointAddress: entryPoint) =>
+    (client: Client): BundlerActions<entryPoint> => ({
+        sendUserOperation: async (
+            args: Omit<SendUserOperationParameters<entryPoint>, "entryPoint">
+        ): Promise<Hash> =>
+            sendUserOperation<entryPoint>(client as BundlerClient<entryPoint>, {
+                ...args,
+                entryPoint: entryPointAddress
+            }),
+        estimateUserOperationGas: (
+            args: Omit<
+                EstimateUserOperationGasParameters<entryPoint>,
+                "entryPoint"
+            >,
+            stateOverrides?: StateOverrides
+        ) =>
+            estimateUserOperationGas<entryPoint>(
+                client as BundlerClient<entryPoint>,
+                { ...args, entryPoint: entryPointAddress },
+                stateOverrides
+            ),
+        supportedEntryPoints: (): Promise<EntryPoint[]> =>
+            supportedEntryPoints(client as BundlerClient<entryPoint>),
+        chainId: () => chainId(client as BundlerClient<entryPoint>),
+        getUserOperationByHash: (args: GetUserOperationByHashParameters) =>
+            getUserOperationByHash<entryPoint>(
+                client as BundlerClient<entryPoint>,
+                args
+            ),
+        getUserOperationReceipt: (args: GetUserOperationReceiptParameters) =>
+            getUserOperationReceipt(client as BundlerClient<entryPoint>, args),
+        waitForUserOperationReceipt: (
+            args: WaitForUserOperationReceiptParameters
+        ) =>
+            waitForUserOperationReceipt(
+                client as BundlerClient<entryPoint>,
+                args
+            )
+    })
 
 export { bundlerActions }

package/clients/decorators/pimlico.ts

@@ -21,6 +21,7 @@ import {
     sponsorUserOperation
 } from "../../actions/pimlico/sponsorUserOperation"
 import type { Prettify } from "../../types/"
+import type { EntryPoint } from "../../types/entrypoint"
 import type { PimlicoBundlerClient, PimlicoPaymasterClient } from "../pimlico"
 
 export type PimlicoBundlerActions = {
@@ -97,19 +98,26 @@ export type PimlicoBundlerActions = {
     ) => Promise<Hash>
 }
 
-export const pimlicoBundlerActions = (
+export const pimlicoBundlerActions = <entryPoint extends EntryPoint>(
     client: Client
 ): PimlicoBundlerActions => ({
     getUserOperationGasPrice: async () =>
-        getUserOperationGasPrice(client as PimlicoBundlerClient),
+        getUserOperationGasPrice(client as PimlicoBundlerClient<entryPoint>),
     getUserOperationStatus: async (args: GetUserOperationStatusParameters) =>
-        getUserOperationStatus(client as PimlicoBundlerClient, args),
+        getUserOperationStatus(
+            client as PimlicoBundlerClient<entryPoint>,
+            args
+        ),
     sendCompressedUserOperation: async (
         args: SendCompressedUserOperationParameters
-    ) => sendCompressedUserOperation(client as PimlicoBundlerClient, args)
+    ) =>
+        sendCompressedUserOperation(
+            client as PimlicoBundlerClient<entryPoint>,
+            args
+        )
 })
 
-export type PimlicoPaymasterClientActions = {
+export type PimlicoPaymasterClientActions<entryPoint extends EntryPoint> = {
     /**
      * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
      *
@@ -134,11 +142,11 @@ export type PimlicoPaymasterClientActions = {
      *
      */
     sponsorUserOperation: (
-        args: Prettify<PimlicoSponsorUserOperationParameters>
-    ) => Promise<Prettify<SponsorUserOperationReturnType>>
+        args: Prettify<PimlicoSponsorUserOperationParameters<entryPoint>>
+    ) => Promise<Prettify<SponsorUserOperationReturnType<entryPoint>>>
 
     validateSponsorshipPolicies: (
-        args: Prettify<ValidateSponsorshipPoliciesParameters>
+        args: Prettify<ValidateSponsorshipPoliciesParameters<entryPoint>>
     ) => Promise<Prettify<ValidateSponsorshipPolicies>[]>
 }
 
@@ -177,15 +185,33 @@ export type PimlicoPaymasterClientActions = {
  *   }
  * ]
  */
-export const pimlicoPaymasterActions = (
-    client: Client
-): PimlicoPaymasterClientActions => ({
-    sponsorUserOperation: async (args: PimlicoSponsorUserOperationParameters) =>
-        sponsorUserOperation(client as PimlicoPaymasterClient, args),
-    validateSponsorshipPolicies: async (
-        args: ValidateSponsorshipPoliciesParameters
-    ) => validateSponsorshipPolicies(client as PimlicoPaymasterClient, args)
-})
+export const pimlicoPaymasterActions =
+    <entryPoint extends EntryPoint>(entryPointAddress: entryPoint) =>
+    (client: Client): PimlicoPaymasterClientActions<entryPoint> => ({
+        sponsorUserOperation: async (
+            args: Omit<
+                PimlicoSponsorUserOperationParameters<entryPoint>,
+                "entryPoint"
+            >
+        ) =>
+            sponsorUserOperation<entryPoint>(
+                client as PimlicoPaymasterClient<entryPoint>,
+                {
+                    ...args,
+                    entryPoint: entryPointAddress
+                }
+            ),
+        validateSponsorshipPolicies: async (
+            args: Omit<
+                ValidateSponsorshipPoliciesParameters<entryPoint>,
+                "entryPoint"
+            >
+        ) =>
+            validateSponsorshipPolicies<entryPoint>(
+                client as PimlicoPaymasterClient<entryPoint>,
+                { ...args, entryPoint: entryPointAddress }
+            )
+    })
 
 /**
  * TODO: Add support for pimlicoActions after we support all the actions of v2 of the Pimlico API.

package/clients/decorators/smartAccount.ts

@@ -21,8 +21,8 @@ import {
     deployContract
 } from "../../actions/smartAccount/deployContract"
 import {
+    type Middleware,
     type PrepareUserOperationRequestReturnType,
-    type SponsorUserOperationMiddleware,
     prepareUserOperationRequest
 } from "../../actions/smartAccount/prepareUserOperationRequest"
 import {
@@ -41,10 +41,14 @@ import {
 } from "../../actions/smartAccount/writeContract"
 import type { Prettify } from "../../types/"
 import type { StateOverrides } from "../../types/bundler"
+import type { EntryPoint } from "../../types/entrypoint"
 
 export type SmartAccountActions<
+    entryPoint extends EntryPoint,
     TChain extends Chain | undefined = Chain | undefined,
-    TSmartAccount extends SmartAccount | undefined = SmartAccount | undefined
+    TSmartAccount extends SmartAccount<entryPoint> | undefined =
+        | SmartAccount<entryPoint>
+        | undefined
 > = {
     /**
      * Creates, signs, and sends a new transaction to the network.
@@ -91,9 +95,7 @@ export type SmartAccountActions<
      */
     sendTransaction: <TChainOverride extends Chain | undefined>(
         args: SendTransactionParameters<TChain, TSmartAccount, TChainOverride>
-    ) => ReturnType<
-        typeof sendTransaction<TChain, TSmartAccount, TChainOverride>
-    >
+    ) => Promise<Hash>
     /**
      * Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
      *
@@ -138,8 +140,10 @@ export type SmartAccountActions<
      * })
      */
     signMessage: (
-        args: Parameters<typeof signMessage<TChain, TSmartAccount>>[1]
-    ) => ReturnType<typeof signMessage<TChain, TSmartAccount>>
+        args: Parameters<
+            typeof signMessage<entryPoint, TChain, TSmartAccount>
+        >[1]
+    ) => ReturnType<typeof signMessage<entryPoint, TChain, TSmartAccount>>
     /**
      * Signs typed data and calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
      *
@@ -242,6 +246,7 @@ export type SmartAccountActions<
     >(
         args: Parameters<
             typeof signTypedData<
+                entryPoint,
                 TTypedData,
                 TPrimaryType,
                 TChain,
@@ -249,7 +254,13 @@ export type SmartAccountActions<
             >
         >[1]
     ) => ReturnType<
-        typeof signTypedData<TTypedData, TPrimaryType, TChain, TSmartAccount>
+        typeof signTypedData<
+            entryPoint,
+            TTypedData,
+            TPrimaryType,
+            TChain,
+            TSmartAccount
+        >
     >
     /**
      * Deploys a contract to the network, given bytecode and constructor arguments.
@@ -289,7 +300,7 @@ export type SmartAccountActions<
                 TChainOverride
             >
         >
-    ) => ReturnType<typeof deployContract<TChain, TSmartAccount>>
+    ) => ReturnType<typeof deployContract<entryPoint, TChain, TSmartAccount>>
     /**
      * Executes a write function on a contract.
      * This function also allows you to sponsor this transaction if sender is a smartAccount
@@ -361,6 +372,7 @@ export type SmartAccountActions<
         >
     ) => ReturnType<
         typeof writeContract<
+            entryPoint,
             TChain,
             TSmartAccount,
             TAbi,
@@ -373,6 +385,7 @@ export type SmartAccountActions<
         args: Prettify<
             Parameters<
                 typeof prepareUserOperationRequest<
+                    entryPoint,
                     TTransport,
                     TChain,
                     TSmartAccount
@@ -380,11 +393,16 @@ export type SmartAccountActions<
             >[1]
         >,
         stateOverrides?: StateOverrides
-    ) => Promise<Prettify<PrepareUserOperationRequestReturnType>>
+    ) => Promise<Prettify<PrepareUserOperationRequestReturnType<entryPoint>>>
     sendUserOperation: <TTransport extends Transport>(
         args: Prettify<
             Parameters<
-                typeof sendUserOperation<TTransport, TChain, TSmartAccount>
+                typeof sendUserOperation<
+                    entryPoint,
+                    TTransport,
+                    TChain,
+                    TSmartAccount
+                >
             >[1]
         >
     ) => Promise<Hash>
@@ -438,57 +456,117 @@ export type SmartAccountActions<
      * }])
      */
     sendTransactions: (
-        args: Prettify<SendTransactionsWithPaymasterParameters<TSmartAccount>>
-    ) => ReturnType<typeof sendTransactions<TChain, TSmartAccount>>
+        args: Prettify<
+            SendTransactionsWithPaymasterParameters<entryPoint, TSmartAccount>
+        >
+    ) => ReturnType<typeof sendTransactions<TChain, TSmartAccount, entryPoint>>
 }
 
-export function smartAccountActions({
-    sponsorUserOperation
-}: SponsorUserOperationMiddleware) {
+export function smartAccountActions<entryPoint extends EntryPoint>({
+    middleware
+}: Middleware<entryPoint>) {
     return <
         TTransport extends Transport,
         TChain extends Chain | undefined = Chain | undefined,
-        TSmartAccount extends SmartAccount | undefined =
-            | SmartAccount
+        TSmartAccount extends SmartAccount<entryPoint> | undefined =
+            | SmartAccount<entryPoint>
             | undefined
     >(
         client: Client<TTransport, TChain, TSmartAccount>
-    ): SmartAccountActions<TChain, TSmartAccount> => ({
+    ): SmartAccountActions<entryPoint, TChain, TSmartAccount> => ({
         prepareUserOperationRequest: (args, stateOverrides) =>
             prepareUserOperationRequest(
                 client,
                 {
                     ...args,
-                    sponsorUserOperation
+                    middleware
                 },
                 stateOverrides
             ),
         deployContract: (args) =>
             deployContract(client, {
                 ...args,
-                sponsorUserOperation
-            } as DeployContractParametersWithPaymaster),
+                middleware
+            } as DeployContractParametersWithPaymaster<entryPoint>),
         sendTransaction: (args) =>
-            sendTransaction(client, {
+            sendTransaction<TChain, TSmartAccount, entryPoint>(client, {
                 ...args,
-                sponsorUserOperation
-            } as SendTransactionWithPaymasterParameters<TChain, TSmartAccount>),
+                middleware
+            } as SendTransactionWithPaymasterParameters<
+                entryPoint,
+                TChain,
+                TSmartAccount
+            >),
         sendTransactions: (args) =>
-            sendTransactions(client, {
+            sendTransactions<TChain, TSmartAccount, entryPoint>(client, {
                 ...args,
-                sponsorUserOperation
-            } as SendTransactionsWithPaymasterParameters<TSmartAccount>),
+                middleware
+            }),
         sendUserOperation: (args) =>
-            sendUserOperation(client, {
-                ...args,
-                sponsorUserOperation
-            } as SendUserOperationParameters<TSmartAccount>),
-        signMessage: (args) => signMessage(client, args),
-        signTypedData: (args) => signTypedData(client, args),
-        writeContract: (args) =>
+            sendUserOperation<entryPoint, TTransport, TChain, TSmartAccount>(
+                client,
+                {
+                    ...args,
+                    middleware
+                } as SendUserOperationParameters<entryPoint, TSmartAccount>
+            ),
+        signMessage: (args) =>
+            signMessage<entryPoint, TChain, TSmartAccount>(client, args),
+        signTypedData: <
+            const TTypedData extends TypedData | { [key: string]: unknown },
+            TPrimaryType extends string
+        >(
+            args: Parameters<
+                typeof signTypedData<
+                    entryPoint,
+                    TTypedData,
+                    TPrimaryType,
+                    TChain,
+                    TSmartAccount
+                >
+            >[1]
+        ) =>
+            signTypedData<
+                entryPoint,
+                TTypedData,
+                TPrimaryType,
+                TChain,
+                TSmartAccount
+            >(client, args),
+        writeContract: <
+            const TAbi extends Abi | readonly unknown[],
+            TFunctionName extends ContractFunctionName<
+                TAbi,
+                "nonpayable" | "payable"
+            > = ContractFunctionName<TAbi, "nonpayable" | "payable">,
+            TArgs extends ContractFunctionArgs<
+                TAbi,
+                "nonpayable" | "payable",
+                TFunctionName
+            > = ContractFunctionArgs<
+                TAbi,
+                "nonpayable" | "payable",
+                TFunctionName
+            >,
+            TChainOverride extends Chain | undefined = undefined
+        >(
+            args: WriteContractParameters<
+                TAbi,
+                TFunctionName,
+                TArgs,
+                TChain,
+                TSmartAccount,
+                TChainOverride
+            >
+        ) =>
             writeContract(client, {
                 ...args,
-                sponsorUserOperation
-            } as WriteContractWithPaymasterParameters<TChain, TSmartAccount>)
+                middleware
+            } as WriteContractWithPaymasterParameters<
+                entryPoint,
+                TChain,
+                TSmartAccount,
+                TAbi
+            >)
     })
 }

package/clients/decorators/stackup.ts

@@ -8,9 +8,10 @@ import {
     type SponsorUserOperationReturnType,
     sponsorUserOperation
 } from "../../actions/stackup/sponsorUserOperation"
+import type { EntryPoint } from "../../types/entrypoint"
 import { type StackupPaymasterClient } from "../stackup"
 
-export type StackupPaymasterClientActions = {
+export type StackupPaymasterClientActions<entryPoint extends EntryPoint> = {
     /**
      * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
      *
@@ -35,8 +36,8 @@ export type StackupPaymasterClientActions = {
      *
      */
     sponsorUserOperation: (
-        args: SponsorUserOperationParameters
-    ) => Promise<SponsorUserOperationReturnType>
+        args: SponsorUserOperationParameters<entryPoint>
+    ) => Promise<SponsorUserOperationReturnType<entryPoint>>
 
     /**
      * Returns all the Paymaster addresses associated with an EntryPoint that’s owned by this service.
@@ -60,14 +61,17 @@ export type StackupPaymasterClientActions = {
      * }})
      *
      */
-    accounts: (args: AccountsParameters) => Promise<Address[]>
+    accounts: (args: AccountsParameters<entryPoint>) => Promise<Address[]>
 }
 
-export const stackupPaymasterActions = (
+export const stackupPaymasterActions = <entryPoint extends EntryPoint>(
     client: Client
-): StackupPaymasterClientActions => ({
-    sponsorUserOperation: async (args: SponsorUserOperationParameters) =>
-        sponsorUserOperation(client as StackupPaymasterClient, args),
-    accounts: async (args: AccountsParameters) =>
-        accounts(client as StackupPaymasterClient, args)
+): StackupPaymasterClientActions<entryPoint> => ({
+    sponsorUserOperation: async (args) =>
+        sponsorUserOperation<entryPoint>(
+            client as StackupPaymasterClient<entryPoint>,
+            args
+        ),
+    accounts: async (args) =>
+        accounts(client as StackupPaymasterClient<entryPoint>, args)
 })

package/clients/pimlico.ts

@@ -6,6 +6,7 @@ import type {
     Transport
 } from "viem"
 import { createClient } from "viem"
+import type { EntryPoint } from "../types/entrypoint"
 import type {
     PimlicoBundlerRpcSchema,
     PimlicoPaymasterRpcSchema
@@ -18,20 +19,20 @@ import {
     pimlicoPaymasterActions
 } from "./decorators/pimlico"
 
-export type PimlicoBundlerClient = Client<
+export type PimlicoBundlerClient<entryPoint extends EntryPoint> = Client<
     Transport,
     Chain | undefined,
     Account | undefined,
     PimlicoBundlerRpcSchema,
-    PimlicoBundlerActions & BundlerActions
+    PimlicoBundlerActions & BundlerActions<entryPoint>
 >
 
-export type PimlicoPaymasterClient = Client<
+export type PimlicoPaymasterClient<entryPoint extends EntryPoint> = Client<
     Transport,
     Chain | undefined,
     Account | undefined,
-    PimlicoPaymasterRpcSchema,
-    PimlicoPaymasterClientActions
+    PimlicoPaymasterRpcSchema<entryPoint>,
+    PimlicoPaymasterClientActions<entryPoint>
 >
 
 /**
@@ -54,11 +55,14 @@ export type PimlicoPaymasterClient = Client<
  * })
  */
 export const createPimlicoBundlerClient = <
-    transport extends Transport,
+    entryPoint extends EntryPoint,
+    transport extends Transport = Transport,
     chain extends Chain | undefined = undefined
 >(
-    parameters: PublicClientConfig<transport, chain>
-): PimlicoBundlerClient => {
+    parameters: PublicClientConfig<transport, chain> & {
+        entryPoint: entryPoint
+    }
+): PimlicoBundlerClient<entryPoint> => {
     const { key = "public", name = "Pimlico Bundler Client" } = parameters
     const client = createClient({
         ...parameters,
@@ -66,7 +70,9 @@ export const createPimlicoBundlerClient = <
         name,
         type: "pimlicoBundlerClient"
     })
-    return client.extend(bundlerActions).extend(pimlicoBundlerActions)
+    return client
+        .extend(bundlerActions(parameters.entryPoint))
+        .extend(pimlicoBundlerActions)
 }
 
 /**
@@ -89,11 +95,14 @@ export const createPimlicoBundlerClient = <
  * })
  */
 export const createPimlicoPaymasterClient = <
-    transport extends Transport,
+    entryPoint extends EntryPoint,
+    transport extends Transport = Transport,
     chain extends Chain | undefined = undefined
 >(
-    parameters: PublicClientConfig<transport, chain>
-): PimlicoPaymasterClient => {
+    parameters: PublicClientConfig<transport, chain> & {
+        entryPoint: entryPoint
+    }
+): PimlicoPaymasterClient<entryPoint> => {
     const { key = "public", name = "Pimlico Paymaster Client" } = parameters
     const client = createClient({
         ...parameters,
@@ -101,5 +110,5 @@ export const createPimlicoPaymasterClient = <
         name,
         type: "pimlicoPaymasterClient"
     })
-    return client.extend(pimlicoPaymasterActions)
+    return client.extend(pimlicoPaymasterActions(parameters.entryPoint))
 }

package/clients/stackup.ts

@@ -6,6 +6,7 @@ import {
     type Transport,
     createClient
 } from "viem"
+import type { EntryPoint } from "../types/entrypoint"
 import type { StackupPaymasterRpcSchema } from "../types/stackup"
 import { type BundlerActions, bundlerActions } from "./decorators/bundler"
 import {
@@ -13,12 +14,12 @@ import {
     stackupPaymasterActions
 } from "./decorators/stackup"
 
-export type StackupPaymasterClient = Client<
+export type StackupPaymasterClient<entryPoint extends EntryPoint> = Client<
     Transport,
     Chain | undefined,
     Account | undefined,
-    StackupPaymasterRpcSchema,
-    StackupPaymasterClientActions & BundlerActions
+    StackupPaymasterRpcSchema<entryPoint>,
+    StackupPaymasterClientActions<entryPoint> & BundlerActions<entryPoint>
 >
 
 /**
@@ -41,11 +42,14 @@ export type StackupPaymasterClient = Client<
  * })
  */
 export const createStackupPaymasterClient = <
-    transport extends Transport,
+    entryPoint extends EntryPoint,
+    transport extends Transport = Transport,
     chain extends Chain | undefined = undefined
 >(
-    parameters: PublicClientConfig<transport, chain>
-): StackupPaymasterClient => {
+    parameters: PublicClientConfig<transport, chain> & {
+        entryPoint: entryPoint
+    }
+): StackupPaymasterClient<entryPoint> => {
     const { key = "public", name = "Stackup Paymaster Client" } = parameters
     const client = createClient({
         ...parameters,
@@ -53,5 +57,7 @@ export const createStackupPaymasterClient = <
         name,
         type: "stackupPaymasterClient"
     })
-    return client.extend(bundlerActions).extend(stackupPaymasterActions)
+    return client
+        .extend(bundlerActions(parameters.entryPoint))
+        .extend(stackupPaymasterActions<entryPoint>)
 }