permissionless 0.2.4 → 0.2.6

package/_types/utils/getRequiredPrefund.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRequiredPrefund.d.ts","sourceRoot":"","sources":["../../utils/getRequiredPrefund.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE7D,MAAM,MAAM,4BAA4B,CACpC,iBAAiB,SAAS,KAAK,GAAG,KAAK,IACvC;IACA,aAAa,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;IAC/C,iBAAiB,EAAE,iBAAiB,CAAA;CACvC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,sIAGsB,MA2BpD,CAAA"}
+{"version":3,"file":"getRequiredPrefund.d.ts","sourceRoot":"","sources":["../../utils/getRequiredPrefund.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE7D,MAAM,MAAM,4BAA4B,CACpC,iBAAiB,SAAS,KAAK,GAAG,KAAK,IACvC;IACA,aAAa,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;IAC/C,iBAAiB,EAAE,iBAAiB,CAAA;CACvC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,GAAI,iBAAiB,SAAS,KAAK,GAAG,KAAK,wCAGvE,4BAA4B,CAAC,iBAAiB,CAAC,KAAG,MA2BpD,CAAA"}

package/_types/utils/isSmartAccountDeployed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSmartAccountDeployed.d.ts","sourceRoot":"","sources":["../../utils/isSmartAccountDeployed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG3C,eAAO,MAAM,sBAAsB,WACvB,MAAM,WACL,OAAO,KACjB,QAAQ,OAAO,CAMjB,CAAA"}
+{"version":3,"file":"isSmartAccountDeployed.d.ts","sourceRoot":"","sources":["../../utils/isSmartAccountDeployed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG3C,eAAO,MAAM,sBAAsB,WACvB,MAAM,WACL,OAAO,KACjB,OAAO,CAAC,OAAO,CAMjB,CAAA"}

package/clients/createSmartAccountClient.ts

@@ -1,20 +1,23 @@
-import type {
-    BundlerRpcSchema,
-    Chain,
-    Client,
-    ClientConfig,
-    EstimateFeesPerGasReturnType,
-    Prettify,
-    RpcSchema,
-    Transport
+import {
+    type BundlerRpcSchema,
+    type Chain,
+    type Client,
+    type ClientConfig,
+    type EstimateFeesPerGasReturnType,
+    type Prettify,
+    type RpcSchema,
+    type Transport,
+    createClient
 } from "viem"
 import {
     type BundlerActions,
     type BundlerClientConfig,
     type PaymasterActions,
+    type PrepareUserOperationParameters,
     type SmartAccount,
     type UserOperationRequest,
-    createBundlerClient
+    bundlerActions,
+    type prepareUserOperation as viemPrepareUserOperation
 } from "viem/account-abstraction"
 import {
     type SmartAccountActions,
@@ -101,6 +104,8 @@ export type SmartAccountClientConfig<
                         userOperation: UserOperationRequest
                     }) => Promise<EstimateFeesPerGasReturnType<"eip1559">>)
                   | undefined
+              /** Prepare User Operation configuration. */
+              prepareUserOperation?: typeof viemPrepareUserOperation | undefined
           }
         | undefined
 }
@@ -134,16 +139,43 @@ export function createSmartAccountClient(
         userOperation
     } = parameters
 
-    const client = createBundlerClient({
-        ...parameters,
-        chain: parameters.chain ?? client_?.chain,
-        key,
-        name,
-        transport: bundlerTransport,
-        paymaster,
-        paymasterContext,
-        userOperation
-    })
+    const client = Object.assign(
+        createClient({
+            ...parameters,
+            chain: parameters.chain ?? client_?.chain,
+            transport: bundlerTransport,
+            key,
+            name,
+            type: "bundlerClient" // TODO: is this okay?
+        }),
+        { client: client_, paymaster, paymasterContext, userOperation }
+    )
+
+    if (parameters.userOperation?.prepareUserOperation) {
+        const customPrepareUserOp =
+            parameters.userOperation.prepareUserOperation
+
+        return client
+            .extend(bundlerActions)
+            .extend((client) => ({
+                prepareUserOperation: (
+                    args: PrepareUserOperationParameters
+                ) => {
+                    return customPrepareUserOp(client, args)
+                }
+            }))
+            .extend(bundlerActions)
+            .extend((client) => ({
+                prepareUserOperation: (
+                    args: PrepareUserOperationParameters
+                ) => {
+                    return customPrepareUserOp(client, args)
+                }
+            }))
+            .extend(smartAccountActions()) as SmartAccountClient
+    }
 
