permissionless 0.2.45 → 0.2.47

package/actions/pimlico/getUserOperationGasPrice.test.ts

@@ -12,6 +12,56 @@ describe("getUserOperationGasPrice", () => {
 
         const gasPrice = await getUserOperationGasPrice(pimlicoBundlerClient)
 
+        expect(gasPrice).toBeTruthy()
+        expect(gasPrice.slow).toBeTruthy()
+        expect(gasPrice.standard).toBeTruthy()
+        expect(gasPrice.fast).toBeTruthy()
+        expect(typeof gasPrice.slow.maxFeePerGas).toBe("bigint")
+        expect(gasPrice.slow.maxFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.slow.maxPriorityFeePerGas).toBe("bigint")
+        expect(gasPrice.slow.maxPriorityFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.standard.maxFeePerGas).toBe("bigint")
+        expect(gasPrice.standard.maxFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.standard.maxPriorityFeePerGas).toBe("bigint")
+        expect(gasPrice.standard.maxPriorityFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.fast.maxFeePerGas).toBe("bigint")
+        expect(gasPrice.fast.maxFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.fast.maxPriorityFeePerGas).toBe("bigint")
+        expect(gasPrice.fast.maxPriorityFeePerGas).toBeGreaterThan(0n)
+    })
+    testWithRpc("getUserOperationGasPrice", async ({ rpc }) => {
+        const pimlicoBundlerClient = getPimlicoClient({
+            entryPointVersion: "0.7",
+            altoRpc: rpc.altoRpc
+        })
+
+        const gasPrice = await getUserOperationGasPrice(pimlicoBundlerClient)
+
+        expect(gasPrice).toBeTruthy()
+        expect(gasPrice.slow).toBeTruthy()
+        expect(gasPrice.standard).toBeTruthy()
+        expect(gasPrice.fast).toBeTruthy()
+        expect(typeof gasPrice.slow.maxFeePerGas).toBe("bigint")
+        expect(gasPrice.slow.maxFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.slow.maxPriorityFeePerGas).toBe("bigint")
+        expect(gasPrice.slow.maxPriorityFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.standard.maxFeePerGas).toBe("bigint")
+        expect(gasPrice.standard.maxFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.standard.maxPriorityFeePerGas).toBe("bigint")
+        expect(gasPrice.standard.maxPriorityFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.fast.maxFeePerGas).toBe("bigint")
+        expect(gasPrice.fast.maxFeePerGas).toBeGreaterThan(0n)
+        expect(typeof gasPrice.fast.maxPriorityFeePerGas).toBe("bigint")
+        expect(gasPrice.fast.maxPriorityFeePerGas).toBeGreaterThan(0n)
+    })
+    testWithRpc("getUserOperationGasPrice", async ({ rpc }) => {
+        const pimlicoBundlerClient = getPimlicoClient({
+            entryPointVersion: "0.8",
+            altoRpc: rpc.altoRpc
+        })
+
+        const gasPrice = await getUserOperationGasPrice(pimlicoBundlerClient)
+
         expect(gasPrice).toBeTruthy()
         expect(gasPrice.slow).toBeTruthy()
         expect(gasPrice.standard).toBeTruthy()

package/actions/pimlico/getUserOperationStatus.test.ts

@@ -119,6 +119,68 @@ describe("getUserOperationStatus", () => {
             hash: opHash
         })
 
+        expect(receipt?.receipt.transactionHash).toBe(
+            userOperationReceipt?.receipt.transactionHash
+        )
+        const userOperationStatus = await getUserOperationStatus(
+            bundlerClient,
+            {
+                hash: opHash
+            }
+        )
+        expect(userOperationStatus).not.toBeNull()
+        expect(userOperationStatus).not.toBeUndefined()
+        expect(userOperationStatus.status).toBe("included")
+        expect(userOperationStatus.transactionHash).toBe(
+            userOperationReceipt?.receipt.transactionHash
+        )
+    })
+    testWithRpc("getUserOperationStatus_V07", async ({ rpc }) => {
+        const { altoRpc } = rpc
+
+        const bundlerClient = getPimlicoClient({
+            entryPointVersion: "0.8",
+            altoRpc: altoRpc
+        })
+
+        const simpleAccountClient = getBundlerClient({
+            account: await getSimpleAccountClient({
+                ...rpc,
+                entryPoint: {
+                    version: "0.8"
+                }
+            }),
+            entryPoint: {
+                version: "0.8"
+            },
+            ...rpc
+        })
+
+        const opHash = await simpleAccountClient.sendUserOperation({
+            calls: [
+                {
+                    to: zeroAddress,
+                    data: "0x",
+                    value: 0n
+                }
+            ]
+        })
+
+        expect(isHash(opHash)).toBe(true)
+
+        const userOperationReceipt =
+            await bundlerClient.waitForUserOperationReceipt({
+                hash: opHash,
+                timeout: 100000
+            })
+        expect(userOperationReceipt).not.toBeNull()
+        expect(userOperationReceipt?.userOpHash).toBe(opHash)
+        expect(userOperationReceipt?.receipt.transactionHash).toBeTruthy()
+
+        const receipt = await bundlerClient.getUserOperationReceipt({
+            hash: opHash
+        })
+
         expect(receipt?.receipt.transactionHash).toBe(
             userOperationReceipt?.receipt.transactionHash
         )

package/actions/pimlico/sponsorUserOperation.test.ts

@@ -110,4 +110,55 @@ describe("sponsorUserOperation", () => {
             userOperationReceipt?.receipt.transactionHash
         )
     })
+
+    testWithRpc("sponsorUserOperation_V08", async ({ rpc }) => {
+        const { altoRpc } = rpc
+
+        const bundlerClient = getPimlicoClient({
+            entryPointVersion: "0.8",
+            altoRpc: altoRpc
+        })
+
+        const simpleAccountClient = getBundlerClient({
+            account: await getSimpleAccountClient({
+                ...rpc,
+                entryPoint: {
+                    version: "0.8"
+                }
+            }),
+            entryPoint: {
+                version: "0.8"
+            },
+            ...rpc
+        })
+
+        const opHash = await simpleAccountClient.sendUserOperation({
+            calls: [
+                {
+                    to: zeroAddress,
+                    data: "0x",
+                    value: 0n
+                }
+            ]
+        })
+
+        expect(isHash(opHash)).toBe(true)
+
+        const userOperationReceipt =
+            await bundlerClient.waitForUserOperationReceipt({
+                hash: opHash,
+                timeout: 100000
+            })
+        expect(userOperationReceipt).not.toBeNull()
+        expect(userOperationReceipt?.userOpHash).toBe(opHash)
+        expect(userOperationReceipt?.receipt.transactionHash).toBeTruthy()
+
+        const receipt = await bundlerClient.getUserOperationReceipt({
+            hash: opHash
+        })
+
+        expect(receipt?.receipt.transactionHash).toBe(
+            userOperationReceipt?.receipt.transactionHash
+        )
+    })
 })

