permissionless 0.3.6 → 0.4.0

package/experimental/pimlico/utils/prepareUserOperationForErc20Paymaster.test.ts

@@ -1,574 +0,0 @@
-import { http, parseEther, zeroAddress } from "viem"
-import {
-    entryPoint06Address,
-    entryPoint07Address,
-    entryPoint08Address
-} from "viem/account-abstraction"
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts"
-import { foundry } from "viem/chains"
-import { describe, expect } from "vitest"
-import {
-    erc20Address,
-    sudoMintTokens,
-    tokenBalanceOf
-} from "../../../../mock-paymaster/helpers/erc20-utils"
-import {
-    createAutoBundleTransport,
-    testWithRpc
-} from "../../../../permissionless-test/src/testWithRpc"
-import {
-    getCoreSmartAccounts,
-    getPublicClient
-} from "../../../../permissionless-test/src/utils"
-import { createSmartAccountClient } from "../../../clients/createSmartAccountClient"
-import { createPimlicoClient } from "../../../clients/pimlico"
-import { prepareUserOperationForErc20Paymaster } from "./prepareUserOperationForErc20Paymaster"
-
-describe.each(getCoreSmartAccounts())(
-    "prepareUserOperationForErc20Paymaster $name",
-    ({
-        getSmartAccountClient,
-        supportsEntryPointV06,
-        supportsEntryPointV07,
-        supportsEntryPointV08,
-        isEip7702Compliant,
-        name
-    }) => {
-        const privateKey = generatePrivateKey()
-        testWithRpc.skipIf(!supportsEntryPointV06 || name === "Kernel 0.2.1")(
-            "prepareUserOperationForErc20Paymaster_v06",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const account = (
-                    await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.6"
-                        },
-                        privateKey,
-                        ...rpc
-                    })
-                ).account
-
-                const pimlicoClient = createPimlicoClient({
-                    transport: http(rpc.paymasterRpc),
-                    entryPoint: {
-                        address: entryPoint06Address,
-                        version: "0.6"
-                    }
-                })
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const smartAccountClient = createSmartAccountClient({
-                    // @ts-ignore
-                    client: getPublicClient(anvilRpc),
-                    account,
-                    paymaster: pimlicoClient,
-                    chain: foundry,
-                    userOperation: {
-                        prepareUserOperation:
-                            prepareUserOperationForErc20Paymaster(pimlicoClient)
-                    },
-                    bundlerTransport: createAutoBundleTransport(
-                        rpc.altoRpc,
-                        rpc.anvilRpc
-                    )
-                })
-
-                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                const PRE_MINT_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-
-                await sudoMintTokens({
-                    amount: parseEther("100"),
-                    to: smartAccountClient.account.address,
-                    anvilRpc
-                })
-
-                const INITIAL_TOKEN_BALANCE =
-                    PRE_MINT_TOKEN_BALANCE + parseEther("100")
-
-                const opHash = await smartAccountClient.sendUserOperation({
-                    calls: [
-                        {
-                            to: zeroAddress,
-                            data: "0x",
-                            value: 0n
-                        }
-                    ],
-                    paymasterContext: {
-                        token: erc20Address
-                    }
-                })
-
-                const receipt =
-                    await smartAccountClient.waitForUserOperationReceipt({
-                        hash: opHash
-                    })
-
-                expect(receipt).toBeTruthy()
-                expect(receipt).toBeTruthy()
-
-                expect(receipt.success).toBeTruthy()
-                const FINAL_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-                const FINAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                expect(FINAL_TOKEN_BALANCE).toBeLessThan(INITIAL_TOKEN_BALANCE) // Token balance should be deducted
-                expect(FINAL_ETH_BALANCE).toEqual(INTIAL_ETH_BALANCE) // There should be no ETH balance change
-            }
-        )
-
-        testWithRpc.skipIf(!supportsEntryPointV07)(
-            "prepareUserOperationForErc20Paymaster_v07",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const account = (
-                    await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.7"
-                        },
-                        privateKey,
-                        ...rpc
-                    })
-                ).account
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const pimlicoClient = createPimlicoClient({
-                    transport: http(rpc.paymasterRpc),
-                    entryPoint: {
-                        address: entryPoint07Address,
-                        version: "0.7"
-                    }
-                })
-
-                const smartAccountClient = createSmartAccountClient({
-                    // @ts-ignore
-                    client: getPublicClient(anvilRpc),
-                    account,
-                    paymaster: pimlicoClient,
-                    chain: foundry,
-                    userOperation: {
-                        prepareUserOperation:
-                            prepareUserOperationForErc20Paymaster(pimlicoClient)
-                    },
-                    bundlerTransport: createAutoBundleTransport(
-                        rpc.altoRpc,
-                        rpc.anvilRpc
-                    )
-                })
-
-                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                const PRE_MINT_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-
-                await sudoMintTokens({
-                    amount: parseEther("100"),
-                    to: smartAccountClient.account.address,
-                    anvilRpc
-                })
-
-                const INITIAL_TOKEN_BALANCE =
-                    PRE_MINT_TOKEN_BALANCE + parseEther("100")
-
-                const authorization = isEip7702Compliant
-                    ? await privateKeyAccount.signAuthorization({
-                          address: (smartAccountClient.account as any)
-                              .implementation,
-                          chainId: smartAccountClient.chain.id,
-                          nonce: await publicClient.getTransactionCount({
-                              address: smartAccountClient.account.address
-                          })
-                      })
-                    : undefined
-
-                const opHash = await smartAccountClient.sendUserOperation({
-                    calls: [
-                        {
-                            to: zeroAddress,
-                            data: "0x",
-                            value: 0n
-                        }
-                    ],
-                    paymasterContext: {
-                        token: erc20Address
-                    },
-                    authorization
-                })
-
-                const receipt =
-                    await smartAccountClient.waitForUserOperationReceipt({
-                        hash: opHash
-                    })
-
-                expect(receipt).toBeTruthy()
-                expect(receipt).toBeTruthy()
-                expect(receipt.success).toBeTruthy()
-
-                const FINAL_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-                const FINAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                expect(FINAL_TOKEN_BALANCE).toBeLessThan(INITIAL_TOKEN_BALANCE) // Token balance should be deducted
-                expect(FINAL_ETH_BALANCE).toEqual(INTIAL_ETH_BALANCE) // There should be no ETH balance change
-            }
-        )
-
-        testWithRpc.skipIf(!supportsEntryPointV08)(
-            "prepareUserOperationForErc20Paymaster_v08",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const account = (
-                    await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.8"
-                        },
-                        privateKey,
-                        ...rpc
-                    })
-                ).account
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const pimlicoClient = createPimlicoClient({
-                    transport: http(rpc.paymasterRpc),
-                    entryPoint: {
-                        address: entryPoint08Address,
-                        version: "0.8"
-                    }
-                })
-
-                const smartAccountClient = createSmartAccountClient({
-                    // @ts-ignore
-                    client: getPublicClient(anvilRpc),
-                    account,
-                    paymaster: pimlicoClient,
-                    chain: foundry,
-                    userOperation: {
-                        prepareUserOperation:
-                            prepareUserOperationForErc20Paymaster(pimlicoClient)
-                    },
-                    bundlerTransport: createAutoBundleTransport(
-                        rpc.altoRpc,
-                        rpc.anvilRpc
-                    )
-                })
-
-                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                const PRE_MINT_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-
-                await sudoMintTokens({
-                    amount: parseEther("100"),
-                    to: smartAccountClient.account.address,
-                    anvilRpc
-                })
-
-                const INITIAL_TOKEN_BALANCE =
-                    PRE_MINT_TOKEN_BALANCE + parseEther("100")
-
-                const authorization = isEip7702Compliant
-                    ? await privateKeyAccount.signAuthorization({
-                          address: (smartAccountClient.account as any)
-                              .implementation,
-                          chainId: smartAccountClient.chain.id,
-                          nonce: await publicClient.getTransactionCount({
-                              address: smartAccountClient.account.address
-                          })
-                      })
-                    : undefined
-
-                const opHash = await smartAccountClient.sendUserOperation({
-                    calls: [
-                        {
-                            to: zeroAddress,
-                            data: "0x",
-                            value: 0n
-                        }
-                    ],
-                    paymasterContext: {
-                        token: erc20Address
-                    },
-                    authorization
-                })
-
-                const receipt =
-                    await smartAccountClient.waitForUserOperationReceipt({
-                        hash: opHash
-                    })
-
-                expect(receipt).toBeTruthy()
-                expect(receipt).toBeTruthy()
-                expect(receipt.success).toBeTruthy()
-
-                const FINAL_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-                const FINAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                expect(FINAL_TOKEN_BALANCE).toBeLessThan(INITIAL_TOKEN_BALANCE) // Token balance should be deducted
-                expect(FINAL_ETH_BALANCE).toEqual(INTIAL_ETH_BALANCE) // There should be no ETH balance change
-            }
-        )
-
-        testWithRpc.skipIf(!supportsEntryPointV07)(
-            "prepareUserOperationForErc20Paymaster_v07 (balanceOverride enabled)",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const account = (
-                    await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.7"
-                        },
-                        privateKey,
-                        ...rpc
-                    })
-                ).account
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const pimlicoClient = createPimlicoClient({
-                    transport: http(rpc.paymasterRpc),
-                    entryPoint: {
-                        address: entryPoint07Address,
-                        version: "0.7"
-                    }
-                })
-
-                const smartAccountClient = createSmartAccountClient({
-                    // @ts-ignore
-                    client: getPublicClient(anvilRpc),
-                    account,
-                    paymaster: pimlicoClient,
-                    chain: foundry,
-                    userOperation: {
-                        prepareUserOperation:
-                            prepareUserOperationForErc20Paymaster(
-                                pimlicoClient,
-                                {
-                                    balanceOverride: true
-                                }
-                            )
-                    },
-                    bundlerTransport: createAutoBundleTransport(
-                        rpc.altoRpc,
-                        rpc.anvilRpc
-                    )
-                })
-
-                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                const PRE_MINT_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-
-                await sudoMintTokens({
-                    amount: parseEther("100"),
-                    to: smartAccountClient.account.address,
-                    anvilRpc
-                })
-
-                const INITIAL_TOKEN_BALANCE =
-                    PRE_MINT_TOKEN_BALANCE + parseEther("100")
-
-                const authorization = isEip7702Compliant
-                    ? await privateKeyAccount.signAuthorization({
-                          address: (smartAccountClient.account as any)
-                              .implementation,
-                          chainId: smartAccountClient.chain.id,
-                          nonce: await publicClient.getTransactionCount({
-                              address: smartAccountClient.account.address
-                          })
-                      })
-                    : undefined
-
-                const opHash = await smartAccountClient.sendUserOperation({
-                    calls: [
-                        {
-                            to: zeroAddress,
-                            data: "0x",
-                            value: 0n
-                        }
-                    ],
-                    paymasterContext: {
-                        token: erc20Address
-                    },
-                    authorization
-                })
-
-                const receipt =
-                    await smartAccountClient.waitForUserOperationReceipt({
-                        hash: opHash
-                    })
-
-                expect(receipt).toBeTruthy()
-                expect(receipt).toBeTruthy()
-                expect(receipt.success).toBeTruthy()
-
-                const FINAL_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-                const FINAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                expect(FINAL_TOKEN_BALANCE).toBeLessThan(INITIAL_TOKEN_BALANCE) // Token balance should be deducted
-                expect(FINAL_ETH_BALANCE).toEqual(INTIAL_ETH_BALANCE) // There should be no ETH balance change
-            }
-        )
-
-        testWithRpc.skipIf(!supportsEntryPointV08)(
-            "prepareUserOperationForErc20Paymaster_v08 (balanceOverride enabled)",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const account = (
-                    await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.8"
-                        },
-                        privateKey,
-                        ...rpc
-                    })
-                ).account
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const pimlicoClient = createPimlicoClient({
-                    transport: http(rpc.paymasterRpc),
-                    entryPoint: {
-                        address: entryPoint08Address,
-                        version: "0.8"
-                    }
-                })
-
-                const smartAccountClient = createSmartAccountClient({
-                    // @ts-ignore
-                    client: getPublicClient(anvilRpc),
-                    account,
-                    paymaster: pimlicoClient,
-                    chain: foundry,
-                    userOperation: {
-                        prepareUserOperation:
-                            prepareUserOperationForErc20Paymaster(
-                                pimlicoClient,
-                                {
-                                    balanceOverride: true
-                                }
-                            )
-                    },
-                    bundlerTransport: createAutoBundleTransport(
-                        rpc.altoRpc,
-                        rpc.anvilRpc
-                    )
-                })
-
-                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                const PRE_MINT_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-
-                await sudoMintTokens({
-                    amount: parseEther("100"),
-                    to: smartAccountClient.account.address,
-                    anvilRpc
-                })
-
-                const INITIAL_TOKEN_BALANCE =
-                    PRE_MINT_TOKEN_BALANCE + parseEther("100")
-
-                const authorization = isEip7702Compliant
-                    ? await privateKeyAccount.signAuthorization({
-                          address: (smartAccountClient.account as any)
-                              .implementation,
-                          chainId: smartAccountClient.chain.id,
-                          nonce: await publicClient.getTransactionCount({
-                              address: smartAccountClient.account.address
-                          })
-                      })
-                    : undefined
-
-                const opHash = await smartAccountClient.sendUserOperation({
-                    calls: [
-                        {
-                            to: zeroAddress,
-                            data: "0x",
-                            value: 0n
-                        }
-                    ],
-                    paymasterContext: {
-                        token: erc20Address
-                    },
-                    authorization
-                })
-
-                const receipt =
-                    await smartAccountClient.waitForUserOperationReceipt({
-                        hash: opHash
-                    })
-
-                expect(receipt).toBeTruthy()
-                expect(receipt).toBeTruthy()
-                expect(receipt.success).toBeTruthy()
-
-                const FINAL_TOKEN_BALANCE = await tokenBalanceOf(
-                    smartAccountClient.account.address,
-                    rpc.anvilRpc
-                )
-                const FINAL_ETH_BALANCE = await publicClient.getBalance({
-                    address: smartAccountClient.account.address
-                })
-
-                expect(FINAL_TOKEN_BALANCE).toBeLessThan(INITIAL_TOKEN_BALANCE) // Token balance should be deducted
-                expect(FINAL_ETH_BALANCE).toEqual(INTIAL_ETH_BALANCE) // There should be no ETH balance change
-            }
-        )
-    }
-)

