permissionless 0.3.5 → 0.3.7

package/actions/smartAccount/sendTransaction.test.ts

@@ -1,416 +0,0 @@
-import { zeroAddress } from "viem"
-import { privateKeyToAccount } from "viem/accounts"
-import { describe, expect } from "vitest"
-import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import {
-    getCoreSmartAccounts,
-    getPublicClient
-} from "../../../permissionless-test/src/utils"
-import { sendTransaction } from "./sendTransaction"
-
-const privateKey =
-    "0x4bbbf85ce3377467afe5d46f804f221813b2bb87f24d81f60f1fcdbf7cbf4356"
-
-describe.each(getCoreSmartAccounts())(
-    "sendTransaction $name",
-    ({
-        getSmartAccountClient,
-        supportsEntryPointV06,
-        supportsEntryPointV07,
-        supportsEntryPointV08,
-        isEip7702Compliant
-    }) => {
-        testWithRpc.skipIf(!supportsEntryPointV06)(
-            "sendTransaction_v06",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.6"
-                    },
-                    ...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")
-
-                // -- second transaction after deployment
-
-                const transactionHash2 = await sendTransaction(smartClient, {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n
-                })
-
-                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(!supportsEntryPointV07)(
-            "sendTransaction_v07",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.7"
-                    },
-                    privateKey, // anvil private key
-                    ...rpc
-                })
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const transactionHash = await sendTransaction(smartClient, {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n,
-                    authorization: isEip7702Compliant
-                        ? await privateKeyAccount.signAuthorization({
-                              address: (smartClient.account as any)
-                                  .implementation,
-                              chainId: smartClient.chain.id,
-                              nonce: await publicClient.getTransactionCount({
-                                  address: smartClient.account.address
-                              })
-                          })
-                        : undefined
-                })
-
-                expect(transactionHash).toBeTruthy()
-
-                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(!supportsEntryPointV08)(
-            "sendTransaction_v08",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.8"
-                    },
-                    privateKey, // anvil private key
-                    ...rpc
-                })
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                const authorization = isEip7702Compliant
-                    ? await privateKeyAccount.signAuthorization({
-                          address: (smartClient.account as any).implementation,
-                          chainId: smartClient.chain.id,
-                          nonce: await publicClient.getTransactionCount({
-                              address: smartClient.account.address
-                          })
-                      })
-                    : undefined
-
-                const transactionHash = await sendTransaction(smartClient, {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n,
-                    authorization
-                })
-
-                expect(transactionHash).toBeTruthy()
-
-                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 }) => {
-                const { anvilRpc } = rpc
-
-                await (async () => {
-                    const smartClient = await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.6"
-                        },
-                        privateKey, // 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.6"
-                    },
-                    privateKey, // anvil private key
-                    ...rpc
-                })
-
-                const publicClient = getPublicClient(anvilRpc)
-
-                // -- second transaction after deployment
-                const transactionHash2 = await sendTransaction(smartClient, {
-                    to: zeroAddress,
-                    data: "0x",
-                    value: 0n
-                })
-
-                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(!supportsEntryPointV07)(
-            "sendTransaction_v07 post deployment",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                await (async () => {
-                    const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                    const smartClient = await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.7"
-                        },
-                        privateKey, // anvil private key
-                        ...rpc
-                    })
-
-                    const publicClient = getPublicClient(anvilRpc)
-
-                    const authorization = isEip7702Compliant
-                        ? await privateKeyAccount.signAuthorization({
-                              address: (smartClient.account as any)
-                                  .implementation,
-                              chainId: smartClient.chain.id,
-                              nonce: await publicClient.getTransactionCount({
-                                  address: smartClient.account.address
-                              })
-                          })
-                        : undefined
-
-                    const transactionHash = await sendTransaction(smartClient, {
-                        to: zeroAddress,
-                        data: "0x",
-                        value: 0n,
-                        authorization
-                    })
-
-                    expect(transactionHash).toBeTruthy()
-
-                    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.7"
-                    },
-                    privateKey, // 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")
-            }
-        )
-
-        testWithRpc.skipIf(!supportsEntryPointV08)(
-            "sendTransaction_v08 post deployment",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                await (async () => {
-                    const smartClient = await getSmartAccountClient({
-                        entryPoint: {
-                            version: "0.8"
-                        },
-                        privateKey, // anvil private key
-                        ...rpc
-                    })
-
-                    const publicClient = getPublicClient(anvilRpc)
-
-                    const authorization = isEip7702Compliant
-                        ? await privateKeyAccount.signAuthorization({
-                              address: (smartClient.account as any)
-                                  .implementation,
-                              chainId: smartClient.chain.id,
-                              nonce: await publicClient.getTransactionCount({
-                                  address: smartClient.account.address
-                              })
-                          })
-                        : undefined
-
-                    const transactionHash = await sendTransaction(smartClient, {
-                        to: zeroAddress,
-                        data: "0x",
-                        value: 0n,
-                        authorization
-                    })
-
-                    expect(transactionHash).toBeTruthy()
-
-                    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, // 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

@@ -1,219 +0,0 @@
-import { zeroAddress } from "viem"
-import { privateKeyToAccount } from "viem/accounts"
-import { describe, expect } from "vitest"
-import { testWithRpc } from "../../../permissionless-test/src/testWithRpc"
-import {
-    getCoreSmartAccounts,
-    getPublicClient
-} from "../../../permissionless-test/src/utils"
-import { signMessage } from "./signMessage"
-
-const privateKey =
-    "0x4bbbf85ce3377467afe5d46f804f221813b2bb87f24d81f60f1fcdbf7cbf4356"
-
-describe.each(getCoreSmartAccounts())(
-    "signMessage $name",
-    ({
-        getSmartAccountClient,
-        isEip1271Compliant,
-        supportsEntryPointV06,
-        supportsEntryPointV07,
-        supportsEntryPointV08,
-        isEip7702Compliant,
-        name
-    }) => {
-        testWithRpc.skipIf(isEip1271Compliant || !supportsEntryPointV06)(
-            "not isEip1271Compliant_v06",
-            async ({ rpc }) => {
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.6"
-                    },
-                    ...rpc
-                })
-
-                await expect(async () =>
-                    signMessage(smartClient, {
-                        message: "slowly and steadily burning the private keys"
-                    })
-                ).rejects.toThrow()
-            }
-        )
-
-        testWithRpc.skipIf(!isEip1271Compliant || !supportsEntryPointV06)(
-            "isEip1271Compliant_v06",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.6"
-                    },
-                    ...rpc
-                })
-
-                if (!smartClient.account) {
-                    throw new Error("Account not found")
-                }
-
-                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",
-                    account: smartClient.account
-                })
-
-                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()
-            }
-        )
-
-        testWithRpc.skipIf(isEip1271Compliant || !supportsEntryPointV07)(
-            "not isEip1271Compliant_v07",
-            async ({ rpc }) => {
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.7"
-                    },
-                    ...rpc
-                })
-
-                await expect(async () =>
-                    signMessage(smartClient, {
-                        message: "slowly and steadily burning the private keys"
-                    })
-                ).rejects.toThrow()
-            }
-        )
-
-        testWithRpc.skipIf(!isEip1271Compliant || !supportsEntryPointV07)(
-            "isEip1271Compliant_v07",
-            async ({ rpc }) => {
-                const { anvilRpc } = rpc
-
-                const privateKeyAccount = privateKeyToAccount(privateKey)
-
-                const smartClient = await getSmartAccountClient({
-                    entryPoint: {
-                        version: "0.7"
-                    },
-                    privateKey, // anvil private key
-                    ...rpc
-                })
-
-                if (name === "LightAccount 2.0.0") {
-                    // LightAccount 2.0.0 doesn't support EIP-1271
-                    return
-                }
-
-                if (
-                    name.includes("Safe 7579") ||
-                    name.includes("Kernel 0.3.3 + EIP-7702")
-                ) {
-                    const publicClient = getPublicClient(anvilRpc)
-
-                    // Due to 7579 launchpad, we can't verify the signature before deploying the account.
-                    await smartClient.sendTransaction({
-                        calls: [{ to: zeroAddress, value: 0n }],
-                        authorization: isEip7702Compliant
-                            ? await privateKeyAccount.signAuthorization({
-                                  address: (smartClient.account as any)
-                                      .implementation,
-                                  chainId: smartClient.chain.id,
-                                  nonce: await publicClient.getTransactionCount(
-                                      {
-                                          address: smartClient.account.address
-                                      }
-                                  )
-                              })
-                            : undefined
-                    })
-                }
-
-                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()
-            }
-        )
-
-        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()
-            }
-        )
-    }
-)