permissionless 0.0.35 → 0.1.0

package/accounts/simple/signerToSimpleSmartAccount.ts

@@ -14,7 +14,13 @@ import { toAccount } from "viem/accounts"
 import { getChainId, signMessage, signTypedData } from "viem/actions"
 import { getAccountNonce } from "../../actions/public/getAccountNonce"
 import { getSenderAddress } from "../../actions/public/getSenderAddress"
-import type { Prettify } from "../../types"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    ENTRYPOINT_ADDRESS_V07_TYPE,
+    Prettify
+} from "../../types"
+import type { EntryPoint } from "../../types/entrypoint"
+import { getEntryPointVersion } from "../../utils"
 import { getUserOperationHash } from "../../utils/getUserOperationHash"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed"
 import {
@@ -24,83 +30,90 @@ import {
 } from "../types"
 
 export type SimpleSmartAccount<
+    entryPoint extends EntryPoint,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined
-> = SmartAccount<"SimpleSmartAccount", transport, chain>
+> = SmartAccount<entryPoint, "SimpleSmartAccount", transport, chain>
 
-const getAccountInitCode = async (
-    factoryAddress: Address,
-    owner: Address,
-    index = 0n
-): Promise<Hex> => {
+const getAccountInitCode = async (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
-    ])
+    return 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]
+    })
 }
 
 const getAccountAddress = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >({
     client,
     factoryAddress,
-    entryPoint,
+    entryPoint: entryPointAddress,
     owner,
     index = 0n
 }: {
     client: Client<TTransport, TChain>
     factoryAddress: Address
     owner: Address
-    entryPoint: Address
+    entryPoint: entryPoint
     index?: bigint
 }): Promise<Address> => {
-    const initCode = await getAccountInitCode(factoryAddress, owner, index)
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    const factoryData = await getAccountInitCode(owner, index)
 
-    return getSenderAddress(client, {
-        initCode,
-        entryPoint
+    if (entryPointVersion === "v0.6") {
+        return getSenderAddress<ENTRYPOINT_ADDRESS_V06_TYPE>(client, {
+            initCode: concatHex([factoryAddress, factoryData]),
+            entryPoint: entryPointAddress as ENTRYPOINT_ADDRESS_V06_TYPE
+        })
+    }
+
+    // Get the sender address based on the init code
+    return getSenderAddress<ENTRYPOINT_ADDRESS_V07_TYPE>(client, {
+        factory: factoryAddress,
+        factoryData,
+        entryPoint: entryPointAddress as ENTRYPOINT_ADDRESS_V07_TYPE
     })
 }
 
 export type SignerToSimpleSmartAccountParameters<
+    entryPoint extends EntryPoint,
     TSource extends string = "custom",
     TAddress extends Address = Address
 > = Prettify<{
     signer: SmartAccountSigner<TSource, TAddress>
     factoryAddress: Address
-    entryPoint: Address
+    entryPoint: entryPoint
     index?: bigint
     address?: Address
 }>
@@ -111,6 +124,7 @@ export type SignerToSimpleSmartAccountParameters<
  * @returns A Private Key Simple Account.
  */
 export async function signerToSimpleSmartAccount<
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TSource extends string = "custom",
@@ -120,11 +134,11 @@ export async function signerToSimpleSmartAccount<
     {
         signer,
         factoryAddress,
-        entryPoint,
+        entryPoint: entryPointAddress,
         index = 0n,
         address
-    }: SignerToSimpleSmartAccountParameters<TSource, TAddress>
-): Promise<SimpleSmartAccount<TTransport, TChain>> {
+    }: SignerToSimpleSmartAccountParameters<entryPoint, TSource, TAddress>
+): Promise<SimpleSmartAccount<entryPoint, TTransport, TChain>> {
     const viemSigner: LocalAccount = {
         ...signer,
         signTransaction: (_, __) => {
@@ -134,10 +148,10 @@ export async function signerToSimpleSmartAccount<
 
     const [accountAddress, chainId] = await Promise.all([
         address ??
-            getAccountAddress<TTransport, TChain>({
+            getAccountAddress<entryPoint, TTransport, TChain>({
                 client,
                 factoryAddress,
-                entryPoint,
+                entryPoint: entryPointAddress,
                 owner: viemSigner.address,
                 index
             }),
@@ -179,12 +193,12 @@ export async function signerToSimpleSmartAccount<
         ...account,
         client: client,
         publicKey: accountAddress,
-        entryPoint: entryPoint,
+        entryPoint: entryPointAddress,
         source: "SimpleSmartAccount",
         async getNonce() {
             return getAccountNonce(client, {
                 sender: accountAddress,
-                entryPoint: entryPoint
+                entryPoint: entryPointAddress
             })
         },
         async signUserOperation(userOperation) {
@@ -192,7 +206,7 @@ export async function signerToSimpleSmartAccount<
                 message: {
                     raw: getUserOperationHash({
                         userOperation,
-                        entryPoint: entryPoint,
+                        entryPoint: entryPointAddress,
                         chainId: chainId
                     })
                 }
@@ -208,7 +222,28 @@ export async function signerToSimpleSmartAccount<
 
             if (smartAccountDeployed) return "0x"
 
-            return getAccountInitCode(factoryAddress, viemSigner.address, index)
+            return concatHex([
+                factoryAddress,
+                await getAccountInitCode(viemSigner.address, index)
+            ])
+        },
+        async getFactory() {
+            if (smartAccountDeployed) return undefined
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+            if (smartAccountDeployed) return undefined
+            return factoryAddress
+        },
+        async getFactoryData() {
+            if (smartAccountDeployed) return undefined
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+            if (smartAccountDeployed) return undefined
+            return getAccountInitCode(viemSigner.address, index)
         },
         async encodeDeployCallData(_) {
             throw new Error("Simple account doesn't support account deployment")
@@ -220,6 +255,36 @@ export async function signerToSimpleSmartAccount<
                     value: bigint
                     data: Hex
                 }[]
+
+                if (getEntryPointVersion(entryPointAddress) === "v0.6") {
+                    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)
+                        ]
+                    })
+                }
                 return encodeFunctionData({
                     abi: [
                         {
@@ -229,6 +294,11 @@ export async function signerToSimpleSmartAccount<
                                     name: "dest",
                                     type: "address[]"
                                 },
+                                {
+                                    internalType: "uint256[]",
+                                    name: "value",
+                                    type: "uint256[]"
+                                },
                                 {
                                     internalType: "bytes[]",
                                     name: "func",
@@ -244,6 +314,7 @@ export async function signerToSimpleSmartAccount<
                     functionName: "executeBatch",
                     args: [
                         argsArray.map((a) => a.to),
+                        argsArray.map((a) => a.value),
                         argsArray.map((a) => a.data)
                     ]
                 })

package/accounts/types.ts

@@ -7,7 +7,8 @@ import {
     type LocalAccount
 } from "viem"
 import type { Chain, EncodeDeployDataParameters, Transport } from "viem"
-import { type UserOperation } from "../types"
+import type { UserOperation } from "../types"
+import type { EntryPoint, GetEntryPointVersion } from "../types/entrypoint"
 
 export class SignTransactionNotSupportedBySmartAccount extends BaseError {
     override name = "SignTransactionNotSupportedBySmartAccount"
@@ -26,15 +27,18 @@ export class SignTransactionNotSupportedBySmartAccount extends BaseError {
 }
 
 export type SmartAccount<
+    entryPoint extends EntryPoint,
     Name extends string = string,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined,
     TAbi extends Abi | readonly unknown[] = Abi
 > = LocalAccount<Name> & {
     client: Client<transport, chain>
-    entryPoint: Address
+    entryPoint: entryPoint
     getNonce: () => Promise<bigint>
     getInitCode: () => Promise<Hex>
+    getFactory: () => Promise<Address | undefined>
+    getFactoryData: () => Promise<Hex | undefined>
     encodeCallData: (
         args:
             | {
@@ -48,13 +52,17 @@ export type SmartAccount<
                   data: Hex
               }[]
     ) => Promise<Hex>
-    getDummySignature(userOperation: UserOperation): Promise<Hex>
+    getDummySignature(
+        userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+    ): Promise<Hex>
     encodeDeployCallData: ({
         abi,
         args,
         bytecode
     }: EncodeDeployDataParameters<TAbi>) => Promise<Hex>
-    signUserOperation: (userOperation: UserOperation) => Promise<Hex>
+    signUserOperation: (
+        userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
+    ) => Promise<Hex>
 }
 
 export type SmartAccountSigner<

package/actions/bundler/chainId.ts

@@ -1,5 +1,6 @@
 import type { Account, Chain, Client, Transport } from "viem"
 import type { BundlerClient } from "../../clients/createBundlerClient"
+import type { EntryPoint } from "../../types"
 import type { BundlerRpcSchema } from "../../types/bundler"
 
 /**
@@ -25,11 +26,12 @@ import type { BundlerRpcSchema } from "../../types/bundler"
  *
  */
 export const chainId = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema<entryPoint>>
 ) => {
     return Number(
         await client.request({

package/actions/bundler/estimateUserOperationGas.ts

@@ -1,38 +1,59 @@
 import {
     type Account,
-    type Address,
     BaseError,
     type Chain,
     type Client,
+    type Hex,
     type Transport
 } from "viem"
 import type { PartialBy } from "viem/types/utils"
 import type { BundlerClient } from "../../clients/createBundlerClient"
 import type { Prettify } from "../../types/"
 import type { BundlerRpcSchema, StateOverrides } from "../../types/bundler"
+import type { EntryPoint, GetEntryPointVersion } from "../../types/entrypoint"
 import type { UserOperation } from "../../types/userOperation"
+import { getEntryPointVersion } from "../../utils"
 import { deepHexlify } from "../../utils/deepHexlify"
 import {
     type GetEstimateUserOperationGasErrorReturnType,
     getEstimateUserOperationGasError
 } from "../../utils/errors/getEstimateUserOperationGasError"
 
-export type EstimateUserOperationGasParameters = {
-    userOperation: PartialBy<
-        UserOperation,
-        "callGasLimit" | "preVerificationGas" | "verificationGasLimit"
-    >
-    entryPoint: Address
-}
+export type EstimateUserOperationGasParameters<entryPoint extends EntryPoint> =
+    {
+        userOperation: GetEntryPointVersion<entryPoint> extends "v0.6"
+            ? PartialBy<
+                  UserOperation<"v0.6">,
+                  "callGasLimit" | "preVerificationGas" | "verificationGasLimit"
+              >
+            : PartialBy<
+                  UserOperation<"v0.7">,
+                  | "callGasLimit"
+                  | "preVerificationGas"
+                  | "verificationGasLimit"
+                  | "paymasterVerificationGasLimit"
+                  | "paymasterPostOpGasLimit"
+              >
+        entryPoint: entryPoint
+    }
 
-export type EstimateUserOperationGasReturnType = {
-    preVerificationGas: bigint
-    verificationGasLimit: bigint
-    callGasLimit: bigint
-}
+export type EstimateUserOperationGasReturnType<entryPoint extends EntryPoint> =
+    GetEntryPointVersion<entryPoint> extends "v0.6"
+        ? {
+              preVerificationGas: bigint
+              verificationGasLimit: bigint
+              callGasLimit: bigint
+          }
+        : {
+              preVerificationGas: bigint
+              verificationGasLimit: bigint
+              callGasLimit: bigint
+              paymasterVerificationGasLimit: bigint | undefined
+              paymasterPostOpGasLimit: bigint | undefined
+          }
 
-export type EstimateUserOperationErrorType =
-    GetEstimateUserOperationGasErrorReturnType
+export type EstimateUserOperationErrorType<entryPoint extends EntryPoint> =
+    GetEstimateUserOperationGasErrorReturnType<entryPoint>
 
 /**
  * Estimates preVerificationGas, verificationGasLimit and callGasLimit for user operation
@@ -62,14 +83,15 @@ export type EstimateUserOperationErrorType =
  *
  */
 export const estimateUserOperationGas = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
-    args: Prettify<EstimateUserOperationGasParameters>,
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema<entryPoint>>,
+    args: Prettify<EstimateUserOperationGasParameters<entryPoint>>,
     stateOverrides?: StateOverrides
-): Promise<Prettify<EstimateUserOperationGasReturnType>> => {
+): Promise<EstimateUserOperationGasReturnType<entryPoint>> => {
     const { userOperation, entryPoint } = args
 
     const userOperationWithBigIntAsHex = deepHexlify(userOperation)
@@ -87,11 +109,44 @@ export const estimateUserOperationGas = async <
                 : [userOperationWithBigIntAsHex, entryPoint]
         })
 
-        return {
-            preVerificationGas: BigInt(response.preVerificationGas || 0),
-            verificationGasLimit: BigInt(response.verificationGasLimit || 0),
-            callGasLimit: BigInt(response.callGasLimit || 0)
+        const entryPointVersion = getEntryPointVersion(entryPoint)
+
+        if (entryPointVersion === "v0.6") {
+            const responseV06 = response as {
+                preVerificationGas: Hex
+                verificationGasLimit: Hex
+                callGasLimit: Hex
+            }
+
+            return {
+                preVerificationGas: BigInt(responseV06.preVerificationGas || 0),
+                verificationGasLimit: BigInt(
+                    responseV06.verificationGasLimit || 0
+                ),
+                callGasLimit: BigInt(responseV06.callGasLimit || 0)
+            } as EstimateUserOperationGasReturnType<entryPoint>
+        }
+
+        const responseV07 = response as {
+            preVerificationGas: Hex
+            verificationGasLimit: Hex
+            callGasLimit: Hex
+            paymasterVerificationGasLimit: Hex | undefined
+            paymasterPostOpGasLimit: Hex | undefined
         }
+
+        return {
+            preVerificationGas: BigInt(responseV07.preVerificationGas || 0),
+            verificationGasLimit: BigInt(responseV07.verificationGasLimit || 0),
+            callGasLimit: BigInt(responseV07.callGasLimit || 0),
+            paymasterVerificationGasLimit:
+                responseV07.paymasterVerificationGasLimit
+                    ? BigInt(responseV07.paymasterVerificationGasLimit)
+                    : undefined,
+            paymasterPostOpGasLimit: responseV07.paymasterPostOpGasLimit
+                ? BigInt(responseV07.paymasterPostOpGasLimit)
+                : undefined
+        } as EstimateUserOperationGasReturnType<entryPoint>
     } catch (err) {
         throw getEstimateUserOperationGasError(err as BaseError, args)
     }

package/actions/bundler/getUserOperationByHash.ts

@@ -2,14 +2,16 @@ import type { Account, Address, Chain, Client, Hash, Transport } from "viem"
 import type { BundlerClient } from "../../clients/createBundlerClient"
 import type { Prettify } from "../../types/"
 import type { BundlerRpcSchema } from "../../types/bundler"
+import type { EntryPoint, GetEntryPointVersion } from "../../types/entrypoint"
 import type { UserOperation } from "../../types/userOperation"
+import { ENTRYPOINT_ADDRESS_V06 } from "../../utils/getEntryPointVersion"
 
 export type GetUserOperationByHashParameters = {
     hash: Hash
 }
 
-export type GetUserOperationByHashReturnType = {
-    userOperation: UserOperation
+export type GetUserOperationByHashReturnType<entryPoint extends EntryPoint> = {
+    userOperation: UserOperation<GetEntryPointVersion<entryPoint>>
     entryPoint: Address
     transactionHash: Hash
     blockHash: Hash
@@ -39,13 +41,14 @@ export type GetUserOperationByHashReturnType = {
  *
  */
 export const getUserOperationByHash = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema<entryPoint>>,
     { hash }: Prettify<GetUserOperationByHashParameters>
-): Promise<Prettify<GetUserOperationByHashReturnType> | null> => {
+): Promise<Prettify<GetUserOperationByHashReturnType<entryPoint>> | null> => {
     const params: [Hash] = [hash]
 
     const response = await client.request({
@@ -57,23 +60,49 @@ export const getUserOperationByHash = async <
 
     const {
         userOperation,
-        entryPoint,
+        entryPoint: entryPointAddress,
         transactionHash,
         blockHash,
         blockNumber
     } = response
 
     return {
-        userOperation: {
-            ...userOperation,
-            nonce: BigInt(userOperation.nonce),
-            callGasLimit: BigInt(userOperation.callGasLimit),
-            verificationGasLimit: BigInt(userOperation.verificationGasLimit),
-            preVerificationGas: BigInt(userOperation.preVerificationGas),
-            maxFeePerGas: BigInt(userOperation.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(userOperation.maxPriorityFeePerGas)
-        } as UserOperation,
-        entryPoint: entryPoint,
+        userOperation: (entryPointAddress === ENTRYPOINT_ADDRESS_V06
+            ? {
+                  ...userOperation,
+                  nonce: BigInt(userOperation.nonce),
+                  callGasLimit: BigInt(userOperation.callGasLimit),
+                  verificationGasLimit: BigInt(
+                      userOperation.verificationGasLimit
+                  ),
+                  preVerificationGas: BigInt(userOperation.preVerificationGas),
+                  maxFeePerGas: BigInt(userOperation.maxFeePerGas),
+                  maxPriorityFeePerGas: BigInt(
+                      userOperation.maxPriorityFeePerGas
+                  )
+              }
+            : {
+                  ...userOperation,
+                  nonce: BigInt(userOperation.nonce),
+                  callGasLimit: BigInt(userOperation.callGasLimit),
+                  verificationGasLimit: BigInt(
+                      userOperation.verificationGasLimit
+                  ),
+                  preVerificationGas: BigInt(userOperation.preVerificationGas),
+                  maxFeePerGas: BigInt(userOperation.maxFeePerGas),
+                  maxPriorityFeePerGas: BigInt(
+                      userOperation.maxPriorityFeePerGas
+                  ),
+                  paymasterVerificationGasLimit:
+                      userOperation.paymasterVerificationGasLimit
+                          ? BigInt(userOperation.paymasterVerificationGasLimit)
+                          : undefined,
+                  paymasterPostOpGasLimit:
+                      userOperation.paymasterVerificationGasLimit
+                          ? BigInt(userOperation.paymasterPostOpGasLimit)
+                          : undefined
+              }) as UserOperation<GetEntryPointVersion<entryPoint>>,
+        entryPoint: entryPointAddress,
         transactionHash: transactionHash,
         blockHash: blockHash,
         blockNumber: BigInt(blockNumber)

package/actions/bundler/getUserOperationReceipt.ts

@@ -10,6 +10,7 @@ import type {
 import type { BundlerClient } from "../../clients/createBundlerClient"
 import type { Prettify } from "../../types"
 import type { BundlerRpcSchema } from "../../types/bundler"
+import type { EntryPoint } from "../../types/entrypoint"
 import type { TStatus } from "../../types/userOperation"
 import { transactionReceiptStatus } from "../../utils/deepHexlify"
 
@@ -73,11 +74,12 @@ export type GetUserOperationReceiptReturnType = {
  *
  */
 export const getUserOperationReceipt = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
     TAccount extends Account | undefined = Account | undefined
 >(
-    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema>,
+    client: Client<TTransport, TChain, TAccount, BundlerRpcSchema<entryPoint>>,
     { hash }: Prettify<GetUserOperationReceiptParameters>
 ): Promise<Prettify<GetUserOperationReceiptReturnType> | null> => {
     const params: [Hash] = [hash]