permissionless 0.1.34 → 0.1.36

package/actions/smartAccount/prepareUserOperationRequest.test.ts

@@ -2,11 +2,15 @@ import { type Chain, type Client, type Transport, zeroAddress } from "viem"
 import { generatePrivateKey } from "viem/accounts"
 import { describe, expect } from "vitest"
 import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import { getCoreSmartAccounts } from "../../../permissionless-test/src/utils"
+import {
+    getCoreSmartAccounts,
+    getPimlicoBundlerClient,
+    getPimlicoPaymasterClient
+} from "../../../permissionless-test/src/utils"
 import type { SmartAccount } from "../../accounts"
-import type { SmartAccountClient } from "../../clients/createSmartAccountClient"
 import type { EntryPoint } from "../../types/entrypoint"
 import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07 } from "../../utils"
+import { pimlicoPaymasterActions } from "../pimlico"
 import { prepareUserOperationRequest } from "./prepareUserOperationRequest"
 
 describe.each(getCoreSmartAccounts())(
@@ -81,6 +85,189 @@ describe.each(getCoreSmartAccounts())(
             }
         )
 
+        testWithRpc.skipIf(!supportsEntryPointV06)(
+            "prepareUserOperationRequest_v06",
+            async ({ rpc }) => {
+                const { anvilRpc, altoRpc, paymasterRpc } = rpc
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V06,
+                    privateKey: generatePrivateKey(),
+                    altoRpc: altoRpc,
+                    anvilRpc: anvilRpc
+                })
+
+                const pimlicoBundlerClient = getPimlicoBundlerClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V06,
+                    altoRpc: altoRpc
+                })
+
+                const pimlicoPaymasterActions = getPimlicoPaymasterClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V06,
+                    paymasterRpc: paymasterRpc
+                })
+
+                const userOperation = await prepareUserOperationRequest(
+                    smartClient as Client<
+                        Transport,
+                        Chain,
+                        SmartAccount<EntryPoint>
+                    >,
+                    {
+                        userOperation: {
+                            callData: await smartClient.account.encodeCallData({
+                                to: zeroAddress,
+                                data: "0x",
+                                value: 0n
+                            })
+                        },
+                        middleware: {
+                            gasPrice: async () =>
+                                (
+                                    await pimlicoBundlerClient.getUserOperationGasPrice()
+                                ).fast,
+                            sponsorUserOperation:
+                                pimlicoPaymasterActions.sponsorUserOperation
+                        }
+                    }
+                )
+
+                expect(userOperation).toBeTruthy()
+                expect(userOperation.sender).toBe(smartClient.account.address)
+                expect(userOperation.nonce).toBe(
+                    await smartClient.account.getNonce()
+                )
+                expect(userOperation.initCode).toBe(
+                    await smartClient.account.getInitCode()
+                )
+                expect(userOperation.callData).toBe(
+                    await smartClient.account.encodeCallData({
+                        to: zeroAddress,
+                        data: "0x",
+                        value: 0n
+                    })
+                )
+                expect(userOperation.callGasLimit).toBeTruthy()
+                expect(userOperation.verificationGasLimit).toBeTruthy()
+                expect(userOperation.maxFeePerGas).toBeTruthy()
+                expect(userOperation.maxPriorityFeePerGas).toBeTruthy()
+                expect(userOperation.paymasterAndData).toBeTruthy()
+                expect(userOperation.signature).toBe(
+                    // @ts-ignore: since tests return all smart account client, some of them don't support V06.
+                    // The TS error is because in that case, getDummySignature would not accept the userOperation of type UserOperation<V07>
+                    await smartClient.account.getDummySignature(userOperation)
+                )
+
+                expect(userOperation.factory).toBe(undefined)
+                expect(userOperation.factoryData).toBe(undefined)
+                expect(userOperation.paymaster).toBe(undefined)
+                expect(userOperation.paymasterVerificationGasLimit).toBe(
+                    undefined
+                )
+                expect(userOperation.paymasterPostOpGasLimit).toBe(undefined)
+                expect(userOperation.paymasterData).toBe(undefined)
+            }
+        )
+
+        testWithRpc.skipIf(!supportsEntryPointV06)(
+            "prepareUserOperationRequest_v06",
+            async ({ rpc }) => {
+                const { anvilRpc, altoRpc, paymasterRpc } = rpc
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V06,
+                    privateKey: generatePrivateKey(),
+                    altoRpc: altoRpc,
+                    anvilRpc: anvilRpc
+                })
+
+                const pimlicoBundlerClient = getPimlicoBundlerClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V06,
+                    altoRpc: altoRpc
+                })
+                const pimlicoPaymasterActions = getPimlicoPaymasterClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V06,
+                    paymasterRpc: paymasterRpc
+                })
+
+                const userOperation = await prepareUserOperationRequest(
+                    smartClient as Client<
+                        Transport,
+                        Chain,
+                        SmartAccount<EntryPoint>
+                    >,
+                    {
+                        userOperation: {
+                            callData: await smartClient.account.encodeCallData({
+                                to: zeroAddress,
+                                data: "0x",
+                                value: 0n
+                            })
+                        },
+                        middleware: async <T>(args: {
+                            userOperation: T
+                            entryPoint: EntryPoint
+                        }) => {
+                            const gasPrice = (
+                                await pimlicoBundlerClient.getUserOperationGasPrice()
+                            ).fast
+
+                            return {
+                                ...args.userOperation,
+                                maxFeePerGas: gasPrice.maxFeePerGas,
+                                maxPriorityFeePerGas:
+                                    gasPrice.maxPriorityFeePerGas,
+                                ...(await pimlicoPaymasterActions.sponsorUserOperation(
+                                    {
+                                        userOperation: {
+                                            ...args.userOperation,
+                                            maxFeePerGas: gasPrice.maxFeePerGas,
+                                            maxPriorityFeePerGas:
+                                                gasPrice.maxPriorityFeePerGas
+                                        }
+                                    }
+                                ))
+                            } as T
+                        }
+                    }
+                )
+
+                expect(userOperation).toBeTruthy()
+                expect(userOperation.sender).toBe(smartClient.account.address)
+                expect(userOperation.nonce).toBe(
+                    await smartClient.account.getNonce()
+                )
+                expect(userOperation.initCode).toBe(
+                    await smartClient.account.getInitCode()
+                )
+                expect(userOperation.callData).toBe(
+                    await smartClient.account.encodeCallData({
+                        to: zeroAddress,
+                        data: "0x",
+                        value: 0n
+                    })
+                )
+                expect(userOperation.callGasLimit).toBeTruthy()
+                expect(userOperation.verificationGasLimit).toBeTruthy()
+                expect(userOperation.maxFeePerGas).toBeTruthy()
+                expect(userOperation.maxPriorityFeePerGas).toBeTruthy()
+                expect(userOperation.paymasterAndData).toBeTruthy()
+                expect(userOperation.signature).toBe(
+                    // @ts-ignore: since tests return all smart account client, some of them don't support V06.
+                    // The TS error is because in that case, getDummySignature would not accept the userOperation of type UserOperation<V07>
+                    await smartClient.account.getDummySignature(userOperation)
+                )
+
+                expect(userOperation.factory).toBe(undefined)
+                expect(userOperation.factoryData).toBe(undefined)
+                expect(userOperation.paymaster).toBe(undefined)
+                expect(userOperation.paymasterVerificationGasLimit).toBe(
+                    undefined
+                )
+                expect(userOperation.paymasterPostOpGasLimit).toBe(undefined)
+                expect(userOperation.paymasterData).toBe(undefined)
+            }
+        )
         testWithRpc.skipIf(!supportsEntryPointV07)(
             "prepareUserOperationRequest_v07",
             async ({ rpc }) => {
@@ -147,5 +334,187 @@ describe.each(getCoreSmartAccounts())(
                 expect(userOperation.initCode).toBe(undefined)
             }
         )
+
+        testWithRpc.skipIf(!supportsEntryPointV07)(
+            "prepareUserOperationRequest_v07",
+            async ({ rpc }) => {
+                const { anvilRpc, altoRpc, paymasterRpc } = rpc
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    privateKey: generatePrivateKey(),
+                    altoRpc: altoRpc,
+                    anvilRpc: anvilRpc
+                })
+
+                const pimlicoBundlerClient = getPimlicoBundlerClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    altoRpc: altoRpc
+                })
+
+                const pimlicoPaymasterActions = getPimlicoPaymasterClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    paymasterRpc: paymasterRpc
+                })
+
+                const userOperation = await prepareUserOperationRequest(
+                    smartClient as Client<
+                        Transport,
+                        Chain,
+                        SmartAccount<EntryPoint>
+                    >,
+                    {
+                        userOperation: {
+                            callData: await smartClient.account.encodeCallData({
+                                to: zeroAddress,
+                                data: "0x",
+                                value: 0n
+                            })
+                        },
+                        middleware: {
+                            gasPrice: async () =>
+                                (
+                                    await pimlicoBundlerClient.getUserOperationGasPrice()
+                                ).fast,
+                            sponsorUserOperation:
+                                pimlicoPaymasterActions.sponsorUserOperation
+                        }
+                    }
+                )
+
+                expect(userOperation).toBeTruthy()
+                expect(userOperation.sender).toBe(smartClient.account.address)
+                expect(userOperation.nonce).toBe(
+                    await smartClient.account.getNonce()
+                )
+                expect(userOperation.factory).toBe(
+                    await smartClient.account.getFactory()
+                )
+                expect(userOperation.factoryData).toBe(
+                    await smartClient.account.getFactoryData()
+                )
+                expect(userOperation.callData).toBe(
+                    await smartClient.account.encodeCallData({
+                        to: zeroAddress,
+                        data: "0x",
+                        value: 0n
+                    })
+                )
+                expect(userOperation.callGasLimit).toBeTruthy()
+                expect(userOperation.verificationGasLimit).toBeTruthy()
+                expect(userOperation.maxFeePerGas).toBeTruthy()
+                expect(userOperation.maxPriorityFeePerGas).toBeTruthy()
+                expect(userOperation.paymaster).toBeTruthy()
+                expect(userOperation.paymasterVerificationGasLimit).toBeTruthy()
+                expect(userOperation.signature).toBe(
+                    // @ts-ignore: since tests return all smart account client, some of them don't support V07.
+                    // The TS error is because in that case, getDummySignature would not accept the userOperation of type UserOperation<V07>
+                    await smartClient.account.getDummySignature(userOperation)
+                )
+                expect(userOperation.paymasterPostOpGasLimit).toBe(1n)
+                expect(userOperation.paymasterData).toBeTruthy()
+                expect(userOperation.paymasterAndData).toBe(undefined)
+                expect(userOperation.initCode).toBe(undefined)
+            }
+        )
+
+        testWithRpc.skipIf(!supportsEntryPointV07)(
+            "prepareUserOperationRequest_v07",
+            async ({ rpc }) => {
+                const { anvilRpc, altoRpc, paymasterRpc } = rpc
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    privateKey: generatePrivateKey(),
+                    altoRpc: altoRpc,
+                    anvilRpc: anvilRpc
+                })
+
+                const pimlicoBundlerClient = getPimlicoBundlerClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    altoRpc: altoRpc
+                })
+                const pimlicoPaymasterActions = getPimlicoPaymasterClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    paymasterRpc: paymasterRpc
+                })
+
+                const userOperation = await prepareUserOperationRequest(
+                    smartClient as Client<
+                        Transport,
+                        Chain,
+                        SmartAccount<EntryPoint>
+                    >,
+                    {
+                        userOperation: {
+                            callData: await smartClient.account.encodeCallData({
+                                to: zeroAddress,
+                                data: "0x",
+                                value: 0n
+                            })
+                        },
+                        middleware: async <T>(args: {
+                            userOperation: T
+                            entryPoint: EntryPoint
+                        }) => {
+                            const gasPrice = (
+                                await pimlicoBundlerClient.getUserOperationGasPrice()
+                            ).fast
+
+                            return {
+                                ...args.userOperation,
+                                maxFeePerGas: gasPrice.maxFeePerGas,
+                                maxPriorityFeePerGas:
+                                    gasPrice.maxPriorityFeePerGas,
+                                ...(await pimlicoPaymasterActions.sponsorUserOperation(
+                                    {
+                                        userOperation: {
+                                            ...args.userOperation,
+                                            maxFeePerGas: gasPrice.maxFeePerGas,
+                                            maxPriorityFeePerGas:
+                                                gasPrice.maxPriorityFeePerGas
+                                        }
+                                    }
+                                ))
+                            } as T
+                        }
+                    }
+                )
+
+                expect(userOperation).toBeTruthy()
+                expect(userOperation.sender).toBe(smartClient.account.address)
+                expect(userOperation.nonce).toBe(
+                    await smartClient.account.getNonce()
+                )
+                expect(userOperation.factory).toBe(
+                    await smartClient.account.getFactory()
+                )
+                expect(userOperation.factoryData).toBe(
+                    await smartClient.account.getFactoryData()
+                )
+                expect(userOperation.callData).toBe(
+                    await smartClient.account.encodeCallData({
+                        to: zeroAddress,
+                        data: "0x",
+                        value: 0n
+                    })
+                )
+                expect(userOperation.callGasLimit).toBeTruthy()
+                expect(userOperation.verificationGasLimit).toBeTruthy()
+                expect(userOperation.maxFeePerGas).toBeTruthy()
+                expect(userOperation.maxPriorityFeePerGas).toBeTruthy()
+                expect(userOperation.paymaster).toBeTruthy()
+                expect(userOperation.paymasterVerificationGasLimit).toBeTruthy()
+                expect(userOperation.signature).toBe(
+                    // @ts-ignore: since tests return all smart account client, some of them don't support V07.
+                    // The TS error is because in that case, getDummySignature would not accept the userOperation of type UserOperation<V07>
+                    await smartClient.account.getDummySignature(userOperation)
+                )
+                expect(userOperation.paymasterPostOpGasLimit).toBe(1n)
+                expect(userOperation.paymasterData).toBeTruthy()
+                expect(userOperation.paymasterAndData).toBe(undefined)
+                expect(userOperation.initCode).toBe(undefined)
+            }
+        )
     }
 )

