permissionless 0.3.5 → 0.3.7

package/utils/encodeNonce.test.ts

@@ -1,38 +0,0 @@
-import { toHex } from "viem"
-import { describe, expect, test } from "vitest"
-import { encodeNonce } from "./index"
-
-describe("encodeNonce", () => {
-    test("should encode key and sequence correctly", async () => {
-        const key = 123456789012345678901234n
-        const sequence = 9876543210n
-        const expectedKey = BigInt(toHex(key, { size: 24 }))
-        const expectedSequence = BigInt(toHex(sequence, { size: 8 }))
-
-        const result = encodeNonce({ key, sequence })
-
-        expect(result).toBe((expectedKey << BigInt(64)) + expectedSequence)
-    })
-
-    test("should handle zero values correctly", () => {
-        const key = BigInt(0)
-        const sequence = BigInt(0)
-        const expectedKey = BigInt(toHex(key, { size: 24 }))
-        const expectedSequence = BigInt(toHex(sequence, { size: 8 }))
-
-        const result = encodeNonce({ key, sequence })
-
-        expect(result).toBe((expectedKey << BigInt(64)) + expectedSequence)
-    })
-
-    test("should handle large values correctly", () => {
-        const key = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFF")
-        const sequence = BigInt("0xFFFFFFFF")
-        const expectedKey = BigInt(toHex(key, { size: 24 }))
-        const expectedSequence = BigInt(toHex(sequence, { size: 8 }))
-
-        const result = encodeNonce({ key, sequence })
-
-        expect(result).toBe((expectedKey << BigInt(64)) + expectedSequence)
-    })
-})

package/utils/erc20AllowanceOverride.test.ts

@@ -1,59 +0,0 @@
-import { toHex } from "viem"
-import { describe, expect, test } from "vitest"
-import {
-    type Erc20AllowanceOverrideParameters,
-    erc20AllowanceOverride
-} from "./erc20AllowanceOverride"
-
-describe("erc20AllowanceOverride", () => {
-    test("should return the correct structure for valid inputs", () => {
-        const params = {
-            token: "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-            owner: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
-            spender: "0xDDdDddDdDdddDDddDDddDDDDdDdDDdDDdDDDDDDd",
-            slot: BigInt(1),
-            amount: BigInt(100)
-        } as const
-
-        const result = erc20AllowanceOverride(params)
-
-        expect(result).toEqual([
-            {
-                address: params.token,
-                stateDiff: [
-                    {
-                        slot: expect.any(String), // Slot will be a keccak256 hash
-                        value: toHex(params.amount)
-                    }
-                ]
-            }
-        ])
-    })
-
-    test("should use the default amount when none is provided", () => {
-        const params: Erc20AllowanceOverrideParameters = {
-            token: "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-            owner: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
-            spender: "0xDDdDddDdDdddDDddDDddDDDDdDdDDdDDdDDDDDDd",
-            slot: BigInt(1)
-        }
-
-        const result = erc20AllowanceOverride(params)
-
-        const expectedDefaultAmount = BigInt(
-            "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
-        )
-
-        expect(result).toEqual([
-            {
-                address: params.token,
-                stateDiff: [
-                    {
-                        slot: expect.any(String), // Slot will be a keccak256 hash
-                        value: toHex(expectedDefaultAmount)
-                    }
-                ]
-            }
-        ])
-    })
-})

package/utils/erc20BalanceOverride.test.ts

@@ -1,57 +0,0 @@
-import { toHex } from "viem"
-import { describe, expect, test } from "vitest"
-import {
-    type Erc20BalanceOverrideParameters,
-    erc20BalanceOverride
-} from "./erc20BalanceOverride"
-
-describe("erc20BalanceOverride", () => {
-    test("should return the correct structure for valid inputs", () => {
-        const params = {
-            token: "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-            owner: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
-            slot: BigInt(1),
-            balance: BigInt(1000)
-        } as const
-
-        const result = erc20BalanceOverride(params)
-
-        expect(result).toEqual([
-            {
-                address: params.token,
-                stateDiff: [
-                    {
-                        slot: expect.any(String), // Slot will be a keccak256 hash
-                        value: toHex(params.balance)
-                    }
-                ]
-            }
-        ])
-    })
-
-    test("should use the default balance when none is provided", () => {
-        const params: Erc20BalanceOverrideParameters = {
-            token: "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
-            owner: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
-            slot: BigInt(1)
-        }
-
-        const result = erc20BalanceOverride(params)
-
-        const expectedDefaultBalance = BigInt(
-            "0x100000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
-        )
-
-        expect(result).toEqual([
-            {
-                address: params.token,
-                stateDiff: [
-                    {
-                        slot: expect.any(String), // Slot will be a keccak256 hash
-                        value: toHex(expectedDefaultBalance)
-                    }
-                ]
-            }
-        ])
-    })
-})

