permissionless 0.3.6 → 0.4.0

package/actions/pimlico/sponsorUserOperation.test.ts

@@ -1,236 +0,0 @@
-import { isHash, zeroAddress } from "viem"
-import {
-    type UserOperation,
-    entryPoint06Address,
-    entryPoint07Address,
-    entryPoint08Address
-} from "viem/account-abstraction"
-import { describe, expect } from "vitest"
-import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import {
-    getBundlerClient,
-    getPimlicoClient,
-    getSimpleAccountClient
-} from "../../../permissionless-test/src/utils"
-import { sponsorUserOperation } from "./sponsorUserOperation"
-
-describe("sponsorUserOperation", () => {
-    testWithRpc("sponsorUserOperation_V06", async ({ rpc }) => {
-        const { altoRpc, paymasterRpc } = rpc
-
-        const bundlerClient = getPimlicoClient({
-            entryPointVersion: "0.6",
-            altoRpc: altoRpc
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.6"
-                }
-            }),
-            entryPoint: {
-                version: "0.6"
-            },
-            ...rpc
-        })
-
-        const preparedUserOp = await simpleAccountClient.prepareUserOperation({
-            calls: [
-                {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n
-                }
-            ]
-        })
-
-        const paymasterClient = getPimlicoClient({
-            entryPointVersion: "0.6",
-            altoRpc: paymasterRpc
-        })
-
-        const sponsorResult = await sponsorUserOperation(paymasterClient, {
-            userOperation: preparedUserOp,
-            entryPoint: {
-                address: entryPoint06Address,
-                version: "0.6"
-            }
-        })
-
-        const finalUserOp = {
-            ...preparedUserOp,
-            ...sponsorResult
-        }
-        const account = simpleAccountClient.account
-        finalUserOp.signature = await account.signUserOperation(finalUserOp)
-
-        const opHash = await simpleAccountClient.sendUserOperation(finalUserOp)
-
-        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
-        )
-    })
-
-    testWithRpc("sponsorUserOperation_V07", async ({ rpc }) => {
-        const { altoRpc, paymasterRpc } = rpc
-
-        const bundlerClient = getPimlicoClient({
-            entryPointVersion: "0.7",
-            altoRpc: altoRpc
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.7"
-                }
-            }),
-            entryPoint: {
-                version: "0.7"
-            },
-            ...rpc
-        })
-
-        const preparedUserOp = await simpleAccountClient.prepareUserOperation({
-            calls: [
-                {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n
-                }
-            ]
-        })
-
-        const paymasterClient = getPimlicoClient({
-            entryPointVersion: "0.7",
-            altoRpc: paymasterRpc
-        })
-
-        const sponsorResult = await sponsorUserOperation(paymasterClient, {
-            userOperation: preparedUserOp,
-            entryPoint: {
-                address: entryPoint07Address,
-                version: "0.7"
-            }
-        })
-
-        const finalUserOp = {
-            ...preparedUserOp,
-            ...sponsorResult
-        }
-        const account = simpleAccountClient.account
-        finalUserOp.signature = await account.signUserOperation(finalUserOp)
-
-        const opHash = await simpleAccountClient.sendUserOperation(finalUserOp)
-
-        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
-        )
-    })
-
-    testWithRpc("sponsorUserOperation_V08", async ({ rpc }) => {
-        const { altoRpc, paymasterRpc } = 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 preparedUserOp = (await simpleAccountClient.prepareUserOperation({
-            calls: [
-                {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n
-                }
-            ]
-        })) as UserOperation<"0.8">
-
-        const paymasterClient = getPimlicoClient({
-            entryPointVersion: "0.8",
-            altoRpc: paymasterRpc
-        })
-
-        const sponsorResult = await sponsorUserOperation(paymasterClient, {
-            userOperation: preparedUserOp,
-            entryPoint: {
-                address: entryPoint08Address,
-                version: "0.8"
-            }
-        })
-
-        const finalUserOp = {
-            ...preparedUserOp,
-            ...sponsorResult
-        }
-        const account = simpleAccountClient.account
-        finalUserOp.signature = await account.signUserOperation(finalUserOp)
-
-        const opHash = await simpleAccountClient.sendUserOperation(finalUserOp)
-
-        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/validateSponsorshipPolicies.test.ts

@@ -1,153 +0,0 @@
-import {
-    entryPoint06Address,
-    entryPoint07Address,
-    entryPoint08Address
-} from "viem/account-abstraction"
-import { describe, expect } from "vitest"
-import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import {
-    getBundlerClient,
-    getPimlicoClient,
-    getSimpleAccountClient
-} from "../../../permissionless-test/src/utils"
-import { validateSponsorshipPolicies } from "./validateSponsorshipPolicies"
-
-describe("validateSponsorshipPolicies", () => {
-    testWithRpc("Validating sponsorship policies V06", async ({ rpc }) => {
-        const { paymasterRpc } = rpc
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.6"
-                }
-            }),
-            entryPoint: {
-                version: "0.6"
-            },
-            ...rpc
-        })
-
-        const userOperation = await simpleAccountClient.prepareUserOperation({
-            calls: [
-                {
-                    to: "0x5af0d9827e0c53e4799bb226655a1de152a425a5",
-                    data: "0x",
-                    value: 0n
-                }
-            ]
-        })
-
-        const pimlicoPaymasterClient = getPimlicoClient({
-            entryPointVersion: "0.6",
-            altoRpc: paymasterRpc
-        })
-
-        const policies = await validateSponsorshipPolicies(
-            pimlicoPaymasterClient,
-            {
-                entryPointAddress: entryPoint06Address,
-                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 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

@@ -1,96 +0,0 @@
-import { http, createPublicClient } from "viem"
-import {
-    entryPoint06Address,
-    entryPoint07Address
-} from "viem/account-abstraction"
-import { describe, expect } from "vitest"
-import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import {
-    getBundlerClient,
-    getSimpleAccountClient
-} from "../../../permissionless-test/src/utils"
-import { getAccountNonce } from "./getAccountNonce"
-
-describe("getAccountNonce", () => {
-    testWithRpc("getAccountNonce_V06", async ({ rpc }) => {
-        const { anvilRpc } = rpc
-
-        const client = createPublicClient({
-            transport: http(anvilRpc)
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.6"
-                }
-            }),
-            entryPoint: {
-                version: "0.6"
-            },
-            ...rpc
-        })
-
-        const nonce = await getAccountNonce(client, {
-            entryPointAddress: entryPoint06Address,
-            address: simpleAccountClient.account.address
-        })
-
-        expect(nonce).toBe(0n)
-    })
-    testWithRpc("getAccountNonce_V07", async ({ rpc }) => {
-        const { anvilRpc } = rpc
-
-        const client = createPublicClient({
-            transport: http(anvilRpc)
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.7"
-                }
-            }),
-            entryPoint: {
-                version: "0.7"
-            },
-            ...rpc
-        })
-
-        const nonce = await getAccountNonce(client, {
-            entryPointAddress: entryPoint07Address,
-            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,154 +0,0 @@
-import { http, concatHex, createPublicClient } from "viem"
-import {
-    entryPoint06Address,
-    entryPoint07Address,
-    entryPoint08Address
-} from "viem/account-abstraction"
-import { describe, expect } from "vitest"
-import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import {
-    getBundlerClient,
-    getSimpleAccountClient
-} from "../../../permissionless-test/src/utils"
-import { getSenderAddress } from "./getSenderAddress"
-
-describe("getSenderAddress", () => {
-    testWithRpc("getSenderAddress_V06", async ({ rpc }) => {
-        const { anvilRpc } = rpc
-
-        const client = createPublicClient({
-            transport: http(anvilRpc)
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.6"
-                }
-            }),
-            entryPoint: {
-                version: "0.6"
-            },
-            ...rpc
-        })
-
-        const { factory, factoryData } =
-            await simpleAccountClient.account.getFactoryArgs()
-
-        if (!factory || !factoryData) {
-            throw new Error("Init code not found")
-        }
-
-        const address = await getSenderAddress(client, {
-            entryPointAddress: entryPoint06Address,
-            initCode: concatHex([factory, factoryData])
-        })
-
-        expect(address).toBe(simpleAccountClient.account.address)
-    })
-    testWithRpc("getSenderAddress_V06_error", async ({ rpc }) => {
-        const { anvilRpc } = rpc
-
-        const client = createPublicClient({
-            transport: http(anvilRpc)
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.6"
-                }
-            }),
-            entryPoint: {
-                version: "0.6"
-            },
-            ...rpc
-        })
-
-        const { factory, factoryData } =
-            await simpleAccountClient.account.getFactoryArgs()
-
-        if (!factory || !factoryData) {
-            throw new Error("Init code not found")
-        }
-
-        await expect(async () =>
-            getSenderAddress(client, {
-                entryPointAddress: "0x0000000000000000000000000000000000000000",
-                initCode: concatHex([factory, factoryData])
-            })
-        ).rejects.toThrowError()
-    })
-    testWithRpc("getSenderAddress_V07", async ({ rpc }) => {
-        const { anvilRpc } = rpc
-
-        const client = createPublicClient({
-            transport: http(anvilRpc)
-        })
-
-        const simpleAccountClient = getBundlerClient({
-            account: await getSimpleAccountClient({
-                ...rpc,
-                entryPoint: {
-                    version: "0.7"
-                }
-            }),
-            entryPoint: {
-                version: "0.7"
-            },
-            ...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: entryPoint07Address,
-            factory,
-            factoryData
-        })
-
-        expect(address).toBe(simpleAccountClient.account.address)
-    })
-    testWithRpc("getSenderAddress_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 { 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)
-    })
-})