@zerodev/sdk 5.1.12 → 5.2.0-alpha-0

package/accounts/utils/toKernelPluginManager.ts

@@ -1,4 +1,5 @@
-import { getAction } from "permissionless"
+import { getAction, getEntryPointVersion } from "permissionless"
+import type { EntryPoint } from "permissionless/types/entrypoint"
 import {
     type Address,
     type Chain,
@@ -7,33 +8,39 @@ import {
     type Transport,
     concat,
     concatHex,
+    encodeAbiParameters,
     hexToBigInt,
     pad,
+    parseAbiParameters,
     toFunctionSelector,
     toHex,
     zeroAddress
 } from "viem"
-import { getChainId, getStorageAt } from "viem/actions"
-import { LATEST_KERNEL_VERSION } from "../../constants.js"
+import { getChainId, readContract } from "viem/actions"
+import { VALIDATOR_MODE, VALIDATOR_TYPE } from "../../constants.js"
 import {
     type KernelPluginManager,
     type KernelPluginManagerParams,
     ValidatorMode
 } from "../../types/kernel.js"
 import { getKernelVersion } from "../../utils.js"
+import { KernelV3AccountAbi } from "../kernel/abi/kernel_v_3_0_0/KernelAccountAbi.js"
+import { KernelModuleIsInitializedAbi } from "../kernel/abi/kernel_v_3_0_0/KernelModuleAbi.js"
+import { getKernelImplementationAddress } from "./6492.js"
 
-export function isKernelPluginManager(
+export function isKernelPluginManager<entryPoint extends EntryPoint>(
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     plugin: any
-): plugin is KernelPluginManager {
+): plugin is KernelPluginManager<entryPoint> {
     return plugin.getPluginEnableSignature !== undefined
 }
 
 export async function toKernelPluginManager<
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >(
-    client: Client<TTransport, TChain>,
+    client: Client<TTransport, TChain, undefined>,
     {
         sudo,
         regular,
@@ -46,45 +53,108 @@ export async function toKernelPluginManager<
             )
         },
         validAfter = 0,
-        validUntil = 0
-    }: KernelPluginManagerParams
-): Promise<KernelPluginManager> {
+        validUntil = 0,
+        entryPoint: entryPointAddress
+    }: KernelPluginManagerParams<entryPoint>
+): Promise<KernelPluginManager<entryPoint>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
     const chainId = await getChainId(client)
