permissionless 0.1.35 → 0.1.36

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
+        )
+    })
+})

package/clients/decorators/smartAccount.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
+        )
+    })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "permissionless",
-    "version": "0.1.35",
+    "version": "0.1.36",
     "author": "Pimlico",
     "homepage": "https://docs.pimlico.io/permissionless",
     "repository": "github:pimlicolabs/permissionless.js",

package/utils/deepHexlify.test.ts

@@ -0,0 +1,57 @@
+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
+        })
+    })
+})

package/utils/encode7579CallData.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "vitest"
+import { encode7579CallData } from "./encode7579CallData"
+
+describe("encode7579CallData", () => {
+    test("single call", async () => {
+        const callData = encode7579CallData({
+            mode: {
+                type: "call"
+            },
+            callData: {
+                to: "0x1234567890123456789012345678901234567890",
+                value: BigInt(12345),
+                data: "0x1234567890123456789012345678901234567890"
+            }
+        })
+
+        expect(callData).toBe(
+            "0xe9ae5c53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000048123456789012345678901234567890123456789000000000000000000000000000000000000000000000000000000000000030391234567890123456789012345678901234567890000000000000000000000000000000000000000000000000"
+        )
+    })
+
+    test("batch call", async () => {
+        const callData = encode7579CallData({
+            mode: {
+                type: "batchcall"
+            },
+            callData: [
+                {
+                    to: "0x1234567890123456789012345678901234567890",
+                    value: BigInt(12345),
+                    data: "0x1234567890123456789012345678901234567890"
+                },
+                {
+                    to: "0x1234567890123456789012345678901234567890",
+                    value: BigInt(12345),
+                    data: "0x1234567890123456789012345678901234567890"
+                }
+            ]
+        })
+
+        expect(callData).toBe(
+            "0xe9ae5c53ff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000001234567890123456789012345678901234567890000000000000000000000000000000000000000000000000000000000000303900000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014123456789012345678901234567890123456789000000000000000000000000000000000000000000000000012345678901234567890123456789012345678900000000000000000000000000000000000000000000000000000000000003039000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000141234567890123456789012345678901234567890000000000000000000000000"
+        )
+    })
+
+    test("should throw error for batch call with different mode", async () => {
+        expect(() => {
+            encode7579CallData({
+                mode: {
+                    type: "call"
+                },
+                // @ts-expect-error
+                callData: [
+                    {
+                        to: "0x1234567890123456789012345678901234567890",
+                        value: BigInt(12345),
+                        data: "0x1234567890123456789012345678901234567890"
+                    },
+                    {
+                        to: "0x1234567890123456789012345678901234567890",
+                        value: BigInt(12345),
+                        data: "0x1234567890123456789012345678901234567890"
+                    }
+                ]
+            })
+        }).toThrowError("batchcall calldata")
+    })
+})

package/utils/encode7579CallData.ts

@@ -33,7 +33,7 @@ export function encode7579CallData<callType extends CallType>({
 }: EncodeCallDataParams<callType>): Hex {
     if (Array.isArray(callData) && mode?.type !== "batchcall") {
         throw new Error(
-            `mode ${mode} does not supported for batchcall calldata`
+            `mode ${JSON.stringify(mode)} does not supported for batchcall calldata`
         )
     }
 

package/utils/getAddressFromInitCodeOrPaymasterAndData.test.ts

@@ -0,0 +1,31 @@
+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/getEntryPointVersion.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "vitest"
+import {
+    ENTRYPOINT_ADDRESS_V06,
+    ENTRYPOINT_ADDRESS_V07,
+    getEntryPointVersion,
+    isUserOperationVersion06,
+    isUserOperationVersion07
+} from "./getEntryPointVersion"
+
+describe("getEntryPointVersion", () => {
+    describe("getEntryPointVersion", () => {
+        test('should return "v0.6" for ENTRYPOINT_ADDRESS_V06', () => {
+            expect(getEntryPointVersion(ENTRYPOINT_ADDRESS_V06)).toBe("v0.6")
+        })
+
+        test('should return "v0.7" for ENTRYPOINT_ADDRESS_V07', () => {
+            expect(getEntryPointVersion(ENTRYPOINT_ADDRESS_V07)).toBe("v0.7")
+        })
+    })
+
+    describe("isUserOperationVersion06", () => {
+        test('should return true for ENTRYPOINT_ADDRESS_V06 and UserOperation<"v0.6">', () => {
+            const userOperation = {} as any // mock UserOperation<"v0.6">
+            expect(
+                isUserOperationVersion06(ENTRYPOINT_ADDRESS_V06, userOperation)
+            ).toBe(true)
+        })
+
+        test('should return false for ENTRYPOINT_ADDRESS_V07 and UserOperation<"v0.6">', () => {
+            const userOperation = {} as any // mock UserOperation<"v0.6">
+            expect(
+                isUserOperationVersion06(ENTRYPOINT_ADDRESS_V07, userOperation)
+            ).toBe(false)
+        })
+    })
+
+    describe("isUserOperationVersion07", () => {
+        test('should return false for ENTRYPOINT_ADDRESS_V06 and UserOperation<"v0.6">', () => {
+            const userOperation = {} as any // mock UserOperation<"v0.6">
+            expect(
+                isUserOperationVersion07(ENTRYPOINT_ADDRESS_V06, userOperation)
+            ).toBe(false)
+        })
+
+        test('should return true for ENTRYPOINT_ADDRESS_V07 and UserOperation<"v0.7">', () => {
+            const userOperation = {} as any // mock UserOperation<"v0.7">
+            expect(
+                isUserOperationVersion07(ENTRYPOINT_ADDRESS_V07, userOperation)
+            ).toBe(true)
+        })
+    })
+})