permissionless 0.2.5 → 0.2.7

package/accounts/biconomy/toBiconomySmartAccount.ts

@@ -15,6 +15,10 @@ import {
     type LocalAccount,
     encodeAbiParameters,
     encodeFunctionData,
+    encodePacked,
+    getContractAddress,
+    hexToBigInt,
+    keccak256,
     parseAbiParameters
 } from "viem"
 import {
@@ -27,10 +31,12 @@ import {
 } from "viem/account-abstraction"
 import { signMessage } from "viem/actions"
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
-import { getSenderAddress } from "../../actions/public/getSenderAddress"
 import { toOwner } from "../../utils/toOwner"
 import { BiconomyAbi, FactoryAbi } from "./abi/BiconomySmartAccountAbi"
 
+const BICONOMY_PROXY_CREATION_CODE =
+    "0x6080346100aa57601f61012038819003918201601f19168301916001600160401b038311848410176100af578084926020946040528339810103126100aa57516001600160a01b0381168082036100aa5715610065573055604051605a90816100c68239f35b60405162461bcd60e51b815260206004820152601e60248201527f496e76616c696420696d706c656d656e746174696f6e206164647265737300006044820152606490fd5b600080fd5b634e487b7160e01b600052604160045260246000fdfe608060405230546000808092368280378136915af43d82803e156020573d90f35b3d90fdfea2646970667358221220a03b18dce0be0b4c9afe58a9eb85c35205e2cf087da098bbf1d23945bf89496064736f6c63430008110033"
+
 /**
  * The account creation ABI for Biconomy Smart Account (from the biconomy SmartAccountFactory)
  */
@@ -41,10 +47,15 @@ import { BiconomyAbi, FactoryAbi } from "./abi/BiconomySmartAccountAbi"
 const BICONOMY_ADDRESSES: {
     ECDSA_OWNERSHIP_REGISTRY_MODULE: Address
     FACTORY_ADDRESS: Address
+    ACCOUNT_V2_0_LOGIC: Address
+    DEFAULT_FALLBACK_HANDLER_ADDRESS: Address
 } = {
     ECDSA_OWNERSHIP_REGISTRY_MODULE:
         "0x0000001c5b32F37F5beA87BDD5374eB2aC54eA8e",
-    FACTORY_ADDRESS: "0x000000a56Aaca3e9a4C479ea6b6CD0DbcB6634F5"
+    FACTORY_ADDRESS: "0x000000a56Aaca3e9a4C479ea6b6CD0DbcB6634F5",
+    ACCOUNT_V2_0_LOGIC: "0x0000002512019Dafb59528B82CB92D3c5D2423aC",
+    DEFAULT_FALLBACK_HANDLER_ADDRESS:
+        "0x0bBa6d96BD616BedC6BFaa341742FD43c60b83C1"
 }
 
 /**
@@ -98,6 +109,8 @@ export type ToBiconomySmartAccountParameters = Prettify<{
     index?: bigint
     factoryAddress?: Address
     ecdsaModuleAddress?: Address
+    accountLogicAddress?: Address
+    fallbackHandlerAddress?: Address
 }>
 
 export type BiconomySmartAccountImplementation = Assign<
@@ -109,6 +122,59 @@ export type ToBiconomySmartAccountReturnType = Prettify<
     SmartAccount<BiconomySmartAccountImplementation>
 >
 
+const getAccountAddress = async ({
+    factoryAddress,
+    accountLogicAddress,
+    fallbackHandlerAddress,
+    ecdsaModuleAddress,
+    owner,
+    index = BigInt(0)
+}: {
+    factoryAddress: Address
+    accountLogicAddress: Address
+    fallbackHandlerAddress: Address
+    ecdsaModuleAddress: Address
+    owner: Address
+    index?: bigint
+}): Promise<Address> => {
+    // Build the module setup data
+    const ecdsaOwnershipInitData = encodeFunctionData({
+        abi: BiconomyAbi,
+        functionName: "initForSmartAccount",
+        args: [owner]
+    })
+
+    // Build account init code
+    const initialisationData = encodeFunctionData({
+        abi: BiconomyAbi,
+        functionName: "init",
+        args: [
+            fallbackHandlerAddress,
+            ecdsaModuleAddress,
+            ecdsaOwnershipInitData
+        ]
+    })
+
+    const deploymentCode = encodePacked(
+        ["bytes", "uint256"],
+        [BICONOMY_PROXY_CREATION_CODE, hexToBigInt(accountLogicAddress)]
+    )
+
+    const salt = keccak256(
+        encodePacked(
+            ["bytes32", "uint256"],
+            [keccak256(encodePacked(["bytes"], [initialisationData])), index]
+        )
+    )
+
+    return getContractAddress({
+        from: factoryAddress,
+        salt,
+        bytecode: deploymentCode,
+        opcode: "CREATE2"
+    })
+}
+
 /**
  * Build a Biconomy modular smart account from a private key, that use the ECDSA signer behind the scene
  * @param client
@@ -122,7 +188,16 @@ export type ToBiconomySmartAccountReturnType = Prettify<
 export async function toBiconomySmartAccount(
     parameters: ToBiconomySmartAccountParameters
 ): Promise<ToBiconomySmartAccountReturnType> {
-    const { owners, client, index = 0n, address } = parameters
+    const {
+        owners,
+        client,
+        index = 0n,
+        address,
+        accountLogicAddress = BICONOMY_ADDRESSES.ACCOUNT_V2_0_LOGIC,
+        fallbackHandlerAddress = BICONOMY_ADDRESSES.DEFAULT_FALLBACK_HANDLER_ADDRESS,
+        ecdsaModuleAddress = BICONOMY_ADDRESSES.ECDSA_OWNERSHIP_REGISTRY_MODULE,
+        factoryAddress = BICONOMY_ADDRESSES.FACTORY_ADDRESS
+    } = parameters
 
     const localOwner = await toOwner({ owner: owners[0] })
 
@@ -132,15 +207,8 @@ export async function toBiconomySmartAccount(
         version: parameters.entryPoint?.version ?? "0.6"
     }
 
-    const factoryAddress =
-        parameters.factoryAddress ?? BICONOMY_ADDRESSES.FACTORY_ADDRESS
-
     let accountAddress: Address | undefined = address
 
-    const ecdsaModuleAddress =
-        parameters.ecdsaModuleAddress ??
-        BICONOMY_ADDRESSES.ECDSA_OWNERSHIP_REGISTRY_MODULE
-
     const getFactoryArgs = async () => {
         return {
             factory: factoryAddress,
@@ -159,13 +227,14 @@ export async function toBiconomySmartAccount(
         async getAddress() {
             if (accountAddress) return accountAddress
 
-            const { factory, factoryData } = await getFactoryArgs()
-
             // Get the sender address based on the init code
-            accountAddress = await getSenderAddress(client, {
-                factory,
-                factoryData,
-                entryPointAddress: entryPoint.address
+            accountAddress = await getAccountAddress({
+                owner: localOwner.address,
+                ecdsaModuleAddress,
+                factoryAddress,
+                accountLogicAddress,
+                fallbackHandlerAddress,
+                index
             })
 
             return accountAddress

package/accounts/safe/toSafeSmartAccount.ts

@@ -951,7 +951,6 @@ export type ToSafeSmartAccountParameters<
         version: entryPointVersion
     }
     safe4337ModuleAddress?: Address
-    erc7569LaunchpadAddress?: Address
     erc7579LaunchpadAddress?: TErc7579
     safeProxyFactoryAddress?: Address
     safeSingletonAddress?: Address

package/actions/smartAccount/sendTransaction.test.ts

@@ -74,6 +74,8 @@ describe.each(getCoreSmartAccounts())(
                     entryPoint: {
                         version: "0.7"
                     },
+                    privateKey:
+                        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // anvil private key
                     ...rpc
                 })
 
@@ -114,5 +116,132 @@ describe.each(getCoreSmartAccounts())(
                 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:
+                            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // 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:
+                        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // 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 smartClient = await getSmartAccountClient({
+                        entryPoint: {
+                            version: "0.7"
+                        },
+                        ...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.7"
+                    },
+                    privateKey:
+                        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", // 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/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,17 +139,43 @@ export function createSmartAccountClient(
         userOperation
     } = parameters
 
-    const client = createBundlerClient({
-        ...parameters,
-        client: client_,
-        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
+            }
+        )
+    }
+)