package/utils/getAddressFromInitCodeOrPaymasterAndData.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, test } from "vitest"
-import { getAddressFromInitCodeOrPaymasterAndData } from "./getAddressFromInitCodeOrPaymasterAndData"
-
-describe("getAddressFromInitCodeOrPaymasterAndData", () => {
-    test("should return undefined for undefined data", () => {
-        expect(
-            // @ts-expect-error
-            getAddressFromInitCodeOrPaymasterAndData(undefined)
-        ).toBeUndefined()
-    })
-
-    test("should return undefined for empty string data", () => {
-        // @ts-expect-error
-        expect(getAddressFromInitCodeOrPaymasterAndData("")).toBeUndefined()
-    })
-
-    test("should return undefined for data shorter than 42 characters", () => {
-        const shortData = "0x123456789"
-        expect(
-            getAddressFromInitCodeOrPaymasterAndData(shortData)
-        ).toBeUndefined()
-    })
-
-    test("should return the correct address for data exactly 42 characters", () => {
-        const expectedAddress = "0x1234567890123456789012345678901234567890"
-        const exactData = `${expectedAddress}_mocked_address_for`
-        expect(getAddressFromInitCodeOrPaymasterAndData(exactData)).toBe(
-            expectedAddress
-        )
-    })
-})

package/utils/getPackedUserOperation.test.ts