package/actions/pimlico/sponsorUserOperation.ts

@@ -8,7 +8,7 @@ import type {
     PartialBy,
     Transport
 } from "viem"
-import type { UserOperation } from "viem/account-abstraction"
+import type { EntryPointVersion, UserOperation } from "viem/account-abstraction"
 import type { PimlicoRpcSchema } from "../../types/pimlico.js"
 import { deepHexlify } from "../../utils/deepHexlify.js"
 
@@ -20,7 +20,7 @@ type PaymasterContext = {
 }
 
 export type PimlicoSponsorUserOperationParameters<
-    entryPointVersion extends "0.6" | "0.7"
+    entryPointVersion extends EntryPointVersion
 > = {
     userOperation: OneOf<
         | (entryPointVersion extends "0.6"
@@ -51,7 +51,7 @@ export type PimlicoSponsorUserOperationParameters<
 }
 
 export type SponsorUserOperationReturnType<
-    entryPointVersion extends "0.6" | "0.7" = "0.7"
+    entryPointVersion extends EntryPointVersion = "0.7"
 > = OneOf<
     | (entryPointVersion extends "0.6"
           ? {
@@ -75,7 +75,7 @@ export type SponsorUserOperationReturnType<
 >
 
 export const sponsorUserOperation = async <
-    entryPointVersion extends "0.6" | "0.7" = "0.6" | "0.7"
+    entryPointVersion extends EntryPointVersion = EntryPointVersion
 >(
     client: Client<
         Transport,

package/actions/pimlico/validateSponsorshipPolicies.test.ts

@@ -1,4 +1,8 @@
-import { entryPoint06Address } from "viem/account-abstraction"
+import {
+    entryPoint06Address,
+    entryPoint07Address,
+    entryPoint08Address
+} from "viem/account-abstraction"
 import { describe, expect } from "vitest"
 import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
 import {
@@ -9,7 +13,7 @@ import {
 import { validateSponsorshipPolicies } from "./validateSponsorshipPolicies"
 
 describe("validateSponsorshipPolicies", () => {
-    testWithRpc("Validating sponsorship policies", async ({ rpc }) => {
+    testWithRpc("Validating sponsorship policies V06", async ({ rpc }) => {
         const { paymasterRpc } = rpc
 
         const simpleAccountClient = getBundlerClient({
@@ -54,4 +58,96 @@ describe("validateSponsorshipPolicies", () => {
         expect(Array.isArray(policies)).toBe(true)
         expect(policies.length).toBe(1)
     })
+
+    testWithRpc("Validating sponsorship policies V07", async ({ rpc }) => {
+        const { paymasterRpc } = rpc
+
+        const simpleAccountClient = getBundlerClient({
+            account: await getSimpleAccountClient({
+                ...rpc,
+                entryPoint: {
+                    version: "0.7"
+                }
+            }),
+            entryPoint: {
+                version: "0.7"
+            },
+            ...rpc
+        })
+
+        const userOperation = await simpleAccountClient.prepareUserOperation({
+            calls: [
+                {
+                    to: "0x5af0d9827e0c53e4799bb226655a1de152a425a5",
+                    data: "0x",
+                    value: 0n
+                }
+            ]
+        })
+
+        const pimlicoPaymasterClient = getPimlicoClient({
+            entryPointVersion: "0.7",
+            altoRpc: paymasterRpc
+        })
+
+        const policies = await validateSponsorshipPolicies(
+            pimlicoPaymasterClient,
+            {
+                entryPointAddress: entryPoint07Address,
+                userOperation: userOperation,
+                sponsorshipPolicyIds: ["sp_crazy_kangaroo"]
+            }
+        )
+
+        expect(policies).toBeTruthy()
+        expect(policies.length).toBeGreaterThan(0)
+        expect(Array.isArray(policies)).toBe(true)
+        expect(policies.length).toBe(1)
+    })
+
+    testWithRpc("Validating sponsorship policies V08", async ({ rpc }) => {
+        const { paymasterRpc } = rpc
+
+        const simpleAccountClient = getBundlerClient({
+            account: await getSimpleAccountClient({
+                ...rpc,
+                entryPoint: {
+                    version: "0.8"
+                }
+            }),
+            entryPoint: {
+                version: "0.8"
+            },
+            ...rpc
+        })
+
+        const userOperation = await simpleAccountClient.prepareUserOperation({
+            calls: [
+                {
+                    to: "0x5af0d9827e0c53e4799bb226655a1de152a425a5",
+                    data: "0x",
+                    value: 0n
+                }
+            ]
+        })
+
+        const pimlicoPaymasterClient = getPimlicoClient({
+            entryPointVersion: "0.8",
+            altoRpc: paymasterRpc
+        })
+
+        const policies = await validateSponsorshipPolicies(
+            pimlicoPaymasterClient,
+            {
+                entryPointAddress: entryPoint08Address,
+                userOperation: userOperation,
+                sponsorshipPolicyIds: ["sp_crazy_kangaroo"]
+            }
+        )
+
+        expect(policies).toBeTruthy()
+        expect(policies.length).toBeGreaterThan(0)
+        expect(Array.isArray(policies)).toBe(true)
+        expect(policies.length).toBe(1)
+    })
 })

package/actions/public/getAccountNonce.test.ts

@@ -65,6 +65,33 @@ describe("getAccountNonce", () => {
             address: simpleAccountClient.account.address
         })
 
+        expect(nonce).toBe(0n)
+    })
+    testWithRpc("getAccountNonce_V08", async ({ rpc }) => {
+        const { anvilRpc } = rpc
+
+        const client = createPublicClient({
+            transport: http(anvilRpc)
+        })
+
+        const simpleAccountClient = getBundlerClient({
+            account: await getSimpleAccountClient({
+                ...rpc,
+                entryPoint: {
+                    version: "0.8"
+                }
+            }),
+            entryPoint: {
+                version: "0.8"
+            },
+            ...rpc
+        })
+
+        const nonce = await getAccountNonce(client, {
+            entryPointAddress: entryPoint07Address,
+            address: simpleAccountClient.account.address
+        })
+
         expect(nonce).toBe(0n)
     })
 })

package/actions/public/getSenderAddress.test.ts

@@ -1,7 +1,8 @@
 import { http, concatHex, createPublicClient } from "viem"
 import {
     entryPoint06Address,
-    entryPoint07Address
+    entryPoint07Address,
+    entryPoint08Address
 } from "viem/account-abstraction"
 import { describe, expect } from "vitest"
 import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
@@ -113,6 +114,41 @@ describe("getSenderAddress", () => {
             factoryData
         })
 
+        expect(address).toBe(simpleAccountClient.account.address)
+    })
+    testWithRpc("getSenderAddress_V08", async ({ rpc }) => {
+        const { anvilRpc, altoRpc } = rpc
+
+        const client = createPublicClient({
+            transport: http(anvilRpc)
+        })
+
+        const simpleAccountClient = getBundlerClient({
+            account: await getSimpleAccountClient({
+                ...rpc,
+                entryPoint: {
+                    version: "0.8"
+                }
+            }),
+            entryPoint: {
+                version: "0.8"
+            },
+            ...rpc
+        })
+
+        const { factory, factoryData } =
+            await simpleAccountClient.account.getFactoryArgs()
+
+        if (!factory || !factoryData) {
+            throw new Error("Factory or factoryData not found")
+        }
+
+        const address = await getSenderAddress(client, {
+            entryPointAddress: entryPoint08Address,
+            factory,
+            factoryData
+        })
+
         expect(address).toBe(simpleAccountClient.account.address)
     })
 })

package/actions/smartAccount/sendTransaction.test.ts

@@ -13,7 +13,8 @@ describe.each(getCoreSmartAccounts())(
     ({
         getSmartAccountClient,
         supportsEntryPointV06,
-        supportsEntryPointV07
+        supportsEntryPointV07,
+        supportsEntryPointV08
     }) => {
         testWithRpc.skipIf(!supportsEntryPointV06)(
             "sendTransaction_v06",
@@ -117,6 +118,58 @@ describe.each(getCoreSmartAccounts())(
             }
         )
 
+        testWithRpc.skipIf(!supportsEntryPointV08)(
+            "sendTransaction_v08",
+            async ({ rpc }) => {
+                const { anvilRpc } = rpc
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: {
+                        version: "0.8"
+                    },
+                    privateKey:
+                        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // anvil private key
+                    ...rpc
+                })
+
+                const transactionHash = await sendTransaction(smartClient, {
+                    to: zeroAddress,
+                    data: "0x",
+                    value: 0n
+                })
+
+                expect(transactionHash).toBeTruthy()
+
+                const publicClient = getPublicClient(anvilRpc)
+
+                const receipt = await publicClient.getTransactionReceipt({
+                    hash: transactionHash
+                })
+
+                expect(receipt).toBeTruthy()
+                expect(receipt.transactionHash).toBe(transactionHash)
+                expect(receipt.status).toBe("success")
+
+                const transactionHash2 = await sendTransaction(smartClient, {
+                    to: zeroAddress,
+                    data: "0x",
+                    value: 0n
+                })
+
+                // -- second transaction after deployment
+
+                expect(transactionHash2).toBeTruthy()
+
+                const receipt2 = await publicClient.getTransactionReceipt({
+                    hash: transactionHash2
+                })
+
+                expect(receipt2).toBeTruthy()
+                expect(receipt2.transactionHash).toBe(transactionHash2)
+                expect(receipt2.status).toBe("success")
+            }
+        )
+
         testWithRpc.skipIf(!supportsEntryPointV06)(
             "sendTransaction_v06 post deployment",
             async ({ rpc }) => {
@@ -191,6 +244,8 @@ describe.each(getCoreSmartAccounts())(
                         entryPoint: {
                             version: "0.7"
                         },
+                        privateKey:
+                            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // anvil private key
                         ...rpc
                     })
 
@@ -243,5 +298,70 @@ describe.each(getCoreSmartAccounts())(
                 expect(receipt2.status).toBe("success")
             }
         )
+
+        testWithRpc.skipIf(!supportsEntryPointV08)(
+            "sendTransaction_v08 post deployment",
+            async ({ rpc }) => {
+                const { anvilRpc } = rpc
+
+                await (async () => {
+                    const smartClient = await getSmartAccountClient({
+                        entryPoint: {
+                            version: "0.8"
+                        },
+                        privateKey:
+                            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // anvil private key
+                        ...rpc
+                    })
+
+                    const transactionHash = await sendTransaction(smartClient, {
+                        to: zeroAddress,
+                        data: "0x",
+                        value: 0n
+                    })
+
+                    expect(transactionHash).toBeTruthy()
+
+                    const publicClient = getPublicClient(anvilRpc)
+
+                    const receipt = await publicClient.getTransactionReceipt({
+                        hash: transactionHash
+                    })
+
+                    expect(receipt).toBeTruthy()
+                    expect(receipt.transactionHash).toBe(transactionHash)
+                    expect(receipt.status).toBe("success")
+                })()
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: {
+                        version: "0.8"
+                    },
+                    privateKey:
+                        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // anvil private key
+                    ...rpc
+                })
+
+                const publicClient = getPublicClient(anvilRpc)
+
+                const transactionHash2 = await sendTransaction(smartClient, {
+                    to: zeroAddress,
+                    data: "0x",
+                    value: 0n
+                })
+
+                // -- second transaction after deployment
+
+                expect(transactionHash2).toBeTruthy()
+
+                const receipt2 = await publicClient.getTransactionReceipt({
+                    hash: transactionHash2
+                })
+
+                expect(receipt2).toBeTruthy()
+                expect(receipt2.transactionHash).toBe(transactionHash2)
+                expect(receipt2.status).toBe("success")
+            }
+        )
     }
 )