package/types/package.json

@@ -1,6 +0,0 @@
-{
-    "type": "module",
-    "types": "../_types/types/index.d.ts",
-    "module": "../_esm/types/index.js",
-    "main": "../_cjs/types/index.js"
-}

package/utils/decodeNonce.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "vitest"
-import { decodeNonce, encodeNonce } from "./index"
-
-describe("decodeNonce", () => {
-    test("should encode key and sequence correctly", async () => {
-        const key = 123456789012345678901234n
-        const sequence = 9876543210n
-
-        const result = encodeNonce({ key, sequence })
-
-        const decodedNonce = decodeNonce(result)
-
-        expect(decodedNonce.key).toBe(key)
-        expect(decodedNonce.sequence).toBe(sequence)
-    })
-
-    test("should handle zero values correctly", () => {
-        const key = BigInt(0)
-        const sequence = BigInt(0)
-
-        const result = encodeNonce({ key, sequence })
-
-        const decodedNonce = decodeNonce(result)
-
-        expect(decodedNonce.key).toBe(key)
-        expect(decodedNonce.sequence).toBe(sequence)
-    })
-
-    test("should handle large values correctly", () => {
-        const key = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFF")
-        const sequence = BigInt("0xFFFFFFFF")
-
-        const result = encodeNonce({ key, sequence })
-
-        const decodedNonce = decodeNonce(result)
-
-        expect(decodedNonce.key).toBe(key)
-        expect(decodedNonce.sequence).toBe(sequence)
-    })
-})