@@ -1,204 +0,0 @@
-import { describe, expect, test } from "vitest"
-import type { UserOperation } from "../types/userOperation"
-import {
-    getAccountGasLimits,
-    getGasLimits,
-    getInitCode,
-    getPackedUserOperation,
-    getPaymasterAndData,
-    unPackInitCode,
-    unpackAccountGasLimits,
-    unpackGasLimits,
-    unpackPaymasterAndData
-} from "./getPackedUserOperation"
-
-describe("getPackedUserOperation", () => {
-    describe("getInitCode", () => {
-        test("should return concatenated factory and factoryData", () => {
-            const userOperation = {
-                factory: "0x60e04be163dBb94688952449bbD9755D1Cd63231",
-                factoryData: "0xfedcba0987654321"
-            }
-            expect(getInitCode(userOperation as UserOperation<"v0.7">)).toBe(
-                "0x60e04be163dBb94688952449bbD9755D1Cd63231fedcba0987654321"
-            )
-        })
-
-        test("should return factory with default factoryData when factoryData is missing", () => {
-            const userOperation = {
-                factory: "0x1234567890abcdef"
-            }
-            expect(getInitCode(userOperation as UserOperation<"v0.7">)).toBe(
-                "0x1234567890abcdef"
-            )
-        })
-
-        test('should return "0x" when factory is missing', () => {
-            const userOperation = {}
-            expect(getInitCode(userOperation as UserOperation<"v0.7">)).toBe(
-                "0x"
-            )
-        })
-    })
-
-    describe("unPackInitCode", () => {
-        test('should return nulls for factory and factoryData when initCode is "0x"', () => {
-            expect(unPackInitCode("0x")).toEqual({
-                factory: null,
-                factoryData: null
-            })
-        })
-
-        test("should return sliced factory and factoryData from initCode", () => {
-            const initCode =
-                "0x60e04be163dBb94688952449bbD9755D1Cd63231fedcba0987654321"
-            expect(unPackInitCode(initCode)).toEqual({
-                factory: "0x60e04be163dBb94688952449bbD9755D1Cd63231",
-                factoryData: "0xfedcba0987654321"
-            })
-        })
-    })
-
-    describe("getAccountGasLimits", () => {
-        test("should return concatenated padded verificationGasLimit and callGasLimit", () => {
-            const userOperation = {
-                verificationGasLimit: BigInt(1000),
-                callGasLimit: BigInt(2000)
-            }
-            expect(
-                getAccountGasLimits(userOperation as UserOperation<"v0.7">)
-            ).toBe(
-                "0x000000000000000000000000000003e8000000000000000000000000000007d0"
-            )
-        })
-    })
-
-    describe("unpackAccountGasLimits", () => {
-        test("should return verificationGasLimit and callGasLimit from sliced accountGasLimits", () => {
-            const accountGasLimits =
-                "0x000000000000000000000000000003e8000000000000000000000000000007d0"
-            expect(unpackAccountGasLimits(accountGasLimits)).toEqual({
-                verificationGasLimit: BigInt(1000),
-                callGasLimit: BigInt(2000)
-            })
-        })
-    })
-
-    describe("getGasLimits", () => {
-        test("should return concatenated padded maxPriorityFeePerGas and maxFeePerGas", () => {
-            const userOperation = {
-                maxPriorityFeePerGas: BigInt(1000),
-                maxFeePerGas: BigInt(2000)
-            }
-            expect(getGasLimits(userOperation as UserOperation<"v0.7">)).toBe(
-                "0x000000000000000000000000000003e8000000000000000000000000000007d0"
-            )
-        })
-    })
-
-    describe("unpackGasLimits", () => {
-        test("should return maxPriorityFeePerGas and maxFeePerGas from sliced gasLimits", () => {
-            const gasLimits =
-                "0x000000000000000000000000000003e8000000000000000000000000000007d0"
-            expect(unpackGasLimits(gasLimits)).toEqual({
-                maxPriorityFeePerGas: BigInt(1000),
-                maxFeePerGas: BigInt(2000)
-            })
-        })
-    })
-
-    describe("getPaymasterAndData", () => {
-        test("should return concatenated paymaster, verificationGasLimit, postOpGasLimit and paymasterData", () => {
-            const userOperation = {
-                paymaster: "0x60e04be163dBb94688952449bbD9755D1Cd63231",
-                paymasterVerificationGasLimit: BigInt(1000),
-                paymasterPostOpGasLimit: BigInt(2000),
-                paymasterData: "0xabcdef"
-            }
-            expect(
-                getPaymasterAndData(userOperation as UserOperation<"v0.7">)
-            ).toBe(
-                "0x60e04be163dBb94688952449bbD9755D1Cd63231000000000000000000000000000003e8000000000000000000000000000007d0abcdef"
-            )
-        })
-
-        test("should return concatenated paymaster with default values when some fields are missing", () => {
-            const userOperation = {
-                paymaster: "0x1234567890abcdef"
-            }
-            expect(
-                getPaymasterAndData(userOperation as UserOperation<"v0.7">)
-            ).toBe(
-                "0x1234567890abcdef0000000000000000000000000000000000000000000000000000000000000000"
-            )
-        })
-
-        test('should return "0x" when paymaster is missing', () => {
-            const userOperation = {}
-            expect(
-                getPaymasterAndData(userOperation as UserOperation<"v0.7">)
-            ).toBe("0x")
-        })
-    })
-
-    describe("unpackPaymasterAndData", () => {
-        test('should return nulls for all fields when paymasterAndData is "0x"', () => {
-            expect(unpackPaymasterAndData("0x")).toEqual({
-                paymaster: null,
-                paymasterVerificationGasLimit: null,
-                paymasterPostOpGasLimit: null,
-                paymasterData: null
-            })
-        })
-
-        test("should return sliced fields from paymasterAndData", () => {
-            const paymasterAndData =
-                "0x60e04be163dBb94688952449bbD9755D1Cd63231000000000000000000000000000003e8000000000000000000000000000007d0abcdef"
-            expect(unpackPaymasterAndData(paymasterAndData)).toEqual({
-                paymaster: "0x60e04be163dBb94688952449bbD9755D1Cd63231",
-                paymasterVerificationGasLimit: BigInt(1000),
-                paymasterPostOpGasLimit: BigInt(2000),
-                paymasterData: "0xabcdef"
-            })
-        })
-    })
-
-    describe("getPackedUserOperation", () => {
-        test("should return packed user operation", () => {
-            const userOperation = {
-                sender: "0xsender",
-                nonce: BigInt(1),
-                factory: "0xfactory",
-                factoryData: "0xfactoryData",
-                verificationGasLimit: BigInt(1000),
-                callGasLimit: BigInt(2000),
-                callData: "0xcallData",
-                preVerificationGas: BigInt(500),
-                maxPriorityFeePerGas: BigInt(3000),
-                maxFeePerGas: BigInt(4000),
-                paymaster: "0xpaymaster",
-                paymasterVerificationGasLimit: BigInt(5000),
-                paymasterPostOpGasLimit: BigInt(6000),
-                paymasterData: "0xpaymasterData",
-                signature: "0xsignature"
-            }
-            const packedUserOperation = getPackedUserOperation(
-                userOperation as UserOperation<"v0.7">
-            )
-            expect(packedUserOperation).toEqual({
-                sender: "0xsender",
-                callData: "0xcallData",
-                nonce: BigInt(1),
-                initCode: "0xfactoryfactoryData",
-                accountGasLimits:
-                    "0x000000000000000000000000000003e8000000000000000000000000000007d0",
-                preVerificationGas: BigInt(500),
-                gasFees:
-                    "0x00000000000000000000000000000bb800000000000000000000000000000fa0",
-                paymasterAndData:
-                    "0xpaymaster0000000000000000000000000000138800000000000000000000000000001770paymasterData",
-                signature: "0xsignature"
-            })
-        })
-    })
-})