+    const activeValidator = regular || sudo
+    if (!activeValidator) {
+        throw new Error("One of `sudo` or `regular` validator must be set")
+    }
     const getValidatorSignature = async (
         accountAddress: Address,
-        selector: Hex
+        selector: Hex,
+        sig?: Hex
     ): Promise<Hex> => {
+        if (entryPointVersion === "v0.6") {
+            if (regular) {
+                if (await regular.isEnabled(accountAddress, selector)) {
+                    return ValidatorMode.plugin
+                }
+
+                const enableSignature =
+                    await getPluginEnableSignature(accountAddress)
+                const enableData = await regular.getEnableData(accountAddress)
+                const enableDataLength = enableData.length / 2 - 1
+                if (!enableSignature) {
+                    throw new Error("Enable signature not set")
+                }
+
+                return concat([
+                    ValidatorMode.enable,
+                    pad(toHex(validUntil), { size: 6 }), // 6 bytes 4 - 10
+                    pad(toHex(validAfter), { size: 6 }), // 6 bytes 10 - 16
+                    pad(regular.address, { size: 20 }), // 20 bytes 16 - 36
+                    pad(executorData.executor, { size: 20 }), // 20 bytes 36 - 56
+                    pad(toHex(enableDataLength), { size: 32 }), // 32 bytes 56 - 88
+                    enableData, // 88 - 88 + enableData.length
+                    pad(toHex(enableSignature.length / 2 - 1), { size: 32 }), // 32 bytes 88 + enableData.length - 120 + enableData.length
+                    enableSignature // 120 + enableData.length - 120 + enableData.length + enableSignature.length
+                ])
+            } else if (sudo) {
+                return ValidatorMode.sudo
+            } else {
+                throw new Error(
+                    "One of `sudo` or `regular` validator must be set"
+                )
+            }
+        }
         if (regular) {
-            if (await regular.isEnabled(accountAddress, selector)) {
-                return ValidatorMode.plugin
+            if (
+                (await isPluginInitialized_7579(accountAddress)) ||
+                (await regular.isEnabled(accountAddress, selector))
+            ) {
+                return sig ?? "0x"
             }
-
+            const enableData = await regular.getEnableData(accountAddress)
             const enableSignature =
                 await getPluginEnableSignature(accountAddress)
-            const enableData = await regular.getEnableData(accountAddress)
-            const enableDataLength = enableData.length / 2 - 1
-            if (!enableSignature) {
-                throw new Error("Enable signature not set")
-            }
-
             return concat([
-                ValidatorMode.enable,
-                pad(toHex(validUntil), { size: 6 }), // 6 bytes 4 - 10
-                pad(toHex(validAfter), { size: 6 }), // 6 bytes 10 - 16
-                pad(regular.address, { size: 20 }), // 20 bytes 16 - 36
-                pad(executorData.executor, { size: 20 }), // 20 bytes 36 - 56
-                pad(toHex(enableDataLength), { size: 32 }), // 32 bytes 56 - 88
-                enableData, // 88 - 88 + enableData.length
-                pad(toHex(enableSignature.length / 2 - 1), { size: 32 }), // 32 bytes 88 + enableData.length - 120 + enableData.length
-                enableSignature // 120 + enableData.length - 120 + enableData.length + enableSignature.length
+                zeroAddress, // hook address 20 bytes
+                encodeAbiParameters(
+                    parseAbiParameters(
+                        "bytes validatorData, bytes hookData, bytes selectorData, bytes enableSig, bytes userOpSig"
+                    ),
+                    [
+                        enableData,
+                        "0x",
+                        concat([
+                            executorData.selector,
+                            executorData.executor,
+                            zeroAddress,
+                            "0x"
+                        ]),
+                        enableSignature,
+                        sig ?? "0x"
+                    ]
+                )
             ])
         } else if (sudo) {
-            return ValidatorMode.sudo
+            return sig ?? "0x"
         } else {
             throw new Error("One of `sudo` or `regular` validator must be set")
         }
     }
 
+    const isPluginInitialized_7579 = async (
+        accountAddress: Address
+    ): Promise<boolean> => {
+        try {
+            return await getAction(
+                client,
+                readContract
+            )({
+                abi: KernelModuleIsInitializedAbi,
+                address: activeValidator.address,
+                functionName: "isInitialized",
+                args: [accountAddress]
+            })
+        } catch (error) {}
+        return false
+    }
+
     const getPluginEnableSignature = async (accountAddress: Address) => {
         if (pluginEnableSignature) return pluginEnableSignature
         if (!sudo)
@@ -92,72 +162,139 @@ export async function toKernelPluginManager<
                 "sudo validator not set -- need it to enable the validator"
             )
         if (!regular) throw new Error("regular validator not set")
-        let kernelImplAddr: Address | undefined
-        try {
-            const strgAddr = await getAction(
-                client,
-                getStorageAt
-            )({
-                address: accountAddress,
-                slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"
+
+        const kernelImplAddr = await getKernelImplementationAddress(
+            client,
+            accountAddress
+        )
+        const kernelVersion = getKernelVersion(
+            entryPointAddress,
+            kernelImplAddr
+        )
+        let ownerSig: Hex
+        if (entryPointVersion === "v0.6") {
+            ownerSig = await sudo.signTypedData({
+                domain: {
+                    name: "Kernel",
+                    version: kernelVersion,
+                    chainId,
+                    verifyingContract: accountAddress
+                },
+                types: {
+                    ValidatorApproved: [
+                        { name: "sig", type: "bytes4" },
+                        { name: "validatorData", type: "uint256" },
+                        { name: "executor", type: "address" },
+                        { name: "enableData", type: "bytes" }
+                    ]
+                },
+                message: {
+                    sig: executorData.selector,
+                    validatorData: hexToBigInt(
+                        concatHex([
+                            pad(toHex(validUntil ?? 0), {
+                                size: 6
+                            }),
+                            pad(toHex(validAfter ?? 0), {
+                                size: 6
+                            }),
+                            regular.address
+                        ]),
+                        { size: 32 }
+                    ),
+                    executor: executorData.executor as Address,
+                    enableData: await regular.getEnableData(accountAddress)
+                },
+                primaryType: "ValidatorApproved"
             })
-            if (strgAddr) kernelImplAddr = `0x${strgAddr.slice(26)}` as Hex
-        } catch (error) {}
-        const ownerSig = await sudo.signTypedData({
+            pluginEnableSignature = ownerSig
+            return ownerSig
+        }
+        ownerSig = await sudo.signTypedData({
             domain: {
                 name: "Kernel",
-                version: kernelImplAddr
-                    ? getKernelVersion(kernelImplAddr)
-                    : LATEST_KERNEL_VERSION,
+                version: kernelVersion,
                 chainId,
                 verifyingContract: accountAddress
             },
             types: {
-                ValidatorApproved: [
-                    { name: "sig", type: "bytes4" },
-                    { name: "validatorData", type: "uint256" },
-                    { name: "executor", type: "address" },
-                    { name: "enableData", type: "bytes" }
+                Enable: [
+                    { name: "validationId", type: "bytes21" },
+                    { name: "nonce", type: "uint32" },
+                    { name: "hook", type: "address" },
+                    { name: "validatorData", type: "bytes" },
+                    { name: "hookData", type: "bytes" },
+                    { name: "selectorData", type: "bytes" }
                 ]
             },
             message: {
-                sig: executorData.selector,
-                validatorData: hexToBigInt(
-                    concatHex([
-                        pad(toHex(validUntil ?? 0), {
-                            size: 6
-                        }),
-                        pad(toHex(validAfter ?? 0), {
-                            size: 6
-                        }),
-                        regular.address
-                    ]),
-                    { size: 32 }
-                ),
-                executor: executorData.executor as Address,
-                enableData: await regular.getEnableData(accountAddress)
+                validationId: concat([
+                    activeValidator.isPermissionValidator
+                        ? VALIDATOR_TYPE.PERMISSION
+                        : VALIDATOR_TYPE.SECONDARY,
+                    activeValidator?.isPermissionValidator
+                        ? // @ts-ignore
+                          pad(regular.getPermissionId() as Hex, {
+                              size: 20,
+                              dir: "right"
+                          })
+                        : activeValidator.address
+                ]),
+                nonce: await getKernelV3Nonce(accountAddress),
+                hook: zeroAddress,
+                validatorData: await regular.getEnableData(accountAddress),
+                hookData: "0x",
+                selectorData: concat([
+                    executorData.selector,
+                    executorData.executor,
+                    zeroAddress,
+                    "0x"
+                ])
             },
-            primaryType: "ValidatorApproved"
+            primaryType: "Enable"
         })
-        pluginEnableSignature = ownerSig
+
         return ownerSig
     }
 
-    const activeValidator = regular || sudo
-    if (!activeValidator) {
-        throw new Error("One of `sudo` or `regular` validator must be set")
+    const getKernelV3Nonce = async (
+        accountAddress: Address
+    ): Promise<number> => {
+        try {
+            const nonce = await getAction(
+                client,
+                readContract
+            )({
+                abi: KernelV3AccountAbi,
+                address: accountAddress,
+                functionName: "currentNonce",
+                args: []
+            })
+            return nonce
+        } catch (error) {
+            return 2
+        }
     }
 
     return {
         ...activeValidator,
         signUserOperation: async (userOperation) => {
-            return concatHex([
-                await getValidatorSignature(
-                    userOperation.sender,
-                    userOperation.callData.toString().slice(0, 10) as Hex
-                ),
+            const userOpSig =
                 await activeValidator.signUserOperation(userOperation)
-            ])
+            if (entryPointVersion === "v0.6") {
+                return concatHex([
+                    await getValidatorSignature(
+                        userOperation.sender,
+                        userOperation.callData.toString().slice(0, 10) as Hex
+                    ),
+                    userOpSig
+                ])
+            }
+            return await getValidatorSignature(
+                userOperation.sender,
+                userOperation.callData.toString().slice(0, 10) as Hex,
+                userOpSig
+            )
         },
         getExecutorData: () => executorData,
         getValidityData: () => ({
@@ -165,13 +302,57 @@ export async function toKernelPluginManager<
             validUntil
         }),
         getDummySignature: async (userOperation) => {
-            return concatHex([
-                await getValidatorSignature(
-                    userOperation.sender,
-                    userOperation.callData.toString().slice(0, 10) as Hex
-                ),
+            const userOpSig =
                 await activeValidator.getDummySignature(userOperation)
-            ])
+            if (entryPointVersion === "v0.6") {
+                return concatHex([
+                    await getValidatorSignature(
+                        userOperation.sender,
+                        userOperation.callData.toString().slice(0, 10) as Hex
+                    ),
+                    userOpSig
+                ])
+            }
+            return await getValidatorSignature(
+                userOperation.sender,
+                userOperation.callData.toString().slice(0, 10) as Hex,
+                userOpSig
+            )
+        },
+        getNonceKey: async (accountAddress = zeroAddress) => {
+            if (entryPointVersion === "v0.6")
+                return await activeValidator.getNonceKey()
+
+            return BigInt(
+                pad(
+                    concatHex([
+                        !regular ||
+                        (await regular.isEnabled(
+                            accountAddress,
+                            executorData.selector
+                        )) ||
+                        (await isPluginInitialized_7579(accountAddress))
+                            ? VALIDATOR_MODE.DEFAULT
+                            : VALIDATOR_MODE.ENABLE, // 1 byte
+                        regular
+                            ? regular.isPermissionValidator
+                                ? VALIDATOR_TYPE.PERMISSION
+                                : VALIDATOR_TYPE.SECONDARY
+                            : VALIDATOR_TYPE.SUDO, // 1 byte
+                        regular?.isPermissionValidator
+                            ? // @ts-ignore
+                              pad(regular.getPermissionId(), {
+                                  size: 20,
+                                  dir: "right"
+                              })
+                            : activeValidator.address, // 20 bytes
+                        pad(toHex(await activeValidator.getNonceKey()), {
+                            size: 2
+                        }) // 10 byte
+                    ]),
+                    { size: 24 }
+                )
+            )
         },
         getPluginEnableSignature,
         getValidatorInitData: async () => {

package/actions/account-client/signUserOperation.ts

@@ -1,8 +1,12 @@
 import type { SmartAccount } from "permissionless/accounts/types"
-import type { SponsorUserOperationMiddleware } from "permissionless/actions/smartAccount"
-import { prepareUserOperationRequest } from "permissionless/actions/smartAccount"
+import {
+    type Middleware,
+    prepareUserOperationRequest
+} from "permissionless/actions/smartAccount"
 import type {
+    EntryPoint,
     GetAccountParameter,
+    GetEntryPointVersion,
     PartialBy,
     Prettify,
     UserOperation
@@ -15,10 +19,13 @@ import {
 import type { Chain, Client, Transport } from "viem"
 
 export type SignUserOperationParameters<
-    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+    entryPoint extends EntryPoint,
+    TAccount extends SmartAccount<entryPoint> | undefined =
+        | SmartAccount<entryPoint>
+        | undefined
 > = {
     userOperation: PartialBy<
-        UserOperation,
+        UserOperation<"v0.6">,
         | "nonce"
         | "sender"
         | "initCode"
@@ -30,30 +37,35 @@ export type SignUserOperationParameters<
         | "verificationGasLimit"
         | "paymasterAndData"
     >
-} & GetAccountParameter<TAccount> &
-    SponsorUserOperationMiddleware
+} & GetAccountParameter<entryPoint, TAccount> &
+    Middleware<entryPoint>
 
-export type SignUserOperationReturnType = UserOperation
+export type SignUserOperationReturnType = UserOperation<"v0.6">
 
 export async function signUserOperation<
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+    TAccount extends SmartAccount<entryPoint> | undefined =
+        | SmartAccount<entryPoint>
+        | undefined
 >(
     client: Client<TTransport, TChain, TAccount>,
-    args: Prettify<SignUserOperationParameters<TAccount>>
+    args: Prettify<SignUserOperationParameters<entryPoint, TAccount>>
 ): Promise<SignUserOperationReturnType> {
     const { account: account_ = client.account } = args
     if (!account_) throw new AccountOrClientNotFoundError()
 
-    const account = parseAccount(account_) as SmartAccount
+    const account = parseAccount(account_) as SmartAccount<entryPoint>
 
     const userOperation = await getAction(
         client,
-        prepareUserOperationRequest
+        prepareUserOperationRequest<entryPoint, TTransport, TChain, TAccount>
     )(args)
 
-    userOperation.signature = await account.signUserOperation(userOperation)
+    userOperation.signature = await account.signUserOperation(
+        userOperation as UserOperation<GetEntryPointVersion<entryPoint>>
+    )
 
-    return userOperation
+    return userOperation as SignUserOperationReturnType
 }

package/actions/paymaster/estimateGasInERC20.ts

@@ -1,3 +1,4 @@
+import type { EntryPoint } from "permissionless/types"
 import type {
     UserOperation,
     UserOperationWithBigIntAsHex
@@ -8,7 +9,7 @@ import { KERNEL_ADDRESSES } from "../../accounts/index.js"
 import type { ZeroDevPaymasterClient } from "../../clients/paymasterClient.js"
 
 export type EstimateGasInERC20Parameters = {
-    userOperation: UserOperation
+    userOperation: UserOperation<"v0.6">
     gasTokenAddress: Hex
     entryPoint?: Address
 }
@@ -26,8 +27,8 @@ export type EstimateGasInERC20ReturnType = {
  * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
  */
 
-export const estimateGasInERC20 = async (
-    client: ZeroDevPaymasterClient,
+export const estimateGasInERC20 = async <entryPoint extends EntryPoint>(
+    client: ZeroDevPaymasterClient<entryPoint>,
     args: EstimateGasInERC20Parameters
 ): Promise<EstimateGasInERC20ReturnType> => {
     const response = await client.request({
@@ -37,7 +38,7 @@ export const estimateGasInERC20 = async (
                 chainId: client.chain?.id as number,
                 userOp: deepHexlify(
                     args.userOperation
-                ) as UserOperationWithBigIntAsHex,
+                ) as UserOperationWithBigIntAsHex<"v0.6">,
                 tokenAddress: args.gasTokenAddress,
                 entryPointAddress:
                     args.entryPoint ?? KERNEL_ADDRESSES.ENTRYPOINT_V0_6