@zerodev/sdk 5.3.25 → 5.4.0-beta.0

package/actions/index.ts

@@ -20,6 +20,21 @@ export {
     type UninstallPluginParameters
 } from "./account-client/uninstallPlugin.js"
 
+export { getKernelV3ModuleCurrentNonce } from "./account-client/getKernelV3ModuleCurrentNonce.js"
+
+export {
+    type InvalidateNonceParameters,
+    invalidateNonce
+} from "./account-client/invalidateNonce.js"
+
+export { sendTransaction } from "./account-client/sendTransaction.js"
+
+export { signMessage } from "./account-client/signMessage.js"
+
+export { signTypedData } from "./account-client/signTypedData.js"
+
+export { writeContract } from "./account-client/writeContract.js"
+
 export {
     changeSudoValidator,
     type ChangeSudoValidatorParameters
@@ -30,9 +45,3 @@ export {
     type EstimateGasInERC20Parameters,
     type EstimateGasInERC20ReturnType
 } from "./paymaster/estimateGasInERC20.js"
-
-export {
-    type SponsorUserOperationEip7677Parameters,
-    type SponsorUserOperationEip7677ReturnType,
-    sponsorUserOperationEip7677
-} from "./paymaster/sponsorUserOperationEip7677.js"

package/actions/paymaster/estimateGasInERC20.ts

@@ -1,12 +1,14 @@
-import { ENTRYPOINT_ADDRESS_V06 } from "permissionless"
-import type { EntryPoint } from "permissionless/types"
-import type { UserOperation } from "permissionless/types/userOperation.js"
-import { deepHexlify } from "permissionless/utils"
 import type { Address, Hex } from "viem"
+import {
+    type EntryPointVersion,
+    type UserOperation,
+    entryPoint06Address
+} from "viem/account-abstraction"
 import type { ZeroDevPaymasterClient } from "../../clients/paymasterClient.js"
+import { deepHexlify } from "../../utils.js"
 
 export type EstimateGasInERC20Parameters = {
-    userOperation: UserOperation<"v0.6" | "v0.7">
+    userOperation: UserOperation
     gasTokenAddress: Hex
     entryPoint: Address
 }
@@ -24,8 +26,10 @@ export type EstimateGasInERC20ReturnType = {
  * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
  */
 
-export const estimateGasInERC20 = async <entryPoint extends EntryPoint>(
-    client: ZeroDevPaymasterClient<entryPoint>,
+export const estimateGasInERC20 = async <
+    entryPointVersion extends EntryPointVersion
+>(
+    client: ZeroDevPaymasterClient<entryPointVersion>,
     args: EstimateGasInERC20Parameters
 ): Promise<EstimateGasInERC20ReturnType> => {
     const response = await client.request({
@@ -38,7 +42,7 @@ export const estimateGasInERC20 = async <entryPoint extends EntryPoint>(
                     initCode: args.userOperation.initCode || "0x"
                 },
                 tokenAddress: args.gasTokenAddress,
-                entryPointAddress: args.entryPoint ?? ENTRYPOINT_ADDRESS_V06
+                entryPointAddress: args.entryPoint ?? entryPoint06Address
             }
         ]
     })

package/actions/paymaster/sponsorUserOperation.ts

@@ -1,77 +1,80 @@
-import { getEntryPointVersion } from "permissionless"
-import type { PartialPick } from "permissionless/types"
-import type {
-    ENTRYPOINT_ADDRESS_V06_TYPE,
-    EntryPoint
-} from "permissionless/types/entrypoint"
-import type { UserOperation } from "permissionless/types/userOperation.js"
-import { deepHexlify } from "permissionless/utils"
 import type { Address, Hex } from "viem"
-import type { PartialBy } from "viem/types/utils"
+import type { PartialBy } from "viem"
+import type { EntryPointVersion, UserOperation } from "viem/account-abstraction"
 import type { ZeroDevPaymasterClient } from "../../clients/paymasterClient.js"
+import type { PartialPick } from "../../types/index.js"
+import { deepHexlify } from "../../utils.js"
 
-export type SponsorUserOperationParameters<entryPoint extends EntryPoint> = {
-    userOperation: entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+export type SponsorUserOperationParameters<
+    entryPointVersion extends EntryPointVersion
+> = {
+    userOperation: entryPointVersion extends "0.6"
         ? PartialBy<
-              UserOperation<"v0.6">,
+              UserOperation<"0.6">,
               "callGasLimit" | "preVerificationGas" | "verificationGasLimit"
           >
         : PartialBy<
-              UserOperation<"v0.7">,
+              UserOperation<"0.7">,
               | "callGasLimit"
               | "preVerificationGas"
               | "verificationGasLimit"
               | "paymasterVerificationGasLimit"
               | "paymasterPostOpGasLimit"
           >
-    entryPoint: entryPoint
+    entryPoint: {
+        address: Address
+        version: entryPointVersion
+    }
     gasToken?: Hex
     shouldOverrideFee?: boolean
     shouldConsume?: boolean
 }
 
-export type SponsorUserOperationReturnType<entryPoint extends EntryPoint> =
-    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
-        ? Pick<
-              UserOperation<"v0.6">,
-              | "callGasLimit"
-              | "verificationGasLimit"
-              | "preVerificationGas"
-              | "paymasterAndData"
-          > &
-              PartialPick<
-                  UserOperation<"v0.6">,
-                  "maxFeePerGas" | "maxPriorityFeePerGas"
-              >
-        : Pick<
-              UserOperation<"v0.7">,
-              | "callGasLimit"
-              | "verificationGasLimit"
-              | "preVerificationGas"
-              | "paymaster"
-              | "paymasterVerificationGasLimit"
-              | "paymasterPostOpGasLimit"
-              | "paymasterData"
-          > &
-              PartialPick<
-                  UserOperation<"v0.7">,
-                  "maxFeePerGas" | "maxPriorityFeePerGas"
-              >
+export type SponsorUserOperationReturnType<
+    entryPointVersion extends EntryPointVersion
+> = entryPointVersion extends "0.6"
+    ? Pick<
+          UserOperation<"0.6">,
+          | "callGasLimit"
+          | "verificationGasLimit"
+          | "preVerificationGas"
+          | "paymasterAndData"
+      > &
+          PartialPick<
+              UserOperation<"0.6">,
+              "maxFeePerGas" | "maxPriorityFeePerGas"
+          >
+    : Pick<
+          UserOperation<"0.7">,
+          | "callGasLimit"
+          | "verificationGasLimit"
+          | "preVerificationGas"
+          | "paymaster"
+          | "paymasterVerificationGasLimit"
+          | "paymasterPostOpGasLimit"
+          | "paymasterData"
+      > &
+          PartialPick<
+              UserOperation<"0.7">,
+              "maxFeePerGas" | "maxPriorityFeePerGas"
+          >
 
 /**
  * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
  */
-export const sponsorUserOperation = async <entryPoint extends EntryPoint>(
-    client: ZeroDevPaymasterClient<entryPoint>,
-    args: SponsorUserOperationParameters<entryPoint>
-): Promise<SponsorUserOperationReturnType<entryPoint>> => {
+export const sponsorUserOperation = async <
+    entryPointVersion extends EntryPointVersion
+>(
+    client: ZeroDevPaymasterClient<entryPointVersion>,
+    args: SponsorUserOperationParameters<entryPointVersion>
+): Promise<SponsorUserOperationReturnType<entryPointVersion>> => {
     const response = await client.request({
         method: "zd_sponsorUserOperation",
         params: [
             {
                 chainId: client.chain?.id as number,
                 userOp: deepHexlify(args.userOperation),
-                entryPointAddress: args.entryPoint,
+                entryPointAddress: args.entryPoint.address,
                 gasTokenData: args.gasToken && {
                     tokenAddress: args.gasToken
                 },
@@ -80,8 +83,7 @@ export const sponsorUserOperation = async <entryPoint extends EntryPoint>(
             }
         ]
     })
-    const entryPointVersion = getEntryPointVersion(args.entryPoint)
-    if (entryPointVersion === "v0.6") {
+    if (args.entryPoint.version === "0.6") {
         return {
             paymasterAndData: response.paymasterAndData,
             preVerificationGas: BigInt(response.preVerificationGas),
@@ -92,7 +94,7 @@ export const sponsorUserOperation = async <entryPoint extends EntryPoint>(
             maxPriorityFeePerGas:
                 response.maxPriorityFeePerGas &&
                 BigInt(response.maxPriorityFeePerGas)
-        } as SponsorUserOperationReturnType<entryPoint>
+        } as SponsorUserOperationReturnType<entryPointVersion>
     }
     const responseV07 = response as {
         preVerificationGas: Hex
@@ -121,5 +123,5 @@ export const sponsorUserOperation = async <entryPoint extends EntryPoint>(
         maxPriorityFeePerGas:
             response.maxPriorityFeePerGas &&
             BigInt(response.maxPriorityFeePerGas)
-    } as SponsorUserOperationReturnType<entryPoint>
+    } as SponsorUserOperationReturnType<entryPointVersion>
 }

package/actions/public/getAccountNonce.ts

@@ -0,0 +1,77 @@
+// Copied from: https://github.com/pimlicolabs/permissionless.js/blob/main/packages/permissionless/actions/public/getAccountNonce.ts
+
+import type { Address, Client } from "viem"
+import { readContract } from "viem/actions"
+import { getAction } from "viem/utils"
+
+export type GetAccountNonceParams = {
+    address: Address
+    entryPointAddress: Address
+    key?: bigint
+}
+
+/**
+ * Returns the nonce of the account with the entry point.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/public-actions/getAccountNonce
+ *
+ * @param client {@link client} that you created using viem's createPublicClient.
+ * @param args {@link GetAccountNonceParams} address, entryPoint & key
+ * @returns bigint nonce
+ *
+ * @example
+ * import { createPublicClient } from "viem"
+ * import { getAccountNonce } from "permissionless/actions"
+ *
+ * const client = createPublicClient({
+ *      chain: goerli,
+ *      transport: http("https://goerli.infura.io/v3/your-infura-key")
+ * })
+ *
+ * const nonce = await getAccountNonce(client, {
+ *      address,
+ *      entryPoint,
+ *      key
+ * })
+ *
+ * // Return 0n
+ */
+export const getAccountNonce = async (
+    client: Client,
+    args: GetAccountNonceParams
+): Promise<bigint> => {
+    const { address, entryPointAddress, key = BigInt(0) } = args
+
+    return await getAction(
+        client,
+        readContract,
+        "readContract"
+    )({
+        address: entryPointAddress,
+        abi: [
+            {
+                inputs: [
+                    {
+                        name: "sender",
+                        type: "address"
+                    },
+                    {
+                        name: "key",
+                        type: "uint192"
+                    }
+                ],
+                name: "getNonce",
+                outputs: [
+                    {
+                        name: "nonce",
+                        type: "uint256"
+                    }
+                ],
+                stateMutability: "view",
+                type: "function"
+            }
+        ],
+        functionName: "getNonce",
+        args: [address, key]
+    })
+}

package/actions/public/getSenderAddress.ts

@@ -0,0 +1,276 @@
+// Copied from: https://github.com/pimlicolabs/permissionless.js/blob/main/packages/permissionless/actions/public/getSenderAddress.ts
+
+import {
+    type Address,
+    BaseError,
+    type Client,
+    type ContractFunctionExecutionErrorType,
+    ContractFunctionRevertedError,
+    type Hex,
+    InvalidInputRpcError,
+    type OneOf,
+    type Prettify,
+    RawContractError,
+    RpcRequestError,
+    UnknownRpcError,
+    concat,
+    decodeErrorResult
+} from "viem"
+
+import { simulateContract } from "viem/actions"
+import { getAction } from "viem/utils"
+
+export type GetSenderAddressParams = OneOf<
+    | {
+          initCode: Hex
+          entryPointAddress: Address
+          factory?: never
+          factoryData?: never
+      }
+    | {
+          entryPointAddress: Address
+          factory: Address
+          factoryData: Hex
+          initCode?: never
+      }
+>
+
+export class InvalidEntryPointError extends BaseError {
+    override name = "InvalidEntryPointError"
+
+    constructor({
+        cause,
+        entryPointAddress
+    }: { cause?: BaseError; entryPointAddress?: Address } = {}) {
+        super(
+            `The entry point address (\`entryPoint\`${
+                entryPointAddress ? ` = ${entryPointAddress}` : ""
+            }) is not a valid entry point. getSenderAddress did not revert with a SenderAddressResult error.`,
+            {
+                cause
+            }
+        )
+    }
+}
+
+/**
+ * Returns the address of the account that will be deployed with the given init code.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/public-actions/getSenderAddress
+ *
+ * @param client {@link Client} that you created using viem's createPublicClient.
+ * @param args {@link GetSenderAddressParams} initCode & entryPoint
+ * @returns Sender's Address
+ *
+ * @example
+ * import { createPublicClient } from "viem"
+ * import { getSenderAddress } from "permissionless/actions"
+ *
+ * const publicClient = createPublicClient({
+ *      chain: goerli,
+ *      transport: http("https://goerli.infura.io/v3/your-infura-key")
+ * })
+ *
+ * const senderAddress = await getSenderAddress(publicClient, {
+ *      initCode,
+ *      entryPoint
+ * })
+ *
+ * // Return '0x7a88a206ba40b37a8c07a2b5688cf8b287318b63'
+ */
+export const getSenderAddress = async (
+    client: Client,
+    args: Prettify<GetSenderAddressParams>
+): Promise<Address> => {
+    const { initCode, entryPointAddress, factory, factoryData } = args
+
+    if (!initCode && !factory && !factoryData) {
+        throw new Error(
+            "Either `initCode` or `factory` and `factoryData` must be provided"
+        )
+    }
+
+    try {
+        await getAction(
+            client,
+            simulateContract,
+            "simulateContract"
+        )({
+            address: entryPointAddress,
+            abi: [
+                {
+                    inputs: [
+                        {
+                            internalType: "address",
+                            name: "sender",
+                            type: "address"
+                        }
+                    ],
+                    name: "SenderAddressResult",
+                    type: "error"
+                },
+                {
+                    inputs: [
+                        {
+                            internalType: "bytes",
+                            name: "initCode",
+                            type: "bytes"
+                        }
+                    ],
+                    name: "getSenderAddress",
+                    outputs: [],
+                    stateMutability: "nonpayable",
+                    type: "function"
+                }
+            ],
+            functionName: "getSenderAddress",
+            args: [initCode || concat([factory as Hex, factoryData as Hex])]
+        })
+    } catch (e) {
+        const revertError = (e as ContractFunctionExecutionErrorType).walk(
+            (err) =>
+                err instanceof ContractFunctionRevertedError ||
+                err instanceof RpcRequestError ||
+                err instanceof InvalidInputRpcError ||
+                err instanceof UnknownRpcError
+        )
+
+        if (!revertError) {
+            // biome-ignore lint/suspicious/noExplicitAny:
+            const cause = (e as ContractFunctionExecutionErrorType).cause as any
+            const errorName = cause?.data?.errorName ?? ""
+            if (
+                errorName === "SenderAddressResult" &&
+                cause?.data?.args &&
+                cause?.data?.args[0]
+            ) {
+                return cause.data?.args[0] as Address
+            }
+        }
+
+        if (revertError instanceof ContractFunctionRevertedError) {
+            const errorName = revertError.data?.errorName ?? ""
+            if (
+                errorName === "SenderAddressResult" &&
+                revertError.data?.args &&
+                revertError.data?.args[0]
+            ) {
+                return revertError.data?.args[0] as Address
+            }
+        }
+
+        if (revertError instanceof RpcRequestError) {
+            const hexStringRegex = /0x[a-fA-F0-9]+/
+            // biome-ignore lint/suspicious/noExplicitAny:
+            const match = (revertError as unknown as any).cause.data.match(
+                hexStringRegex
+            )
+
+            if (!match) {
+                throw new Error(
+                    "Failed to parse revert bytes from RPC response"
+                )
+            }
+
+            const data: Hex = match[0]
+
+            const error = decodeErrorResult({
+                abi: [
+                    {
+                        inputs: [
+                            {
+                                internalType: "address",
+                                name: "sender",
+                                type: "address"
+                            }
+                        ],
+                        name: "SenderAddressResult",
+                        type: "error"
+                    }
+                ],
+                data
+            })
+
+            return error.args[0] as Address
+        }
+
+        if (revertError instanceof InvalidInputRpcError) {
+            const { data: data_ } = (
+                e instanceof RawContractError
+                    ? e
+                    : e instanceof BaseError
+                      ? e.walk((err) => "data" in (err as Error)) || e.walk()
+                      : {}
+            ) as RawContractError
+
+            const data = typeof data_ === "string" ? data_ : data_?.data
+
+            if (data === undefined) {
+                throw new Error(
+                    "Failed to parse revert bytes from RPC response"
+                )
+            }
+
+            const error = decodeErrorResult({
+                abi: [
+                    {
+                        inputs: [
+                            {
+                                internalType: "address",
+                                name: "sender",
+                                type: "address"
+                            }
+                        ],
+                        name: "SenderAddressResult",
+                        type: "error"
+                    }
+                ],
+                data
+            })
+
+            return error.args[0] as Address
+        }
+
+        if (revertError instanceof UnknownRpcError) {
+            const parsedBody = JSON.parse(
+                // biome-ignore lint/suspicious/noExplicitAny:
+                (revertError as unknown as any).cause.body
+            )
+            const revertData = parsedBody.error.data
+
+            const hexStringRegex = /0x[a-fA-F0-9]+/
+            const match = revertData.match(hexStringRegex)
+
+            if (!match) {
+                throw new Error(
+                    "Failed to parse revert bytes from RPC response"
+                )
+            }
+
+            const data: Hex = match[0]
+
+            const error = decodeErrorResult({
+                abi: [
+                    {
+                        inputs: [
+                            {
+                                internalType: "address",
+                                name: "sender",
+                                type: "address"
+                            }
+                        ],
+                        name: "SenderAddressResult",
+                        type: "error"
+                    }
+                ],
+                data
+            })
+
+            return error.args[0] as Address
+        }
+
+        throw e
+    }
+
+    throw new InvalidEntryPointError({ entryPointAddress })
+}

package/actions/public/index.ts

@@ -0,0 +1,9 @@
+export {
+    type GetAccountNonceParams,
+    getAccountNonce
+} from "./getAccountNonce.js"
+export {
+    type GetSenderAddressParams,
+    type InvalidEntryPointError,
+    getSenderAddress
+} from "./getSenderAddress.js"