permissionless 0.0.11 → 0.0.13

package/accounts/signerToSimpleSmartAccount.ts

@@ -0,0 +1,267 @@
+import {
+    type Account,
+    type Address,
+    type Chain,
+    type Client,
+    type Hex,
+    type Transport,
+    concatHex,
+    encodeFunctionData
+} from "viem"
+import { toAccount } from "viem/accounts"
+import {
+    getBytecode,
+    getChainId,
+    signMessage,
+    signTypedData
+} from "viem/actions"
+import { getAccountNonce } from "../actions/public/getAccountNonce.js"
+import { getSenderAddress } from "../actions/public/getSenderAddress.js"
+import { getUserOperationHash } from "../utils/getUserOperationHash.js"
+import {
+    SignTransactionNotSupportedBySmartAccount,
+    type SmartAccount,
+    type SmartAccountSigner
+} from "./types.js"
+
+export type SimpleSmartAccount<
+    transport extends Transport = Transport,
+    chain extends Chain | undefined = Chain | undefined
+> = SmartAccount<"SimpleSmartAccount", 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,
+    index = 0n
+}: {
+    client: Client<TTransport, TChain>
+    factoryAddress: Address
+    owner: Address
+    entryPoint: Address
+    index?: bigint
+}): Promise<Address> => {
+    const initCode = await getAccountInitCode(factoryAddress, owner, index)
+
+    return getSenderAddress(client, {
+        initCode,
+        entryPoint
+    })
+}
+
+/**
+ * @description Creates an Simple Account from a private key.
+ *
+ * @returns A Private Key Simple Account.
+ */
+export async function signerToSimpleSmartAccount<
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>(
+    client: Client<TTransport, TChain>,
+    {
+        signer,
+        factoryAddress,
+        entryPoint,
+        index = 0n
+    }: {
+        signer: SmartAccountSigner
+        factoryAddress: Address
+        entryPoint: Address
+        index?: bigint
+    }
+): Promise<SimpleSmartAccount<TTransport, TChain>> {
+    const viemSigner: Account =
+        signer.type === "local"
+            ? ({
+                  ...signer,
+                  signTransaction: (_, __) => {
+                      throw new SignTransactionNotSupportedBySmartAccount()
+                  }
+              } as Account)
+            : (signer as Account)
+
+    const [accountAddress, chainId] = await Promise.all([
+        getAccountAddress<TTransport, TChain>({
+            client,
+            factoryAddress,
+            entryPoint,
+            owner: viemSigner.address,
+            index
+        }),
+        getChainId(client)
+    ])
+
+    if (!accountAddress) throw new Error("Account address not found")
+
+    const account = toAccount({
+        address: accountAddress,
+        async signMessage({ message }) {
+            return signMessage(client, { account: viemSigner, message })
+        },
+        async signTransaction(_, __) {
+            throw new SignTransactionNotSupportedBySmartAccount()
+        },
+        async signTypedData(typedData) {
+            return signTypedData(client, { account: viemSigner, ...typedData })
+        }
+    })
+
+    return {
+        ...account,
+        client: client,
+        publicKey: accountAddress,
+        entryPoint: entryPoint,
+        source: "SimpleSmartAccount",
+        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, viemSigner.address, index)
+        },
+        async encodeDeployCallData(_) {
+            throw new Error("Simple account doesn't support account deployment")
+        },
+        async encodeCallData(args) {
+            if (Array.isArray(args)) {
+                const argsArray = args as {
+                    to: Address
+                    value: bigint
+                    data: Hex
+                }[]
+                return encodeFunctionData({
+                    abi: [
+                        {
+                            inputs: [
+                                {
+                                    internalType: "address[]",
+                                    name: "dest",
+                                    type: "address[]"
+                                },
+                                {
+                                    internalType: "bytes[]",
+                                    name: "func",
+                                    type: "bytes[]"
+                                }
+                            ],
+                            name: "executeBatch",
+                            outputs: [],
+                            stateMutability: "nonpayable",
+                            type: "function"
+                        }
+                    ],
+                    functionName: "executeBatch",
+                    args: [
+                        argsArray.map((a) => a.to),
+                        argsArray.map((a) => a.data)
+                    ]
+                })
+            }
+
+            const { to, value, data } = args as {
+                to: Address
+                value: bigint
+                data: Hex
+            }
+
+            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"
+        }
+    }
+}

package/accounts/types.ts

@@ -0,0 +1,64 @@
+import {
+    type Abi,
+    type Account,
+    type Address,
+    BaseError,
+    type Client,
+    type GetConstructorArgs,
+    type Hex,
+    type LocalAccount
+} from "viem"
+import type { Chain, Transport } from "viem"
+import { type UserOperation } from "../types/index.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 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: (
+        args:
+            | {
+                  to: Address
+                  value: bigint
+                  data: Hex
+              }
+            | {
+                  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>
+}
+
+export type SmartAccountSigner<TAddress extends Address = Address> = Omit<
+    Account<TAddress>,
+    "signTransaction"
+>

package/actions/bundler/chainId.ts