package/actions/smartAccount/signMessage.test.ts

@@ -14,6 +14,7 @@ describe.each(getCoreSmartAccounts())(
         isEip1271Compliant,
         supportsEntryPointV06,
         supportsEntryPointV07,
+        supportsEntryPointV08,
         name
     }) => {
         testWithRpc.skipIf(isEip1271Compliant || !supportsEntryPointV06)(
@@ -131,5 +132,63 @@ describe.each(getCoreSmartAccounts())(
                 expect(isVerified).toBeTruthy()
             }
         )
+
+        testWithRpc.skipIf(isEip1271Compliant || !supportsEntryPointV08)(
+            "not isEip1271Compliant_v08",
+            async ({ rpc }) => {
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: {
+                        version: "0.8"
+                    },
+                    ...rpc
+                })
+
+                await expect(async () =>
+                    signMessage(smartClient, {
+                        message: "slowly and steadily burning the private keys"
+                    })
+                ).rejects.toThrow()
+            }
+        )
+
+        testWithRpc.skipIf(!isEip1271Compliant || !supportsEntryPointV08)(
+            "isEip1271Compliant_v08",
+            async ({ rpc }) => {
+                const { anvilRpc } = rpc
+
+                const smartClient = await getSmartAccountClient({
+                    entryPoint: {
+                        version: "0.8"
+                    },
+                    ...rpc
+                })
+
+                if (name === "LightAccount 2.0.0") {
+                    // LightAccount 2.0.0 doesn't support EIP-1271
+                    return
+                }
+
+                if (name.includes("Safe 7579")) {
+                    // Due to 7579 launchpad, we can't verify the signature before deploying the account.
+                    await smartClient.sendTransaction({
+                        calls: [{ to: zeroAddress, value: 0n }]
+                    })
+                }
+
+                const signature = await signMessage(smartClient, {
+                    message: "slowly and steadily burning the private keys"
+                })
+
+                const publicClient = getPublicClient(anvilRpc)
+
+                const isVerified = await publicClient.verifyMessage({
+                    address: smartClient.account.address,
+                    message: "slowly and steadily burning the private keys",
+                    signature
+                })
+
+                expect(isVerified).toBeTruthy()
+            }
+        )
     }
 )