package/utils/deepHexlify.test.ts

@@ -1,57 +0,0 @@
-import { toHex } from "viem"
-import { describe, expect, test } from "vitest"
-import { deepHexlify } from "../utils"
-
-describe("deepHexlify", () => {
-    test("should return undefined for function input", async () => {
-        const func = () => {}
-        expect(deepHexlify(func)).toBeUndefined()
-    })
-
-    test("should return null for null input", () => {
-        expect(deepHexlify(null)).toBeNull()
-    })
-
-    test("should return the same string for string input", () => {
-        const str = "test"
-        expect(deepHexlify(str)).toBe(str)
-    })
-
-    test("should return the same boolean for boolean input", () => {
-        const bool = true
-        expect(deepHexlify(bool)).toBe(bool)
-    })
-
-    test("should return hex string for bigint input", () => {
-        const bigint = BigInt(12345)
-        expect(deepHexlify(bigint)).toBe(toHex(bigint))
-    })
-
-    test("should return hex string for number input", () => {
-        const number = 12345
-        expect(deepHexlify(number)).toBe(toHex(number).replace(/^0x0/, "0x"))
-    })
-
-    test("should return array with hex values for array input", () => {
-        const array = [12345, BigInt(67890)]
-        expect(deepHexlify(array)).toEqual([
-            toHex(12345).replace(/^0x0/, "0x"),
-            toHex(BigInt(67890))
-        ])
-    })
-
-    test("should return object with hex values for object input", () => {
-        const obj = {
-            a: 12345,
-            b: BigInt(67890),
-            c: "string",
-            d: true
-        }
-        expect(deepHexlify(obj)).toEqual({
-            a: toHex(12345).replace(/^0x0/, "0x"),
-            b: toHex(BigInt(67890)),
-            c: "string",
-            d: true
-        })
-    })
-})