@@ -1,4 +1,6 @@
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { Account, Chain, Client, Transport } from "viem"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
+import type { BundlerRpcSchema } from "../../types/bundler.js"
 
 /**
  * Returns the supported chain id by the bundler service
@@ -22,7 +24,13 @@ import type { BundlerClient } from "../../clients/bundler.js"
  * // Return 5n for Goerli
  *
  */
-export const chainId = async (client: BundlerClient) => {
+export const chainId = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>
+) => {
     return Number(
         await client.request({
             method: "eth_chainId",

package/actions/bundler/estimateUserOperationGas.ts

@@ -1,12 +1,16 @@
-import type { Address } from "viem"
+import type { Account, Address, Chain, Client, Transport } 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 { BundlerRpcSchema } from "../../types/bundler.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
 }
 
@@ -43,15 +47,22 @@ export type EstimateUserOperationGasReturnType = {
  * // Return {preVerificationGas: 43492n, verificationGasLimit: 59436n, callGasLimit: 9000n}
  *
  */
-export const estimateUserOperationGas = async (
-    client: BundlerClient,
+export const estimateUserOperationGas = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
     args: EstimateUserOperationGasParameters
 ): Promise<EstimateUserOperationGasReturnType> => {
     const { userOperation, entryPoint } = args
 
     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 {

package/actions/bundler/getUserOperationByHash.ts

@@ -1,5 +1,6 @@
-import type { Address, Hash } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { Account, Address, Chain, Client, Hash, Transport } from "viem"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
+import type { BundlerRpcSchema } from "../../types/bundler.js"
 import type { UserOperation } from "../../types/userOperation.js"
 
 export type GetUserOperationByHashParameters = {
@@ -36,8 +37,12 @@ export type GetUserOperationByHashReturnType = {
  * getUserOperationByHash(bundlerClient, {hash: userOpHash})
  *
  */
-export const getUserOperationByHash = async (
-    client: BundlerClient,
+export const getUserOperationByHash = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
     { hash }: GetUserOperationByHashParameters
 ): Promise<GetUserOperationByHashReturnType> => {
     const params: [Hash] = [hash]
@@ -49,7 +54,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: {

package/actions/bundler/getUserOperationReceipt.ts

@@ -1,5 +1,14 @@
-import type { Address, Hash, Hex } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
+import type {
+    Account,
+    Address,
+    Chain,
+    Client,
+    Hash,
+    Hex,
+    Transport
+} from "viem"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
+import type { BundlerRpcSchema } from "../../types/bundler.js"
 import type { TStatus } from "../../types/userOperation.js"
 import { transactionReceiptStatus } from "../../utils/deepHexlify.js"
 
@@ -62,8 +71,12 @@ export type GetUserOperationReceiptReturnType = {
  * getUserOperationReceipt(bundlerClient, {hash: userOpHash})
  *
  */
-export const getUserOperationReceipt = async (
-    client: BundlerClient,
+export const getUserOperationReceipt = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
     { hash }: GetUserOperationReceiptParameters
 ): Promise<GetUserOperationReceiptReturnType | null> => {
     const params: [Hash] = [hash]

package/actions/bundler/sendUserOperation.ts

@@ -1,6 +1,10 @@
-import type { Address, Hash } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
-import type { UserOperation, UserOperationWithBigIntAsHex } from "../../types/userOperation.js"
+import type { Account, Address, Chain, Client, Hash, Transport } from "viem"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
+import type { BundlerRpcSchema } from "../../types/bundler.js"
+import type {
+    UserOperation,
+    UserOperationWithBigIntAsHex
+} from "../../types/userOperation.js"
 import { deepHexlify } from "../../utils/deepHexlify.js"
 
 export type SendUserOperationParameters = {
@@ -17,7 +21,6 @@ export type SendUserOperationParameters = {
  * @param args {@link SendUserOperationParameters}.
  * @returns UserOpHash that you can use to track user operation as {@link Hash}.
  *
- *
  * @example
  * import { createClient } from "viem"
  * import { sendUserOperation } from "permissionless/actions"
@@ -33,13 +36,22 @@ export type SendUserOperationParameters = {
  * })
  *
  * // Return '0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34'
- *
  */
-export const sendUserOperation = async (client: BundlerClient, args: SendUserOperationParameters): Promise<Hash> => {
+export const sendUserOperation = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
+    args: SendUserOperationParameters
+): Promise<Hash> => {
     const { userOperation, entryPoint } = args
 
     return client.request({
         method: "eth_sendUserOperation",
-        params: [deepHexlify(userOperation) as UserOperationWithBigIntAsHex, entryPoint as Address]
+        params: [
+            deepHexlify(userOperation) as UserOperationWithBigIntAsHex,
+            entryPoint as Address
+        ]
     })
 }

package/actions/bundler/supportedEntryPoints.ts

@@ -1,5 +1,6 @@
-import type { Address } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
+import type { Account, Address, Chain, Client, Transport } from "viem"
+import type { BundlerClient } from "../../clients/createBundlerClient.js"
+import type { BundlerRpcSchema } from "../../types/bundler.js"
 
 /**
  * Returns the supported entrypoints by the bundler service
@@ -23,7 +24,13 @@ import type { BundlerClient } from "../../clients/bundler.js"
  * // Return ['0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789']
  *
  */
-export const supportedEntryPoints = async (client: BundlerClient): Promise<Address[]> => {
+export const supportedEntryPoints = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>
+): Promise<Address[]> => {
     return client.request({
         method: "eth_supportedEntryPoints",
         params: []

package/actions/bundler/waitForUserOperationReceipt.ts

@@ -1,12 +1,25 @@
-import { BaseError, type Chain, type Hash, stringify } from "viem"
-import type { BundlerClient } from "../../clients/bundler.js"
+import {
+    type Account,
+    BaseError,
+    type Chain,
+    type Client,
+    type Hash,
+    type Transport,
+    stringify
+} from "viem"
+import { getAction } from "../../utils/getAction.js"
 import { observe } from "../../utils/observe.js"
-import { type GetUserOperationReceiptReturnType, getUserOperationReceipt } from "./getUserOperationReceipt.js"
+import {
+    type GetUserOperationReceiptReturnType,
+    getUserOperationReceipt
+} from "./getUserOperationReceipt.js"
 
 export class WaitForUserOperationReceiptTimeoutError extends BaseError {
     override name = "WaitForUserOperationReceiptTimeoutError"
     constructor({ hash }: { hash: Hash }) {
-        super(`Timed out while waiting for transaction with hash "${hash}" to be confirmed.`)
+        super(
+            `Timed out while waiting for transaction with hash "${hash}" to be confirmed.`
+        )
     }
 }
 
@@ -43,38 +56,63 @@ export type WaitForUserOperationReceiptParameters = {
  *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
  * })
  */
-export const waitForUserOperationReceipt = <TChain extends Chain | undefined>(
-    bundlerClient: BundlerClient<TChain>,
-    { hash, pollingInterval = bundlerClient.pollingInterval, timeout }: WaitForUserOperationReceiptParameters
+export const waitForUserOperationReceipt = <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    bundlerClient: Client<TTransport, TChain, TAccount>,
+    {
+        hash,
+        pollingInterval = bundlerClient.pollingInterval,
+        timeout
+    }: WaitForUserOperationReceiptParameters
 ): Promise<GetUserOperationReceiptReturnType> => {
-    const observerId = stringify(["waitForUserOperationReceipt", bundlerClient.uid, hash])
+    const observerId = stringify([
+        "waitForUserOperationReceipt",
+        bundlerClient.uid,
+        hash
+    ])
 
     let userOperationReceipt: GetUserOperationReceiptReturnType
 
     return new Promise((resolve, reject) => {
         if (timeout) {
-            setTimeout(() => reject(new WaitForUserOperationReceiptTimeoutError({ hash })), timeout)
+            setTimeout(
+                () =>
+                    reject(
+                        new WaitForUserOperationReceiptTimeoutError({ hash })
+                    ),
+                timeout
+            )
         }
 
-        const _unobserve = observe(observerId, { resolve, reject }, async (emit) => {
-            const _removeInterval = setInterval(async () => {
-                const done = (fn: () => void) => {
-                    clearInterval(_removeInterval)
-                    fn()
-                    _unobserve()
-                }
+        const _unobserve = observe(
+            observerId,
+            { resolve, reject },
+            async (emit) => {
+                const _removeInterval = setInterval(async () => {
+                    const done = (fn: () => void) => {
+                        clearInterval(_removeInterval)
+                        fn()
+                        _unobserve()
+                    }
 
-                const _userOperationReceipt = await getUserOperationReceipt(bundlerClient, { hash })
+                    const _userOperationReceipt = await getAction(
+                        bundlerClient,
+                        getUserOperationReceipt
+                    )({ hash })
 
-                if (_userOperationReceipt !== null) {
-                    userOperationReceipt = _userOperationReceipt
-                }
+                    if (_userOperationReceipt !== null) {
+                        userOperationReceipt = _userOperationReceipt
+                    }
 
-                if (userOperationReceipt) {
-                    done(() => emit.resolve(userOperationReceipt))
-                    return
-                }
-            }, pollingInterval)
-        })
+                    if (userOperationReceipt) {
+                        done(() => emit.resolve(userOperationReceipt))
+                        return
+                    }
+                }, pollingInterval)
+            }
+        )
     })
 }

package/actions/index.ts

@@ -11,7 +11,10 @@ import type {
 import type { SendUserOperationParameters } from "./bundler/sendUserOperation.js"
 
 import type { GetSenderAddressParams } from "./public/getSenderAddress.js"
-import { InvalidEntryPointError, getSenderAddress } from "./public/getSenderAddress.js"
+import {
+    InvalidEntryPointError,
+    getSenderAddress
+} from "./public/getSenderAddress.js"
 
 import { chainId } from "./bundler/chainId.js"
 import { estimateUserOperationGas } from "./bundler/estimateUserOperationGas.js"