package/actions/smartAccount.test.ts

@@ -0,0 +1,198 @@
+import type {
+    Abi,
+    Account,
+    Address,
+    Chain,
+    Client,
+    Hash,
+    Hex,
+    SignTypedDataParameters,
+    Transport,
+    TypedData
+} from "viem"
+import type { SignMessageParameters } from "viem"
+import { describe, expectTypeOf, test } from "vitest"
+import type { SmartAccount } from "../accounts"
+import type { BundlerRpcSchema } from "../types/bundler"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "../types/entrypoint"
+import {
+    type DeployContractParametersWithPaymaster,
+    type PrepareUserOperationRequestParameters,
+    type PrepareUserOperationRequestReturnType,
+    type SendTransactionWithPaymasterParameters,
+    type SendTransactionsWithPaymasterParameters,
+    type SendUserOperationParameters,
+    type WriteContractWithPaymasterParameters,
+    deployContract,
+    prepareUserOperationRequest,
+    sendTransaction,
+    sendTransactions,
+    sendUserOperation,
+    signMessage,
+    signTypedData,
+    writeContract
+} from "./smartAccount"
+
+describe("index", () => {
+    test("sendUserOperation", () => {
+        expectTypeOf(deployContract).toBeFunction()
+        expectTypeOf(deployContract)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(deployContract)
+            .parameter(1)
+            .toMatchTypeOf<DeployContractParametersWithPaymaster<EntryPoint>>()
+        expectTypeOf(deployContract).returns.toMatchTypeOf<Promise<Hash>>()
+    })
+    test("prepareUserOperationRequest", () => {
+        expectTypeOf(prepareUserOperationRequest).toBeFunction()
+        expectTypeOf(prepareUserOperationRequest)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(prepareUserOperationRequest)
+            .parameter(1)
+            .toMatchTypeOf<PrepareUserOperationRequestParameters<EntryPoint>>()
+        expectTypeOf(prepareUserOperationRequest).returns.toMatchTypeOf<
+            Promise<PrepareUserOperationRequestReturnType<EntryPoint>>
+        >()
+    })
+    test("sendTransaction", () => {
+        expectTypeOf(sendTransaction).toBeFunction()
+        expectTypeOf(sendTransaction)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(sendTransaction)
+            .parameter(1)
+            .toMatchTypeOf<SendTransactionWithPaymasterParameters<EntryPoint>>()
+        expectTypeOf(sendTransaction).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("sendTransactions", () => {
+        expectTypeOf(sendTransactions).toBeFunction()
+        expectTypeOf(sendTransactions)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(sendTransactions)
+            .parameter(1)
+            .toMatchTypeOf<
+                SendTransactionsWithPaymasterParameters<EntryPoint>
+            >()
+        expectTypeOf(sendTransactions).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("writeContract", () => {
+        expectTypeOf(writeContract).toBeFunction()
+        expectTypeOf(writeContract)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(
+            writeContract<
+                ENTRYPOINT_ADDRESS_V06_TYPE,
+                Chain,
+                SmartAccount<ENTRYPOINT_ADDRESS_V06_TYPE>,
+                Abi
+            >
+        )
+            .parameter(1)
+            .toMatchTypeOf<
+                WriteContractWithPaymasterParameters<
+                    ENTRYPOINT_ADDRESS_V06_TYPE,
+                    Chain,
+                    SmartAccount<ENTRYPOINT_ADDRESS_V06_TYPE>,
+                    Abi
+                >
+            >()
+        expectTypeOf(writeContract).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("sendUserOperation", () => {
+        expectTypeOf(sendUserOperation).toBeFunction()
+        expectTypeOf(sendUserOperation)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(sendUserOperation)
+            .parameter(1)
+            .toMatchTypeOf<SendUserOperationParameters<EntryPoint>>()
+        expectTypeOf(sendUserOperation).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("signMessage", () => {
+        expectTypeOf(signMessage).toBeFunction()
+        expectTypeOf(signMessage)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(signMessage)
+            .parameter(1)
+            .toMatchTypeOf<SignMessageParameters<SmartAccount<EntryPoint>>>()
+        expectTypeOf(signMessage).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("signTypedData", () => {
+        expectTypeOf(signTypedData).toBeFunction()
+        expectTypeOf(signTypedData)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(
+            signTypedData<EntryPoint, TypedData, string, undefined, undefined>
+        )
+            .parameter(1)
+            .toMatchTypeOf<
+                SignTypedDataParameters<TypedData, string, undefined>
+            >()
+        expectTypeOf(signTypedData).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+})

package/clients/createBundlerClient.test.ts

@@ -0,0 +1,26 @@
+import { http } from "viem"
+import { describe, expect } from "vitest"
+import { testWithRpc } from "../../permissionless-test/src/testWithRpc"
+import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07 } from "../utils"
+import { createBundlerClient } from "./createBundlerClient"
+
+describe("createBundlerClient", () => {
+    testWithRpc("createBundlerClient_V06", async ({ rpc }) => {
+        const bundlerClientV06 = createBundlerClient({
+            transport: http(rpc.altoRpc),
+            entryPoint: ENTRYPOINT_ADDRESS_V06
+        })
+
+        const entryPoints = await bundlerClientV06.supportedEntryPoints()
+        expect(entryPoints).contain(ENTRYPOINT_ADDRESS_V06)
+    })
+
+    testWithRpc("createBundlerClient_V07", async ({ rpc }) => {
+        const bundlerClientV07 = createBundlerClient({
+            transport: http(rpc.altoRpc),
+            entryPoint: ENTRYPOINT_ADDRESS_V07
+        })
+        const entryPoints = await bundlerClientV07.supportedEntryPoints()
+        expect(entryPoints).contain(ENTRYPOINT_ADDRESS_V07)
+    })
+})

package/clients/createSmartAccountClient.test.ts

@@ -0,0 +1,55 @@
+import { http } from "viem"
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts"
+import { foundry } from "viem/chains"
+import { describe, expect } from "vitest"
+import { testWithRpc } from "../../permissionless-test/src/testWithRpc"
+import { getPublicClient } from "../../permissionless-test/src/utils"
+import { signerToSimpleSmartAccount } from "../accounts"
+import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07 } from "../utils"
+import { createSmartAccountClient } from "./createSmartAccountClient"
+
+describe("createSmartAccountClient", () => {
+    testWithRpc("createSmartAccountClient_V06", async ({ rpc }) => {
+        const publicClient = getPublicClient(rpc.anvilRpc)
+
+        const simpleSmartAccount = await signerToSimpleSmartAccount(
+            publicClient,
+            {
+                entryPoint: ENTRYPOINT_ADDRESS_V06,
+                signer: privateKeyToAccount(generatePrivateKey())
+            }
+        )
+
+        const smartAccountClient = createSmartAccountClient({
+            chain: foundry,
+            account: simpleSmartAccount,
+            bundlerTransport: http(rpc.altoRpc)
+        })
+
+        expect(smartAccountClient.account.address).toBe(
+            simpleSmartAccount.address
+        )
+    })
+
+    testWithRpc("createSmartAccountClient_V07", async ({ rpc }) => {
+        const publicClient = getPublicClient(rpc.anvilRpc)
+
+        const simpleSmartAccount = await signerToSimpleSmartAccount(
+            publicClient,
+            {
+                entryPoint: ENTRYPOINT_ADDRESS_V07,
+                signer: privateKeyToAccount(generatePrivateKey())
+            }
+        )
+
+        const smartAccountClient = createSmartAccountClient({
+            chain: foundry,
+            account: simpleSmartAccount,
+            bundlerTransport: http(rpc.altoRpc)
+        })
+
+        expect(smartAccountClient.account.address).toBe(
+            simpleSmartAccount.address
+        )
+    })
+})