permissionless 0.0.35 → 0.1.0

package/actions/bundler/sendUserOperation.ts

@@ -1,15 +1,8 @@
-import type {
-    Account,
-    Address,
-    BaseError,
-    Chain,
-    Client,
-    Hash,
-    Transport
-} from "viem"
+import type { Account, BaseError, Chain, Client, Hash, Transport } from "viem"
 import type { BundlerClient } from "../../clients/createBundlerClient"
 import type { Prettify } from "../../types/"
 import type { BundlerRpcSchema } from "../../types/bundler"
+import type { EntryPoint, GetEntryPointVersion } from "../../types/entrypoint"
 import type {
     UserOperation,
     UserOperationWithBigIntAsHex
@@ -17,9 +10,9 @@ import type {
 import { deepHexlify } from "../../utils/deepHexlify"
 import { getSendUserOperationError } from "../../utils/errors/getSendUserOperationError"
 
-export type SendUserOperationParameters = {
-    userOperation: UserOperation
-    entryPoint: Address
+export type SendUserOperationParameters<entryPoint extends EntryPoint> = {
+    userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+    entryPoint: entryPoint
 }
 
 /**
@@ -48,12 +41,13 @@ export type SendUserOperationParameters = {
  * // Return '0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34'
  */
 export const sendUserOperation = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
-    args: Prettify<SendUserOperationParameters>
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema<entryPoint>>,
+    args: Prettify<SendUserOperationParameters<entryPoint>>
 ): Promise<Hash> => {
     const { userOperation, entryPoint } = args
 
@@ -61,8 +55,10 @@ export const sendUserOperation = async <
         const userOperationHash = await client.request({
             method: "eth_sendUserOperation",
             params: [
-                deepHexlify(userOperation) as UserOperationWithBigIntAsHex,
-                entryPoint as Address
+                deepHexlify(userOperation) as UserOperationWithBigIntAsHex<
+                    GetEntryPointVersion<entryPoint>
+                >,
+                entryPoint
             ]
         })
 
@@ -70,7 +66,7 @@ export const sendUserOperation = async <
     } catch (err) {
         throw getSendUserOperationError(
             err as BaseError,
-            args as SendUserOperationParameters
+            args as SendUserOperationParameters<entryPoint>
         )
     }
 }

package/actions/bundler/supportedEntryPoints.ts

@@ -1,6 +1,7 @@
-import type { Account, Address, Chain, Client, Transport } from "viem"
+import type { Account, Chain, Client, Transport } from "viem"
 import type { BundlerClient } from "../../clients/createBundlerClient"
 import type { BundlerRpcSchema } from "../../types/bundler"
+import type { EntryPoint } from "../../types/entrypoint"
 
 /**
  * Returns the supported entrypoints by the bundler service
@@ -25,12 +26,13 @@ import type { BundlerRpcSchema } from "../../types/bundler"
  *
  */
 export const supportedEntryPoints = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>
-): Promise<Address[]> => {
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema<entryPoint>>
+): Promise<EntryPoint[]> => {
     return client.request({
         method: "eth_supportedEntryPoints",
         params: []

package/actions/pimlico/getUserOperationGasPrice.ts

@@ -45,25 +45,23 @@ export const getUserOperationGasPrice = async <
 >(
     client: Client<TTransport, TChain, TAccount, PimlicoBundlerRpcSchema>
 ): Promise<Prettify<GetUserOperationGasPriceReturnType>> => {
-    const gasPrices = await client.request({
+    const gasPrice = await client.request({
         method: "pimlico_getUserOperationGasPrice",
         params: []
     })
 
     return {
         slow: {
-            maxFeePerGas: BigInt(gasPrices.slow.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.slow.maxPriorityFeePerGas)
+            maxFeePerGas: BigInt(gasPrice.slow.maxFeePerGas),
+            maxPriorityFeePerGas: BigInt(gasPrice.slow.maxPriorityFeePerGas)
         },
         standard: {
-            maxFeePerGas: BigInt(gasPrices.standard.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(
-                gasPrices.standard.maxPriorityFeePerGas
-            )
+            maxFeePerGas: BigInt(gasPrice.standard.maxFeePerGas),
+            maxPriorityFeePerGas: BigInt(gasPrice.standard.maxPriorityFeePerGas)
         },
         fast: {
-            maxFeePerGas: BigInt(gasPrices.fast.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.fast.maxPriorityFeePerGas)
+            maxFeePerGas: BigInt(gasPrice.fast.maxFeePerGas),
+            maxPriorityFeePerGas: BigInt(gasPrice.fast.maxPriorityFeePerGas)
         }
     }
 }

package/actions/pimlico/sponsorUserOperation.ts

@@ -1,26 +1,58 @@
-import type { Account, Address, Chain, Client, Transport } from "viem"
+import type { Account, Address, Chain, Client, Hex, Transport } from "viem"
 import type { PartialBy } from "viem/types/utils"
 import type { Prettify } from "../../types/"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint,
+    GetEntryPointVersion
+} from "../../types/entrypoint"
 import type { PimlicoPaymasterRpcSchema } from "../../types/pimlico"
 import type {
     UserOperation,
     UserOperationWithBigIntAsHex
 } from "../../types/userOperation"
 import { deepHexlify } from "../../utils/deepHexlify"
+import { ENTRYPOINT_ADDRESS_V06 } from "../../utils/getEntryPointVersion"
 
-export type PimlicoSponsorUserOperationParameters = {
-    userOperation: PartialBy<
-        UserOperation,
-        | "callGasLimit"
-        | "preVerificationGas"
-        | "verificationGasLimit"
-        | "paymasterAndData"
-    >
-    entryPoint: Address
+export type PimlicoSponsorUserOperationParameters<
+    entryPoint extends EntryPoint
+> = {
+    userOperation: entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+        ? PartialBy<
+              UserOperation<"v0.6">,
+              "callGasLimit" | "preVerificationGas" | "verificationGasLimit"
+          >
+        : PartialBy<
+              UserOperation<"v0.7">,
+              | "callGasLimit"
+              | "preVerificationGas"
+              | "verificationGasLimit"
+              | "paymasterVerificationGasLimit"
+              | "paymasterPostOpGasLimit"
+          >
+    entryPoint: entryPoint
     sponsorshipPolicyId?: string
 }
 
-export type SponsorUserOperationReturnType = UserOperation
+export type SponsorUserOperationReturnType<entryPoint extends EntryPoint> =
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+        ? Pick<
+              UserOperation<"v0.6">,
+              | "callGasLimit"
+              | "verificationGasLimit"
+              | "preVerificationGas"
+              | "paymasterAndData"
+          >
+        : Pick<
+              UserOperation<"v0.7">,
+              | "callGasLimit"
+              | "verificationGasLimit"
+              | "preVerificationGas"
+              | "paymaster"
+              | "paymasterVerificationGasLimit"
+              | "paymasterPostOpGasLimit"
+              | "paymasterData"
+          >
 
 /**
  * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
@@ -48,20 +80,28 @@ export type SponsorUserOperationReturnType = UserOperation
  *
  */
 export const sponsorUserOperation = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, PimlicoPaymasterRpcSchema>,
-    args: Prettify<PimlicoSponsorUserOperationParameters>
-): Promise<Prettify<SponsorUserOperationReturnType>> => {
+    client: Client<
+        TTransport,
+        TChain,
+        TAccount,
+        PimlicoPaymasterRpcSchema<entryPoint>
+    >,
+    args: Prettify<PimlicoSponsorUserOperationParameters<entryPoint>>
+): Promise<Prettify<SponsorUserOperationReturnType<entryPoint>>> => {
     const response = await client.request({
         method: "pm_sponsorUserOperation",
         params: args.sponsorshipPolicyId
             ? [
                   deepHexlify(
                       args.userOperation
-                  ) as UserOperationWithBigIntAsHex,
+                  ) as UserOperationWithBigIntAsHex<
+                      GetEntryPointVersion<entryPoint>
+                  >,
                   args.entryPoint,
                   {
                       sponsorshipPolicyId: args.sponsorshipPolicyId
@@ -70,18 +110,52 @@ export const sponsorUserOperation = async <
             : [
                   deepHexlify(
                       args.userOperation
-                  ) as UserOperationWithBigIntAsHex,
+                  ) as UserOperationWithBigIntAsHex<
+                      GetEntryPointVersion<entryPoint>
+                  >,
                   args.entryPoint
               ]
     })
 
-    const userOperation: UserOperation = {
-        ...args.userOperation,
-        paymasterAndData: response.paymasterAndData,
-        preVerificationGas: BigInt(response.preVerificationGas),
-        verificationGasLimit: BigInt(response.verificationGasLimit),
-        callGasLimit: BigInt(response.callGasLimit)
+    if (args.entryPoint === ENTRYPOINT_ADDRESS_V06) {
+        const responseV06 = response as {
+            paymasterAndData: Hex
+            preVerificationGas: Hex
+            verificationGasLimit: Hex
+            callGasLimit: Hex
+            paymaster?: never
+            paymasterVerificationGasLimit?: never
+            paymasterPostOpGasLimit?: never
+            paymasterData?: never
+        }
+        return {
+            paymasterAndData: responseV06.paymasterAndData,
+            preVerificationGas: BigInt(responseV06.preVerificationGas),
+            verificationGasLimit: BigInt(responseV06.verificationGasLimit),
+            callGasLimit: BigInt(responseV06.callGasLimit)
+        } as SponsorUserOperationReturnType<entryPoint>
+    }
+
+    const responseV07 = response as {
+        preVerificationGas: Hex
+        verificationGasLimit: Hex
+        callGasLimit: Hex
+        paymaster: Address
+        paymasterVerificationGasLimit: Hex
+        paymasterPostOpGasLimit: Hex
+        paymasterData: Hex
+        paymasterAndData?: never
     }
 
-    return userOperation
+    return {
+        callGasLimit: BigInt(responseV07.callGasLimit),
+        verificationGasLimit: BigInt(responseV07.verificationGasLimit),
+        preVerificationGas: BigInt(responseV07.preVerificationGas),
+        paymaster: responseV07.paymaster,
+        paymasterVerificationGasLimit: BigInt(
+            responseV07.paymasterVerificationGasLimit
+        ),
+        paymasterPostOpGasLimit: BigInt(responseV07.paymasterPostOpGasLimit),
+        paymasterData: responseV07.paymasterData
+    } as SponsorUserOperationReturnType<entryPoint>
 }

package/actions/pimlico/validateSponsorshipPolicies.ts

@@ -1,5 +1,6 @@
-import type { Account, Address, Chain, Client, Transport } from "viem"
+import type { Account, Chain, Client, Transport } from "viem"
 import type { Prettify } from "../../types/"
+import type { EntryPoint, GetEntryPointVersion } from "../../types/entrypoint"
 import type { PimlicoPaymasterRpcSchema } from "../../types/pimlico"
 import type {
     UserOperation,
@@ -7,9 +8,11 @@ import type {
 } from "../../types/userOperation"
 import { deepHexlify } from "../../utils/deepHexlify"
 
-export type ValidateSponsorshipPoliciesParameters = {
-    userOperation: UserOperation
-    entryPoint: Address
+export type ValidateSponsorshipPoliciesParameters<
+    entryPoint extends EntryPoint
+> = {
+    userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+    entryPoint: entryPoint
     sponsorshipPolicyIds: string[]
 }
 
@@ -59,17 +62,25 @@ export type ValidateSponsorshipPolicies = {
  * ]
  */
 export const validateSponsorshipPolicies = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, PimlicoPaymasterRpcSchema>,
-    args: Prettify<ValidateSponsorshipPoliciesParameters>
+    client: Client<
+        TTransport,
+        TChain,
+        TAccount,
+        PimlicoPaymasterRpcSchema<entryPoint>
+    >,
+    args: Prettify<ValidateSponsorshipPoliciesParameters<entryPoint>>
 ): Promise<Prettify<ValidateSponsorshipPolicies>[]> => {
     return await client.request({
         method: "pm_validateSponsorshipPolicies",
         params: [
-            deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex,
+            deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex<
+                GetEntryPointVersion<entryPoint>
+            >,
             args.entryPoint,
             args.sponsorshipPolicyIds
         ]

package/actions/public/getAccountNonce.ts

@@ -1,11 +1,12 @@
 import type { Address, Chain, Client, Transport } from "viem"
 import { readContract } from "viem/actions"
 import type { Prettify } from "../../types/"
+import type { EntryPoint } from "../../types/entrypoint"
 import { getAction } from "../../utils/getAction"
 
 export type GetAccountNonceParams = {
     sender: Address
-    entryPoint: Address
+    entryPoint: EntryPoint
     key?: bigint
 }
 

package/actions/public/getSenderAddress.ts

@@ -6,14 +6,32 @@ import {
     type ContractFunctionExecutionErrorType,
     type ContractFunctionRevertedErrorType,
     type Hex,
-    type Transport
+    type Transport,
+    concat
 } from "viem"
 
 import { simulateContract } from "viem/actions"
 import type { Prettify } from "../../types/"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "../../types/entrypoint"
 import { getAction } from "../../utils/getAction"
 
-export type GetSenderAddressParams = { initCode: Hex; entryPoint: Address }
+export type GetSenderAddressParams<entryPoint extends EntryPoint> =
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+        ? {
+              initCode: Hex
+              entryPoint: entryPoint
+              factory?: never
+              factoryData?: never
+          }
+        : {
+              entryPoint: entryPoint
+              factory: Address
+              factoryData: Hex
+              initCode?: never
+          }
 
 export class InvalidEntryPointError extends BaseError {
     override name = "InvalidEntryPointError"
@@ -59,13 +77,20 @@ export class InvalidEntryPointError extends BaseError {
  * // Return '0x7a88a206ba40b37a8c07a2b5688cf8b287318b63'
  */
 export const getSenderAddress = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >(
     client: Client<TTransport, TChain>,
-    args: Prettify<GetSenderAddressParams>
+    args: Prettify<GetSenderAddressParams<entryPoint>>
 ): Promise<Address> => {
-    const { initCode, entryPoint } = args
+    const { initCode, entryPoint, factory, factoryData } = args
+
+    if (!initCode && !factory && !factoryData) {
+        throw new Error(
+            "Either `initCode` or `factory` and `factoryData` must be provided"
+        )
+    }
 
     try {
         await getAction(
@@ -100,7 +125,7 @@ export const getSenderAddress = async <
                 }
             ],
             functionName: "getSenderAddress",
-            args: [initCode]
+            args: [initCode || concat([factory as Hex, factoryData as Hex])]
         })
     } catch (e) {
         const err = e as ContractFunctionExecutionErrorType

package/actions/smartAccount/deployContract.ts

@@ -9,20 +9,24 @@ import type {
 } from "viem"
 import type { SmartAccount } from "../../accounts/types"
 import type { Prettify } from "../../types/"
+import type { EntryPoint } from "../../types/entrypoint"
 import { parseAccount } from "../../utils/"
 import { getAction } from "../../utils/getAction"
 import { AccountOrClientNotFoundError } from "../../utils/signUserOperationHashWithECDSA"
 import { waitForUserOperationReceipt } from "../bundler/waitForUserOperationReceipt"
-import { type SponsorUserOperationMiddleware } from "./prepareUserOperationRequest"
+import { type Middleware } from "./prepareUserOperationRequest"
 import { sendUserOperation } from "./sendUserOperation"
 
 export type DeployContractParametersWithPaymaster<
+    entryPoint extends EntryPoint,
     TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[],
     TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends SmartAccount | undefined = SmartAccount | undefined,
+    TAccount extends SmartAccount<entryPoint> | undefined =
+        | SmartAccount<entryPoint>
+        | undefined,
     TChainOverride extends Chain | undefined = Chain | undefined
 > = DeployContractParameters<TAbi, TChain, TAccount, TChainOverride> &
-    SponsorUserOperationMiddleware
+    Middleware<entryPoint>
 
 /**
  * Deploys a contract to the network, given bytecode and constructor arguments.
@@ -53,17 +57,18 @@ export type DeployContractParametersWithPaymaster<
  * })
  */
 export async function deployContract<
+    entryPoint extends EntryPoint,
     TChain extends Chain | undefined,
-    TAccount extends SmartAccount | undefined
+    TAccount extends SmartAccount<entryPoint> | undefined
 >(
     client: Client<Transport, TChain, TAccount>,
-    args: Prettify<DeployContractParametersWithPaymaster>
+    args: Prettify<DeployContractParametersWithPaymaster<entryPoint>>
 ): Promise<Hash> {
     const {
         abi,
         args: constructorArgs,
         bytecode,
-        sponsorUserOperation,
+        middleware,
         ...request
     } = args
 
@@ -75,15 +80,14 @@ export async function deployContract<
         })
     }
 
-    const account = parseAccount(account_) as SmartAccount
+    const account = parseAccount(account_) as SmartAccount<entryPoint>
 
     const userOpHash = await getAction(
         client,
-        sendUserOperation
+        sendUserOperation<entryPoint>
     )({
         userOperation: {
             sender: account.address,
-            paymasterAndData: "0x",
             maxFeePerGas: request.maxFeePerGas || 0n,
             maxPriorityFeePerGas: request.maxPriorityFeePerGas || 0n,
             callData: await account.encodeDeployCallData({
@@ -93,7 +97,7 @@ export async function deployContract<
             } as EncodeDeployDataParameters)
         },
         account: account,
-        sponsorUserOperation
+        middleware
     })
 
     const userOperationReceipt = await getAction(