-    return client.extend(smartAccountActions()) as unknown as SmartAccountClient
+    return client
+        .extend(bundlerActions)
+        .extend(smartAccountActions()) as SmartAccountClient
 }

package/experimental/pimlico/index.ts

@@ -0,0 +1,2 @@
+import { prepareUserOperationForErc20Paymaster } from "./utils/prepareUserOperationForErc20Paymaster"
+export { prepareUserOperationForErc20Paymaster }

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

@@ -0,0 +1,195 @@
+import { http, parseEther, zeroAddress } from "viem"
+import {
+    entryPoint06Address,
+    entryPoint07Address
+} from "viem/account-abstraction"
+import { foundry } from "viem/chains"
+import { describe, expect } from "vitest"
+import {
+    ERC20_ADDRESS,
+    sudoMintTokens,
+    tokenBalanceOf
+} from "../../../../permissionless-test/src/erc20-utils.ts"
+import { testWithRpc } from "../../../../permissionless-test/src/testWithRpc.ts"
+import {
+    getCoreSmartAccounts,
+    getPublicClient
+} from "../../../../permissionless-test/src/utils"
+import { createSmartAccountClient } from "../../../clients/createSmartAccountClient.ts"
+import { createPimlicoClient } from "../../../clients/pimlico.ts"
+import { prepareUserOperationForErc20Paymaster } from "./prepareUserOperationForErc20Paymaster.ts"
+
+describe.each(getCoreSmartAccounts())(
+    "prepareUserOperationForErc20Paymaster $name",
+    ({
+        getSmartAccountClient,
+        supportsEntryPointV06,
+        supportsEntryPointV07
+    }) => {
+        testWithRpc.skipIf(!supportsEntryPointV06)(
+            "prepareUserOperationForErc20Paymaster_v06",
+            async ({ rpc }) => {
+                const { anvilRpc } = rpc
+
+                const account = (
+                    await getSmartAccountClient({
+                        entryPoint: {
+                            version: "0.6"
+                        },
+                        ...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: http(rpc.altoRpc)
+                })
+
+                const INITIAL_TOKEN_BALANCE = parseEther("100")
+                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
+                    address: smartAccountClient.account.address
+                })
+
+                sudoMintTokens({
+                    amount: INITIAL_TOKEN_BALANCE,
+                    to: smartAccountClient.account.address,
+                    anvilRpc
+                })
+
+                const opHash = await smartAccountClient.sendUserOperation({
+                    calls: [
+                        {
+                            to: zeroAddress,
+                            data: "0x",
+                            value: 0n
+                        }
+                    ],
+                    paymasterContext: {
+                        token: ERC20_ADDRESS
+                    }
+                })
+
+                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 account = (
+                    await getSmartAccountClient({
+                        entryPoint: {
+                            version: "0.7"
+                        },
+                        ...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: http(rpc.altoRpc)
+                })
+
+                const INITIAL_TOKEN_BALANCE = parseEther("100")
+                const INTIAL_ETH_BALANCE = await publicClient.getBalance({
+                    address: smartAccountClient.account.address
+                })
+
+                sudoMintTokens({
+                    amount: INITIAL_TOKEN_BALANCE,
+                    to: smartAccountClient.account.address,
+                    anvilRpc
+                })
+
+                const opHash = await smartAccountClient.sendUserOperation({
+                    calls: [
+                        {
+                            to: zeroAddress,
+                            data: "0x",
+                            value: 0n
+                        }
+                    ],
+                    paymasterContext: {
+                        token: ERC20_ADDRESS
+                    }
+                })
+
+                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/experimental/pimlico/utils/prepareUserOperationForErc20Paymaster.ts

@@ -0,0 +1,270 @@
+import {
+    type Address,
+    type Chain,
+    type Client,
+    type ContractFunctionParameters,
+    type Transport,
+    encodeFunctionData,
+    erc20Abi,
+    getAddress,
+    maxUint256
+} from "viem"
+import {
+    type BundlerClient,
+    type PrepareUserOperationParameters,
+    type PrepareUserOperationRequest,
+    type PrepareUserOperationReturnType,
+    type SmartAccount,
+    type UserOperation,
+    type UserOperationCall,
+    getPaymasterData as getPaymasterData_,
+    prepareUserOperation
+} from "viem/account-abstraction"
+import { getChainId as getChainId_ } from "viem/actions"
+import { readContract } from "viem/actions"
+import { getAction, parseAccount } from "viem/utils"
+import { getTokenQuotes } from "../../../actions/pimlico"
+
+export const prepareUserOperationForErc20Paymaster =
+    (pimlicoClient: Client) =>
+    async <
+        account extends SmartAccount | undefined,
+        const calls extends readonly unknown[],
+        const request extends PrepareUserOperationRequest<
+            account,
+            accountOverride,
+            calls
+        >,
+        accountOverride extends SmartAccount | undefined = undefined
+    >(
+        client: Client<Transport, Chain | undefined, account>,
+        parameters_: PrepareUserOperationParameters<
+            account,
+            accountOverride,
+            calls,
+            request
+        >
+    ): Promise<
+        PrepareUserOperationReturnType<account, accountOverride, calls, request>
+    > => {
+        const parameters = parameters_ as PrepareUserOperationParameters
+        const account_ = client.account
+
+        if (!account_) throw new Error("Account not found")
+        const account = parseAccount(account_)
+
+        const bundlerClient = client as unknown as BundlerClient
+
+        const paymasterContext = parameters.paymasterContext
+            ? parameters.paymasterContext
+            : bundlerClient?.paymasterContext
+
+        if (
+            typeof paymasterContext === "object" &&
+            paymasterContext !== null &&
+            "token" in paymasterContext &&
+            typeof paymasterContext.token === "string"
+        ) {
+            ////////////////////////////////////////////////////////////////////////////////
+            // Inject custom approval before calling prepareUserOperation
+            ////////////////////////////////////////////////////////////////////////////////
+
+            const token = getAddress(paymasterContext.token)
+
+            let chainId: number | undefined
+            async function getChainId(): Promise<number> {
+                if (chainId) return chainId
+                if (client.chain) return client.chain.id
+                const chainId_ = await getAction(
+                    client,
+                    getChainId_,
+                    "getChainId"
+                )({})
+                chainId = chainId_
+                return chainId
+            }
+
+            const quotes = await getAction(
+                pimlicoClient,
+                getTokenQuotes,
+                "getTokenQuotes"
+            )({
+                tokens: [token],
+                chain:
+                    pimlicoClient.chain ?? client.chain ?? account.client.chain,
+                entryPointAddress: account.entryPoint.address
+            })
+
+            const {
+                postOpGas,
+                exchangeRate,
+                paymaster: paymasterERC20Address
+            } = quotes[0]
+
+            const callsWithDummyApproval = [
+                {
+                    abi: erc20Abi,
+                    functionName: "approve",
+                    args: [paymasterERC20Address, maxUint256], // dummy approval to ensure simulation passes
+                    to: paymasterContext.token
+                },
+                ...(parameters.calls ? parameters.calls : [])
+            ]
+
+            if (parameters.callData) {
+                throw new Error(
+                    "parameter callData is not supported with prepareUserOperationForErc20Paymaster"
+                )
+            }
+
+            ////////////////////////////////////////////////////////////////////////////////
+            // Call prepareUserOperation
+            ////////////////////////////////////////////////////////////////////////////////
+
+            const userOperation = await getAction(
+                client,
+                prepareUserOperation,
+                "prepareUserOperation"
+            )({
+                ...parameters,
+                calls: callsWithDummyApproval
+            } as unknown as PrepareUserOperationParameters)
+
+            ////////////////////////////////////////////////////////////////////////////////
+            // Call pimlico_getTokenQuotes and calculate the approval amount needed for op
+            ////////////////////////////////////////////////////////////////////////////////
+
+            const maxFeePerGas = userOperation.maxFeePerGas
+
+            const userOperationMaxGas =
+                userOperation.preVerificationGas +
+                userOperation.callGasLimit +
+                userOperation.verificationGasLimit +
+                (userOperation.paymasterPostOpGasLimit || 0n) +
+                (userOperation.paymasterVerificationGasLimit || 0n)
+
+            const userOperationMaxCost = userOperationMaxGas * maxFeePerGas
+
+            // using formula here https://github.com/pimlicolabs/singleton-paymaster/blob/main/src/base/BaseSingletonPaymaster.sol#L334-L341
+            const maxCostInToken =
+                ((userOperationMaxCost + postOpGas * maxFeePerGas) *
+                    exchangeRate) /
+                BigInt(1e18)
+
+            ////////////////////////////////////////////////////////////////////////////////
+            // Check if we need to approve the token
+            // If the user has existing approval that is sufficient, skip approval injection
+            ////////////////////////////////////////////////////////////////////////////////
+
+            const publicClient = account.client
+
+            const allowance = await getAction(
+                publicClient,
+                readContract,
+                "readContract"
+            )({
+                abi: erc20Abi,
+                functionName: "allowance",
+                args: [account.address, paymasterERC20Address],
+                address: token
+            })
+
+            const hasSufficientApproval = allowance >= maxCostInToken
+
+            const finalCalls = hasSufficientApproval
+                ? parameters.calls
+                : [
+                      {
+                          abi: erc20Abi,
+                          functionName: "approve",
+                          args: [paymasterERC20Address, maxCostInToken],
+                          to: paymasterContext.token
+                      },
+                      ...parameters.calls
+                  ]
+
+            userOperation.callData = await account.encodeCalls(
+                finalCalls.map((call_) => {
+                    const call = call_ as
+                        | UserOperationCall
+                        | (ContractFunctionParameters & {
+                              to: Address
+                              value: bigint
+                          })
+                    if ("abi" in call)
+                        return {
+                            data: encodeFunctionData(call),
+                            to: call.to,
+                            value: call.value
+                        } as UserOperationCall
+                    return call as UserOperationCall
+                })
+            )
+            parameters.calls = finalCalls
+
+            ////////////////////////////////////////////////////////////////////////////////
+            // Declare Paymaster properties. (taken from viem)
+            ////////////////////////////////////////////////////////////////////////////////
+
+            const paymaster = parameters.paymaster ?? bundlerClient?.paymaster
+            const { getPaymasterData } = (() => {
+                // If `paymaster: true`, we will assume the Bundler Client supports Paymaster Actions.
+                if (paymaster === true)
+                    return {
+                        getPaymasterData: (parameters: any) =>
+                            getAction(
+                                bundlerClient,
+                                getPaymasterData_,
+                                "getPaymasterData"
+                            )(parameters)
+                    }
+
+                // If Actions are passed to `paymaster` (via Paymaster Client or directly), we will use them.
+                if (
+                    typeof paymaster === "object" &&
+                    paymaster.getPaymasterData
+                ) {
+                    const { getPaymasterData } = paymaster
+                    return {
+                        getPaymasterData
+                    }
+                }
+
+                throw new Error(
+                    "Expected paymaster: cannot sponsor ERC-20 without paymaster"
+                )
+            })()
+
+            ////////////////////////////////////////////////////////////////////////////////
+            // Re-calculate Paymaster data fields.
+            ////////////////////////////////////////////////////////////////////////////////
+
+            const paymasterData = await getPaymasterData({
+                chainId: await getChainId(),
+                entryPointAddress: account.entryPoint.address,
+                context: paymasterContext,
+                ...(userOperation as UserOperation)
+            })
+
+            return {
+                ...userOperation,
+                ...paymasterData
+            } as unknown as PrepareUserOperationReturnType<
+                account,
+                accountOverride,
+                calls,
+                request
+            >
+        }
+
+        return (await getAction(
+            client,
+            prepareUserOperation,
+            "prepareUserOperation"
+        )(parameters)) as unknown as PrepareUserOperationReturnType<
+            account,
+            accountOverride,
+            calls,
+            request
+        >
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "permissionless",
-    "version": "0.2.4",
+    "version": "0.2.6",
     "author": "Pimlico",
     "homepage": "https://docs.pimlico.io/permissionless",
     "repository": "github:pimlicolabs/permissionless.js",
@@ -64,13 +64,13 @@
             "import": "./_esm/errors/index.js",
             "default": "./_cjs/errors/index.js"
         },
-        "./experimental": {
-            "types": "./_types/experimental/index.d.ts",
-            "import": "./_esm/experimental/index.js",
-            "default": "./_cjs/experimental/index.js"
+        "./experimental/pimlico": {
+            "types": "./_types/experimental/pimlico/index.d.ts",
+            "import": "./_esm/experimental/pimlico/index.js",
+            "default": "./_cjs/experimental/pimlico/index.js"
         }
     },
     "peerDependencies": {
-        "viem": "^2.20.0"
+        "viem": "^2.21.2"
     }
 }