permissionless 0.0.35 → 0.1.0

package/accounts/biconomy/signerToBiconomySmartAccount.ts

@@ -20,6 +20,8 @@ import { toAccount } from "viem/accounts"
 import { getChainId, signMessage, signTypedData } from "viem/actions"
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
 import type { Prettify } from "../../types"
+import type { ENTRYPOINT_ADDRESS_V06_TYPE } from "../../types/entrypoint"
+import { getEntryPointVersion } from "../../utils"
 import { getUserOperationHash } from "../../utils/getUserOperationHash"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
 import {
@@ -31,12 +33,12 @@ import {
     BiconomyExecuteAbi,
     BiconomyInitAbi
 } from "./abi/BiconomySmartAccountAbi"
-// import Abis
 
 export type BiconomySmartAccount<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined
-> = SmartAccount<"biconomySmartAccount", transport, chain>
+> = SmartAccount<entryPoint, "biconomySmartAccount", transport, chain>
 
 /**
  * The account creation ABI for Biconomy Smart Account (from the biconomy SmartAccountFactory)
@@ -104,12 +106,10 @@ const BICONOMY_PROXY_CREATION_CODE =
 const getAccountInitCode = async ({
     owner,
     index,
-    factoryAddress,
     ecdsaModuleAddress
 }: {
     owner: Address
     index: bigint
-    factoryAddress: Address
     ecdsaModuleAddress: Address
 }): Promise<Hex> => {
     if (!owner) throw new Error("Owner account not found")
@@ -122,14 +122,11 @@ const getAccountInitCode = async ({
     })
 
     // Build the account init code
-    return concatHex([
-        factoryAddress,
-        encodeFunctionData({
-            abi: createAccountAbi,
-            functionName: "deployCounterFactualAccount",
-            args: [ecdsaModuleAddress, ecdsaOwnershipInitData, index]
-        }) as Hex
-    ])
+    return encodeFunctionData({
+        abi: createAccountAbi,
+        functionName: "deployCounterFactualAccount",
+        args: [ecdsaModuleAddress, ecdsaOwnershipInitData, index]
+    })
 }
 
 const getAccountAddress = async ({
@@ -186,11 +183,12 @@ const getAccountAddress = async ({
 }
 
 export type SignerToBiconomySmartAccountParameters<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TSource extends string = "custom",
     TAddress extends Address = Address
 > = Prettify<{
     signer: SmartAccountSigner<TSource, TAddress>
-    entryPoint: Address
+    entryPoint: entryPoint
     address?: Address
     index?: bigint
     factoryAddress?: Address
@@ -210,6 +208,7 @@ export type SignerToBiconomySmartAccountParameters<
  * @param ecdsaModuleAddress
  */
 export async function signerToBiconomySmartAccount<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TSource extends string = "custom",
@@ -219,14 +218,20 @@ export async function signerToBiconomySmartAccount<
     {
         signer,
         address,
-        entryPoint,
+        entryPoint: entryPointAddress,
         index = 0n,
         factoryAddress = BICONOMY_ADDRESSES.FACTORY_ADDRESS,
         accountLogicAddress = BICONOMY_ADDRESSES.ACCOUNT_V2_0_LOGIC,
         fallbackHandlerAddress = BICONOMY_ADDRESSES.DEFAULT_FALLBACK_HANDLER_ADDRESS,
         ecdsaModuleAddress = BICONOMY_ADDRESSES.ECDSA_OWNERSHIP_REGISTRY_MODULE
-    }: SignerToBiconomySmartAccountParameters<TSource, TAddress>
-): Promise<BiconomySmartAccount<TTransport, TChain>> {
+    }: SignerToBiconomySmartAccountParameters<entryPoint, TSource, TAddress>
+): Promise<BiconomySmartAccount<entryPoint, TTransport, TChain>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (entryPointVersion !== "v0.6") {
+        throw new Error("Only EntryPoint 0.6 is supported")
+    }
+
     // Get the private key related account
     const viemSigner: LocalAccount = {
         ...signer,
@@ -240,7 +245,6 @@ export async function signerToBiconomySmartAccount<
         getAccountInitCode({
             owner: viemSigner.address,
             index,
-            factoryAddress,
             ecdsaModuleAddress
         })
 
@@ -294,14 +298,14 @@ export async function signerToBiconomySmartAccount<
         ...account,
         client: client,
         publicKey: accountAddress,
-        entryPoint: entryPoint,
+        entryPoint: entryPointAddress,
         source: "biconomySmartAccount",
 
         // Get the nonce of the smart account
         async getNonce() {
             return getAccountNonce(client, {
                 sender: accountAddress,
-                entryPoint: entryPoint
+                entryPoint: entryPointAddress
             })
         },
 
@@ -312,7 +316,7 @@ export async function signerToBiconomySmartAccount<
                     ...userOperation,
                     signature: "0x"
                 },
