Merge pull request #31 from pimlicolabs/feat/account-system

Create simple account client

.changeset/fluffy-dolls-mate.md

@@ -0,0 +1,5 @@
+---
+"permissionless": patch
+---
+
+Added support for SimpleAccount management

biome.json

@@ -32,8 +32,8 @@
     "formatter": {
         "enabled": true,
         "formatWithErrors": true,
-        "lineWidth": 120,
-        "indentSize": 4,
+        "lineWidth": 80,
+        "indentWidth": 4,
         "indentStyle": "space"
     },
     "javascript": {

package.json

@@ -11,7 +11,7 @@
         "@changesets/cli": "^2.26.2",
         "@size-limit/esbuild-why": "^9.0.0",
         "@size-limit/preset-small-lib": "^9.0.0",
-        "bun-types": "^1.0.3",
+        "bun-types": "^1.0.7",
         "rimraf": "^5.0.1",
         "simple-git-hooks": "^2.9.0",
         "size-limit": "^9.0.0",

src/accounts/index.ts

@@ -0,0 +1,14 @@
+import {
+    type PrivateKeySimpleSmartAccount,
+    SignTransactionNotSupportedBySmartAccount,
+    privateKeyToSimpleSmartAccount
+} from "./privateKeyToSimpleSmartAccount.js"
+
+import { type SmartAccount } from "./types.js"
+
+export {
+    SignTransactionNotSupportedBySmartAccount,
+    type PrivateKeySimpleSmartAccount,
+    privateKeyToSimpleSmartAccount,
+    type SmartAccount
+}

src/accounts/privateKeyToSimpleSmartAccount.ts

@@ -0,0 +1,220 @@
+import {
+    type Address,
+    BaseError,
+    type Chain,
+    type Client,
+    type Hex,
+    type Transport,
+    concatHex,
+    encodeFunctionData
+} from "viem"
+import { privateKeyToAccount, toAccount } from "viem/accounts"
+import { getBytecode, getChainId } from "viem/actions"
+import { getAccountNonce } from "../actions/public/getAccountNonce.js"
+import { getSenderAddress } from "../actions/public/getSenderAddress.js"
+import { getUserOperationHash } from "../utils/getUserOperationHash.js"
+import { type SmartAccount } from "./types.js"
+
+export class SignTransactionNotSupportedBySmartAccount extends BaseError {
+    override name = "SignTransactionNotSupportedBySmartAccount"
+    constructor({ docsPath }: { docsPath?: string } = {}) {
+        super(
+            [
+                "A smart account cannot sign or send transaction, it can only sign message or userOperation.",
+                "Please send user operation instead."
+            ].join("\n"),
+            {
+                docsPath,
+                docsSlug: "account"
+            }
+        )
+    }
+}
+
+export type PrivateKeySimpleSmartAccount<
+    transport extends Transport = Transport,
+    chain extends Chain | undefined = Chain | undefined
+> = SmartAccount<"privateKeySimpleSmartAccount", transport, chain>
+
+const getAccountInitCode = async (
+    factoryAddress: Address,
+    owner: Address,
+    index = 0n
+): Promise<Hex> => {
+    if (!owner) throw new Error("Owner account not found")
+
+    return concatHex([
+        factoryAddress,
+        encodeFunctionData({
+            abi: [
+                {
+                    inputs: [
+                        {
+                            internalType: "address",
+                            name: "owner",
+                            type: "address"
+                        },
+                        {
+                            internalType: "uint256",
+                            name: "salt",
+                            type: "uint256"
+                        }
+                    ],
+                    name: "createAccount",
+                    outputs: [
+                        {
+                            internalType: "contract SimpleAccount",
+                            name: "ret",
+                            type: "address"
+                        }
+                    ],
+                    stateMutability: "nonpayable",
+                    type: "function"
+                }
+            ],
+            functionName: "createAccount",
+            args: [owner, index]
+        }) as Hex
+    ])
+}
+
+const getAccountAddress = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>({
+    client,
+    factoryAddress,
+    entryPoint,
+    owner
+}: {
+    client: Client<TTransport, TChain>
+    factoryAddress: Address
+    owner: Address
+    entryPoint: Address
+}): Promise<Address> => {
+    const initCode = await getAccountInitCode(factoryAddress, owner)
+
+    return getSenderAddress(client, {
+        initCode,
+        entryPoint
+    })
+}
+
+/**
+ * @description Creates an Simple Account from a private key.
+ *
+ * @returns A Private Key Simple Account.
+ */
+export async function privateKeyToSimpleSmartAccount<
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>(
+    client: Client<TTransport, TChain>,
+    {
+        privateKey,
+        factoryAddress,
+        entryPoint
+    }: {
+        privateKey: Hex
+        factoryAddress: Address
+        entryPoint: Address
+    }
+): Promise<PrivateKeySimpleSmartAccount<TTransport, TChain>> {
+    const privateKeyAccount = privateKeyToAccount(privateKey)
+
+    const [accountAddress, chainId] = await Promise.all([
+        getAccountAddress<TTransport, TChain>({
+            client,
+            factoryAddress,
+            entryPoint,
+            owner: privateKeyAccount.address
+        }),
+        getChainId(client)
+    ])
+
+    if (!accountAddress) throw new Error("Account address not found")
+
+    const account = toAccount({
+        address: accountAddress,
+        async signMessage({ message }) {
+            return privateKeyAccount.signMessage({ message })
+        },
+        async signTransaction(_, __) {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        },
+        async signTypedData(typedData) {
+            return privateKeyAccount.signTypedData({ ...typedData, privateKey })
+        }
+    })
+
+    return {
+        ...account,
+        client: client,
+        publicKey: accountAddress,
+        entryPoint: entryPoint,
+        source: "privateKeySimpleSmartAccount",
+        async getNonce() {
+            return getAccountNonce(client, {
+                sender: accountAddress,
+                entryPoint: entryPoint
+            })
+        },
+        async signUserOperation(userOperation) {
+            return account.signMessage({
+                message: {
+                    raw: getUserOperationHash({
+                        userOperation,
+                        entryPoint: entryPoint,
+                        chainId: chainId
+                    })
+                }
+            })
+        },
+        async getInitCode() {
+            const contractCode = await getBytecode(client, {
+                address: accountAddress
+            })
+
+            if ((contractCode?.length ?? 0) > 2) return "0x"
+
+            return getAccountInitCode(factoryAddress, privateKeyAccount.address)
+        },
+        async encodeDeployCallData(_) {
+            throw new Error("Simple account doesn't support account deployment")
+        },
+        async encodeCallData({ to, value, data }) {
+            return encodeFunctionData({
+                abi: [
+                    {
+                        inputs: [
+                            {
+                                internalType: "address",
+                                name: "dest",
+                                type: "address"
+                            },
+                            {
+                                internalType: "uint256",
+                                name: "value",
+                                type: "uint256"
+                            },
+                            {
+                                internalType: "bytes",
+                                name: "func",
+                                type: "bytes"
+                            }
+                        ],
+                        name: "execute",
+                        outputs: [],
+                        stateMutability: "nonpayable",
+                        type: "function"
+                    }
+                ],
+                functionName: "execute",
+                args: [to, value, data]
+            })
+        },
+        async getDummySignature() {
+            return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
+        }
+    }
+}

src/accounts/types.ts

@@ -0,0 +1,33 @@
+import type {
+    Abi,
+    Address,
+    Client,
+    GetConstructorArgs,
+    Hex,
+    LocalAccount
+} from "viem"
+import type { Chain, Transport } from "viem"
+import { type UserOperation } from "../types/index.js"
+
+export type SmartAccount<
+    Name extends string = string,
+    transport extends Transport = Transport,
+    chain extends Chain | undefined = Chain | undefined
+> = LocalAccount<Name> & {
+    client: Client<transport, chain>
+    entryPoint: Address
+    getNonce: () => Promise<bigint>
+    getInitCode: () => Promise<Hex>
+    encodeCallData: ({
+        to,
+        value,
+        data
+    }: { to: Address; value: bigint; data: Hex }) => Promise<Hex>
+    getDummySignature(): Promise<Hex>
+    encodeDeployCallData: <TAbi extends Abi | readonly unknown[] = Abi>({
+        abi,
+        args,
+        bytecode
+    }: { abi: TAbi; bytecode: Hex } & GetConstructorArgs<TAbi>) => Promise<Hex>
+    signUserOperation: (UserOperation: UserOperation) => Promise<Hex>
+}

src/actions/bundler/chainId.ts

@@ -1,4 +1,4 @@
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
 
 /**
  * Returns the supported chain id by the bundler service

src/actions/bundler/estimateUserOperationGas.ts

@@ -1,12 +1,15 @@
 import type { Address } from "viem"
 import type { PartialBy } from "viem/types/utils"
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
 import type { UserOperation } from "../../types/userOperation.js"
 import type { UserOperationWithBigIntAsHex } from "../../types/userOperation.js"
 import { deepHexlify } from "../../utils/deepHexlify.js"
 
 export type EstimateUserOperationGasParameters = {
-    userOperation: PartialBy<UserOperation, "callGasLimit" | "preVerificationGas" | "verificationGasLimit">
+    userOperation: PartialBy<
+        UserOperation,
+        "callGasLimit" | "preVerificationGas" | "verificationGasLimit"
+    >
     entryPoint: Address
 }
 
@@ -51,7 +54,10 @@ export const estimateUserOperationGas = async (
 
     const response = await client.request({
         method: "eth_estimateUserOperationGas",
-        params: [deepHexlify(userOperation) as UserOperationWithBigIntAsHex, entryPoint as Address]
+        params: [
+            deepHexlify(userOperation) as UserOperationWithBigIntAsHex,
+            entryPoint as Address
+        ]
     })
 
     return {

src/actions/bundler/getUserOperationByHash.ts

@@ -1,5 +1,5 @@
 import type { Address, Hash } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
 import type { UserOperation } from "../../types/userOperation.js"
 
 export type GetUserOperationByHashParameters = {
@@ -49,7 +49,13 @@ export const getUserOperationByHash = async (
 
     if (!response) return null
 
-    const { userOperation, entryPoint, transactionHash, blockHash, blockNumber } = response
+    const {
+        userOperation,
+        entryPoint,
+        transactionHash,
+        blockHash,
+        blockNumber
+    } = response
 
     return {
         userOperation: {

src/actions/bundler/getUserOperationReceipt.ts

@@ -1,5 +1,5 @@
 import type { Address, Hash, Hex } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
 import type { TStatus } from "../../types/userOperation.js"
 import { transactionReceiptStatus } from "../../utils/deepHexlify.js"