permissionless 0.0.12 → 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

@@ -1,14 +1,32 @@
-import type {
-    Abi,
-    Address,
-    Client,
-    GetConstructorArgs,
-    Hex,
-    LocalAccount
+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,
@@ -18,11 +36,19 @@ export type SmartAccount<
     entryPoint: Address
     getNonce: () => Promise<bigint>
     getInitCode: () => Promise<Hex>
-    encodeCallData: ({
-        to,
-        value,
-        data
-    }: { to: Address; value: bigint; data: Hex }) => 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,
@@ -31,3 +57,8 @@ export type SmartAccount<
     }: { 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 { 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/createBundlerClient.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,6 +1,7 @@
-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/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"
@@ -46,8 +47,12 @@ 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

package/actions/bundler/getUserOperationByHash.ts

@@ -1,5 +1,6 @@
-import type { Address, Hash } from "viem"
+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]

package/actions/bundler/getUserOperationReceipt.ts

@@ -1,5 +1,14 @@
-import type { Address, Hash, Hex } from "viem"
+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,5 +1,6 @@
-import type { Address, Hash } from "viem"
+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
@@ -36,8 +37,12 @@ export type SendUserOperationParameters = {
  *
  * // Return '0xe9fad2cd67f9ca1d0b7a6513b2a42066784c8df938518da2b51bb8cc9a89ea34'
  */
-export const sendUserOperation = async (
-    client: BundlerClient,
+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

package/actions/bundler/supportedEntryPoints.ts

@@ -1,5 +1,6 @@
-import type { Address } from "viem"
+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,8 +24,12 @@ import type { BundlerClient } from "../../clients/createBundlerClient.js"
  * // Return ['0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789']
  *
  */
-export const supportedEntryPoints = async (
-    client: BundlerClient
+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",

package/actions/bundler/waitForUserOperationReceipt.ts

@@ -1,5 +1,12 @@
-import { BaseError, type Chain, type Hash, stringify } from "viem"
-import type { BundlerClient } from "../../clients/createBundlerClient.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 {
@@ -49,8 +56,12 @@ export type WaitForUserOperationReceiptParameters = {
  *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
  * })
  */
-export const waitForUserOperationReceipt = <TChain extends Chain | undefined>(
-    bundlerClient: BundlerClient<TChain>,
+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,

package/actions/pimlico/getUserOperationGasPrice.ts

@@ -31,7 +31,7 @@ export type GetUserOperationGasPriceReturnType = {
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
  * })
  *
  * await getUserOperationGasPrice(bundlerClient)

package/actions/pimlico/getUserOperationStatus.ts

@@ -27,7 +27,7 @@ export type GetUserOperationStatusReturnType = PimlicoUserOperationStatus
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
+ *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
  * })
  *
  * await getUserOperationStatus(bundlerClient, { hash: userOpHash })

package/actions/smartAccount/prepareUserOperationRequest.ts

@@ -121,7 +121,9 @@ export async function prepareUserOperationRequest<
             client,
             estimateUserOperationGas
         )({
-            userOperation,
+            userOperation: {
+                ...userOperation
+            },
             entryPoint: account.entryPoint
         })
 

package/actions/smartAccount/sendTransaction.ts

@@ -87,6 +87,7 @@ export async function sendTransaction<
         maxPriorityFeePerGas,
         to,
         value,
+        nonce,
         sponsorUserOperation
     } = args
 
@@ -119,7 +120,8 @@ export async function sendTransaction<
             paymasterAndData: "0x",
             maxFeePerGas: maxFeePerGas || 0n,
             maxPriorityFeePerGas: maxPriorityFeePerGas || 0n,
-            callData: callData
+            callData: callData,
+            nonce: nonce ? BigInt(nonce) : undefined
         },
         account: account,
         sponsorUserOperation