-                entryPoint: entryPoint,
+                entryPoint: entryPointAddress,
                 chainId: chainId
             })
             const signature = await signMessage(client, {
@@ -327,6 +331,31 @@ export async function signerToBiconomySmartAccount<
             return signatureWithModuleAddress
         },
 
+        async getFactory() {
+            if (smartAccountDeployed) return undefined
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return undefined
+
+            return factoryAddress
+        },
+
+        async getFactoryData() {
+            if (smartAccountDeployed) return undefined
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return undefined
+            return generateInitCode()
+        },
+
         // Encode the init code
         async getInitCode() {
             if (smartAccountDeployed) return "0x"
@@ -338,7 +367,7 @@ export async function signerToBiconomySmartAccount<
 
             if (smartAccountDeployed) return "0x"
 
-            return generateInitCode()
+            return concatHex([factoryAddress, await generateInitCode()])
         },
 
         // Encode the deploy call data

package/accounts/kernel/signerToEcdsaKernelSmartAccount.ts

@@ -21,6 +21,8 @@ import {
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
 import { getSenderAddress } from "../../actions/public/getSenderAddress"
 import type { Prettify } from "../../types"
+import type { ENTRYPOINT_ADDRESS_V06_TYPE } from "../../types/entrypoint"
+import { getEntryPointVersion } from "../../utils"
 import { getUserOperationHash } from "../../utils/getUserOperationHash"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
 import type { SmartAccount } from "../types"
@@ -31,9 +33,10 @@ import {
 import { KernelExecuteAbi, KernelInitAbi } from "./abi/KernelAccountAbi"
 
 export type KernelEcdsaSmartAccount<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined
-> = SmartAccount<"kernelEcdsaSmartAccount", transport, chain>
+> = SmartAccount<entryPoint, "kernelEcdsaSmartAccount", transport, chain>
 
 /**
  * The account creation ABI for a kernel smart account (from the KernelFactory)
@@ -94,13 +97,11 @@ const KERNEL_ADDRESSES: {
 const getAccountInitCode = async ({
     owner,
     index,
-    factoryAddress,
     accountLogicAddress,
     ecdsaValidatorAddress
 }: {
     owner: Address
     index: bigint
-    factoryAddress: Address
     accountLogicAddress: Address
     ecdsaValidatorAddress: Address
 }): Promise<Hex> => {
@@ -114,14 +115,11 @@ const getAccountInitCode = async ({
     })
 
     // Build the account init code
-    return concatHex([
-        factoryAddress,
-        encodeFunctionData({
-            abi: createAccountAbi,
-            functionName: "createAccount",
-            args: [accountLogicAddress, initialisationData, index]
-        }) as Hex
-    ])
+    return encodeFunctionData({
+        abi: createAccountAbi,
+        functionName: "createAccount",
+        args: [accountLogicAddress, initialisationData, index]
+    })
 }
 
 /**
@@ -134,20 +132,23 @@ const getAccountInitCode = async ({
  * @param deployedAccountAddress
  */
 const getAccountAddress = async <
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >({
     client,
     owner,
-    entryPoint,
+    entryPoint: entryPointAddress,
     initCodeProvider,
     ecdsaValidatorAddress,
-    deployedAccountAddress
+    deployedAccountAddress,
+    factoryAddress
 }: {
     client: Client<TTransport, TChain>
     owner: Address
     initCodeProvider: () => Promise<Hex>
-    entryPoint: Address
+    factoryAddress: Address
+    entryPoint: entryPoint
     ecdsaValidatorAddress: Address
     deployedAccountAddress?: Address
 }): Promise<Address> => {
@@ -191,21 +192,21 @@ const getAccountAddress = async <
     }
 
     // Find the init code for this account
-    const initCode = await initCodeProvider()
+    const factoryData = await initCodeProvider()
 
-    // Get the sender address based on the init code
-    return getSenderAddress(client, {
-        initCode,
-        entryPoint
+    return getSenderAddress<ENTRYPOINT_ADDRESS_V06_TYPE>(client, {
+        initCode: concatHex([factoryAddress, factoryData]),
+        entryPoint: entryPointAddress as ENTRYPOINT_ADDRESS_V06_TYPE
     })
 }
 
 export type SignerToEcdsaKernelSmartAccountParameters<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TSource extends string = "custom",
     TAddress extends Address = Address
 > = Prettify<{
     signer: SmartAccountSigner<TSource, TAddress>
-    entryPoint: Address
+    entryPoint: entryPoint
     address?: Address
     index?: bigint
     factoryAddress?: Address
@@ -225,6 +226,7 @@ export type SignerToEcdsaKernelSmartAccountParameters<
  * @param deployedAccountAddress
  */
 export async function signerToEcdsaKernelSmartAccount<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TSource extends string = "custom",
@@ -234,14 +236,20 @@ export async function signerToEcdsaKernelSmartAccount<
     {
         signer,
         address,
-        entryPoint,
+        entryPoint: entryPointAddress,
         index = 0n,
         factoryAddress = KERNEL_ADDRESSES.FACTORY_ADDRESS,
         accountLogicAddress = KERNEL_ADDRESSES.ACCOUNT_V2_2_LOGIC,
         ecdsaValidatorAddress = KERNEL_ADDRESSES.ECDSA_VALIDATOR,
         deployedAccountAddress
-    }: SignerToEcdsaKernelSmartAccountParameters<TSource, TAddress>
-): Promise<KernelEcdsaSmartAccount<TTransport, TChain>> {
+    }: SignerToEcdsaKernelSmartAccountParameters<entryPoint, TSource, TAddress>
+): Promise<KernelEcdsaSmartAccount<entryPoint, TTransport, TChain>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (entryPointVersion !== "v0.6") {
+        throw new Error("Only EntryPoint 0.6 is supported")
+    }
+
     // Get the private key related account
     const viemSigner: LocalAccount = {
         ...signer,
@@ -255,7 +263,6 @@ export async function signerToEcdsaKernelSmartAccount<
         getAccountInitCode({
             owner: viemSigner.address,
             index,
-            factoryAddress,
             accountLogicAddress,
             ecdsaValidatorAddress
         })
@@ -263,13 +270,14 @@ export async function signerToEcdsaKernelSmartAccount<
     // Fetch account address and chain id
     const [accountAddress, chainId] = await Promise.all([
         address ??
-            getAccountAddress<TTransport, TChain>({
+            getAccountAddress<entryPoint, TTransport, TChain>({
                 client,
-                entryPoint,
+                entryPoint: entryPointAddress,
                 owner: viemSigner.address,
                 ecdsaValidatorAddress,
                 initCodeProvider: generateInitCode,
-                deployedAccountAddress
+                deployedAccountAddress,
+                factoryAddress
             }),
         getChainId(client)
     ])
@@ -310,14 +318,14 @@ export async function signerToEcdsaKernelSmartAccount<
         ...account,
         client: client,
         publicKey: accountAddress,
-        entryPoint: entryPoint,
+        entryPoint: entryPointAddress,
         source: "kernelEcdsaSmartAccount",
 
         // Get the nonce of the smart account
         async getNonce() {
             return getAccountNonce(client, {
                 sender: accountAddress,
-                entryPoint: entryPoint
+                entryPoint: entryPointAddress
             })
         },
 
@@ -328,7 +336,7 @@ export async function signerToEcdsaKernelSmartAccount<
                     ...userOperation,
                     signature: "0x"
                 },
-                entryPoint: entryPoint,
+                entryPoint: entryPointAddress,
                 chainId: chainId
             })
             const signature = await signMessage(client, {
@@ -350,6 +358,32 @@ export async function signerToEcdsaKernelSmartAccount<
 
             if (smartAccountDeployed) return "0x"
 
+            return concatHex([factoryAddress, await generateInitCode()])
+        },
+
+        async getFactory() {
+            if (smartAccountDeployed) return undefined
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return undefined
+
+            return factoryAddress
+        },
+
+        async getFactoryData() {
+            if (smartAccountDeployed) return undefined
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return undefined
+
             return generateInitCode()
         },
 

package/accounts/safe/privateKeyToSafeSmartAccount.ts

@@ -1,16 +1,18 @@
 import { type Chain, type Client, type Hex, type Transport } from "viem"
 import { privateKeyToAccount } from "viem/accounts"
-import type { Prettify } from "../../types"
+import type { ENTRYPOINT_ADDRESS_V06_TYPE, Prettify } from "../../types"
 import {
     type SafeSmartAccount,
     type SignerToSafeSmartAccountParameters,
     signerToSafeSmartAccount
 } from "./signerToSafeSmartAccount"
 
-export type PrivateKeyToSafeSmartAccountParameters = Prettify<
+export type PrivateKeyToSafeSmartAccountParameters<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+> = Prettify<
     {
         privateKey: Hex
-    } & Omit<SignerToSafeSmartAccountParameters, "signer">
+    } & Omit<SignerToSafeSmartAccountParameters<entryPoint>, "signer">
 >
 
 /**
@@ -19,12 +21,13 @@ export type PrivateKeyToSafeSmartAccountParameters = Prettify<
  * @returns A Private Key Simple Account.
  */
 export async function privateKeyToSafeSmartAccount<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >(
     client: Client<TTransport, TChain, undefined>,
-    { privateKey, ...rest }: PrivateKeyToSafeSmartAccountParameters
-): Promise<SafeSmartAccount<TTransport, TChain>> {
+    { privateKey, ...rest }: PrivateKeyToSafeSmartAccountParameters<entryPoint>
+): Promise<SafeSmartAccount<entryPoint, TTransport, TChain>> {
     const privateKeyAccount = privateKeyToAccount(privateKey)
 
     return signerToSafeSmartAccount(client, {

package/accounts/safe/signerToSafeSmartAccount.ts

@@ -28,7 +28,9 @@ import {
     signTypedData
 } from "viem/actions"
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
-import type { Prettify } from "../../types"
+import type { ENTRYPOINT_ADDRESS_V06_TYPE, Prettify } from "../../types"
+import type { EntryPoint } from "../../types/entrypoint"
+import { getEntryPointVersion } from "../../utils"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
 import {
     SignTransactionNotSupportedBySmartAccount,
@@ -172,9 +174,11 @@ const encodeMultiSend = (
 }
 
 export type SafeSmartAccount<
+    entryPoint extends
+        ENTRYPOINT_ADDRESS_V06_TYPE = ENTRYPOINT_ADDRESS_V06_TYPE,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined
-> = SmartAccount<"SafeSmartAccount", transport, chain>
+> = SmartAccount<entryPoint, "SafeSmartAccount", transport, chain>
 
 const getInitializerCode = async ({
     owner,
@@ -292,7 +296,6 @@ const getAccountInitCode = async ({
     owner,
     addModuleLibAddress,
     safe4337ModuleAddress,
-    safeProxyFactoryAddress,
     safeSingletonAddress,
     multiSendAddress,
     saltNonce = 0n,
@@ -302,7 +305,6 @@ const getAccountInitCode = async ({
     owner: Address
     addModuleLibAddress: Address
     safe4337ModuleAddress: Address
-    safeProxyFactoryAddress: Address
     safeSingletonAddress: Address
     multiSendAddress: Address
     saltNonce?: bigint
@@ -359,7 +361,7 @@ const getAccountInitCode = async ({
         args: [safeSingletonAddress, initializer, saltNonce]
     })
 
-    return concatHex([safeProxyFactoryAddress, initCodeCallData])
+    return initCodeCallData
 }
 
 const getAccountAddress = async <
@@ -490,12 +492,13 @@ const getDefaultAddresses = (
 }
 
 export type SignerToSafeSmartAccountParameters<
+    entryPoint extends EntryPoint,
     TSource extends string = "custom",
     TAddress extends Address = Address
 > = Prettify<{
     signer: SmartAccountSigner<TSource, TAddress>
     safeVersion: SafeVersion
-    entryPoint: Address
+    entryPoint: entryPoint
     address?: Address
     addModuleLibAddress?: Address
     safe4337ModuleAddress?: Address
@@ -520,6 +523,7 @@ export type SignerToSafeSmartAccountParameters<
  * @returns A Private Key Simple Account.
  */
 export async function signerToSafeSmartAccount<
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TSource extends string = "custom",
@@ -530,7 +534,7 @@ export async function signerToSafeSmartAccount<
         signer,
         address,
         safeVersion,
-        entryPoint,
+        entryPoint: entryPointAddress,
         addModuleLibAddress: _addModuleLibAddress,
         safe4337ModuleAddress: _safe4337ModuleAddress,
         safeProxyFactoryAddress: _safeProxyFactoryAddress,
@@ -542,8 +546,14 @@ export async function signerToSafeSmartAccount<
         validAfter = 0,
         safeModules = [],
         setupTransactions = []
-    }: SignerToSafeSmartAccountParameters<TSource, TAddress>
-): Promise<SafeSmartAccount<TTransport, TChain>> {
+    }: SignerToSafeSmartAccountParameters<entryPoint, TSource, TAddress>
+): Promise<SafeSmartAccount<entryPoint, TTransport, TChain>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (entryPointVersion !== "v0.6") {
+        throw new Error("Only EntryPoint 0.6 is supported")
+    }
+
     const chainId = await getChainId(client)
 
     const viemSigner: LocalAccount = {
@@ -647,16 +657,16 @@ export async function signerToSafeSmartAccount<
         }
     })
 
-    return {
+    const safeSmartAccount: SafeSmartAccount<entryPoint, TTransport, TChain> = {
         ...account,
         client: client,
         publicKey: accountAddress,
-        entryPoint: entryPoint,
+        entryPoint: entryPointAddress,
         source: "SafeSmartAccount",
         async getNonce() {
             return getAccountNonce(client, {
                 sender: accountAddress,
-                entryPoint: entryPoint
+                entryPoint: entryPointAddress
             })
         },
         async signUserOperation(userOperation) {
@@ -674,7 +684,7 @@ export async function signerToSafeSmartAccount<
                         message: {
                             safe: accountAddress,
                             callData: userOperation.callData,
-                            entryPoint: entryPoint,
+                            entryPoint: entryPointAddress,
                             nonce: userOperation.nonce,
                             initCode: userOperation.initCode,
                             maxFeePerGas: userOperation.maxFeePerGas,
@@ -713,11 +723,39 @@ export async function signerToSafeSmartAccount<
 
             if (safeDeployed) return "0x"
 
-            return getAccountInitCode({
+            const initCodeCallData = await getAccountInitCode({
+                owner: viemSigner.address,
+                addModuleLibAddress,
+                safe4337ModuleAddress,
+                safeSingletonAddress,
+                multiSendAddress,
+                saltNonce,
+                setupTransactions,
+                safeModules
+            })
+
+            return concatHex([safeProxyFactoryAddress, initCodeCallData])
+        },
+        async getFactory() {
+            if (safeDeployed) return undefined
+
+            safeDeployed = await isSmartAccountDeployed(client, accountAddress)
+
+            if (safeDeployed) return undefined
+
+            return safeProxyFactoryAddress
+        },
+        async getFactoryData() {
+            if (safeDeployed) return undefined
+
+            safeDeployed = await isSmartAccountDeployed(client, accountAddress)
+
+            if (safeDeployed) return undefined
+
+            return await getAccountInitCode({
                 owner: viemSigner.address,
                 addModuleLibAddress,
                 safe4337ModuleAddress,
-                safeProxyFactoryAddress,
                 safeSingletonAddress,
                 multiSendAddress,
                 saltNonce,
@@ -784,13 +822,13 @@ export async function signerToSafeSmartAccount<
                                 type: "uint8"
                             }
                         ],
-                        name: "executeUserOp",
+                        name: "executeUserOpWithErrorString",
                         outputs: [],
                         stateMutability: "nonpayable",
                         type: "function"
                     }
                 ],
-                functionName: "executeUserOp",
+                functionName: "executeUserOpWithErrorString",
                 args: [to, value, data, operationType]
             })
         },
@@ -798,4 +836,6 @@ export async function signerToSafeSmartAccount<
             return "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
         }
     }
+
+    return safeSmartAccount
 }

package/accounts/simple/privateKeyToSimpleSmartAccount.ts

@@ -1,16 +1,24 @@
-import { type Chain, type Client, type Hex, type Transport } from "viem"
+import {
+    type Address,
+    type Chain,
+    type Client,
+    type Hex,
+    type Transport
+} from "viem"
 import { privateKeyToAccount } from "viem/accounts"
-import type { Prettify } from "../../types"
+import type { EntryPoint, Prettify } from "../../types"
 import {
     type SignerToSimpleSmartAccountParameters,
     type SimpleSmartAccount,
     signerToSimpleSmartAccount
 } from "./signerToSimpleSmartAccount"
 
-export type PrivateKeyToSimpleSmartAccountParameters = Prettify<
+export type PrivateKeyToSimpleSmartAccountParameters<
+    entryPoint extends EntryPoint
+> = Prettify<
     {
         privateKey: Hex
-    } & Omit<SignerToSimpleSmartAccountParameters, "signer">
+    } & Omit<SignerToSimpleSmartAccountParameters<entryPoint>, "signer">
 >
 
 /**
@@ -19,15 +27,25 @@ export type PrivateKeyToSimpleSmartAccountParameters = Prettify<
  * @returns A Private Key Simple Account.
  */
 export async function privateKeyToSimpleSmartAccount<
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >(
     client: Client<TTransport, TChain, undefined>,
-    { privateKey, ...rest }: PrivateKeyToSimpleSmartAccountParameters
-): Promise<SimpleSmartAccount<TTransport, TChain>> {
+    {
+        privateKey,
+        ...rest
+    }: PrivateKeyToSimpleSmartAccountParameters<entryPoint>
+): Promise<SimpleSmartAccount<entryPoint, TTransport, TChain>> {
     const privateKeyAccount = privateKeyToAccount(privateKey)
 
-    return signerToSimpleSmartAccount(client, {
+    return signerToSimpleSmartAccount<
+        entryPoint,
+        TTransport,
+        TChain,
+        "privateKey",
+        Address
+    >(client, {
         signer: privateKeyAccount,
         ...rest
     })