package/utils/getRequiredPrefund.test.ts

@@ -1,90 +0,0 @@
-import type { UserOperation } from "viem/account-abstraction"
-import { describe, expect, test } from "vitest"
-import { getRequiredPrefund } from "./getRequiredPrefund"
-
-describe("getRequiredPrefund", () => {
-    describe("v0.6 UserOperation", () => {
-        test("should calculate the required prefund without paymasterAndData", () => {
-            const userOperation = {
-                callGasLimit: BigInt(1000),
-                verificationGasLimit: BigInt(2000),
-                preVerificationGas: BigInt(500),
-                maxFeePerGas: BigInt(10),
-                paymasterAndData: "0x"
-            }
-            const result = getRequiredPrefund({
-                userOperation: userOperation as UserOperation<"0.6">,
-                entryPointVersion: "0.6"
-            })
-            const expectedGas =
-                BigInt(1000) + BigInt(2000) * BigInt(1) + BigInt(500)
-            const expectedResult = expectedGas * BigInt(10)
-            expect(result).toBe(expectedResult)
-        })
-
-        test("should calculate the required prefund with paymasterAndData", () => {
-            const userOperation = {
-                callGasLimit: BigInt(1000),
-                verificationGasLimit: BigInt(2000),
-                preVerificationGas: BigInt(500),
-                maxFeePerGas: BigInt(10),
-                paymasterAndData: "0x1234"
-            }
-            const result = getRequiredPrefund({
-                userOperation: userOperation as UserOperation<"0.6">,
-                entryPointVersion: "0.6"
-            })
-            const multiplier = BigInt(3)
-            const expectedGas =
-                BigInt(1000) + BigInt(2000) * multiplier + BigInt(500)
-            const expectedResult = expectedGas * BigInt(10)
-            expect(result).toBe(expectedResult)
-        })
-    })
-    describe("v0.7 UserOperation", () => {
-        test("should calculate the required prefund without paymater gasLimits", () => {
-            const userOperation = {
-                callGasLimit: BigInt(1000),
-                verificationGasLimit: BigInt(2000),
-                preVerificationGas: BigInt(500),
-                paymasterVerificationGasLimit: undefined,
-                paymasterPostOpGasLimit: undefined,
-                paymaster: undefined,
-                paymasterData: undefined,
-                maxFeePerGas: BigInt(10)
-            }
-            const result = getRequiredPrefund({
-                userOperation: userOperation as UserOperation<"0.7">,
-                entryPointVersion: "0.7"
-            })
-            const expectedGas =
-                BigInt(1000) + BigInt(2000) * BigInt(1) + BigInt(500)
-            const expectedResult = expectedGas * BigInt(10)
-            expect(result).toBe(expectedResult)
-        })
-
-        test("should calculate the required prefund with paymaster gasLimits", () => {
-            const userOperation = {
-                callGasLimit: BigInt(1000),
-                verificationGasLimit: BigInt(2000),
-                preVerificationGas: BigInt(500),
-                paymasterVerificationGasLimit: BigInt(20),
-                paymasterPostOpGasLimit: BigInt(30),
-                paymaster: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-                maxFeePerGas: BigInt(10)
-            }
-            const result = getRequiredPrefund({
-                userOperation: userOperation as UserOperation<"0.7">,
-                entryPointVersion: "0.7"
-            })
-            const expectedGas =
-                BigInt(1000) +
-                BigInt(2000) +
-                BigInt(500) +
-                BigInt(20) +
-                BigInt(30)
-            const expectedResult = expectedGas * BigInt(10)
-            expect(result).toBe(expectedResult)
-        })
-    })
-})

package/vitest.config.ts

@@ -1,31 +0,0 @@
-import { join } from "node:path"
-import { loadEnv } from "vite"
-import { defineConfig } from "vitest/config"
-
-export default defineConfig({
-    test: {
-        coverage: {
-            all: true,
-            provider: "v8",
-            reporter: process.env.CI ? ["lcov"] : ["text", "json", "html"],
-            include: ["**/permissionless/**"],
-            exclude: [
-                "**/errors/utils.ts",
-                "**/*.test.ts",
-                "**/permissionless-test/**",
-                "**/_cjs/**",
-                "**/_esm/**",
-                "**/_types/**"
-            ]
-        },
-        sequence: {
-            concurrent: false
-        },
-        fileParallelism: true,
-        environment: "node",
-        testTimeout: 60_000,
-        hookTimeout: 45_000,
-        include: [join(__dirname, "./**/*.test.ts")],
-        env: loadEnv("test", process.cwd())
-    }
-})