@zerodev/sdk 5.2.0-alpha-3 → 5.2.0

package/accounts/utils/toKernelPluginManager.ts

@@ -1,4 +1,4 @@
-import { getAction, getEntryPointVersion } from "permissionless"
+import { getEntryPointVersion } from "permissionless"
 import type { EntryPoint } from "permissionless/types/entrypoint"
 import {
     type Address,
@@ -8,25 +8,27 @@ import {
     type Transport,
     concat,
     concatHex,
-    encodeAbiParameters,
-    hexToBigInt,
+    maxUint16,
+    maxUint192,
     pad,
-    parseAbiParameters,
-    toFunctionSelector,
     toHex,
     zeroAddress
 } from "viem"
-import { getChainId, readContract } from "viem/actions"
+import { getChainId } 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"
+import { getKernelV3Nonce } from "../kernel/utils/account/ep0_7/getKernelV3Nonce.js"
+import { accountMetadata } from "../kernel/utils/common/accountMetadata.js"
+import { getActionSelector } from "../kernel/utils/common/getActionSelector.js"
+import { getEncodedPluginsData as getEncodedPluginsDataV1 } from "../kernel/utils/plugins/ep0_6/getEncodedPluginsData.js"
+import { getPluginsEnableTypedData as getPluginsEnableTypedDataV1 } from "../kernel/utils/plugins/ep0_6/getPluginsEnableTypedData.js"
+import { getEncodedPluginsData as getEncodedPluginsDataV2 } from "../kernel/utils/plugins/ep0_7/getEncodedPluginsData.js"
+import { getPluginsEnableTypedData as getPluginsEnableTypedDataV2 } from "../kernel/utils/plugins/ep0_7/getPluginsEnableTypedData.js"
+import { isPluginInitialized } from "../kernel/utils/plugins/ep0_7/isPluginInitialized.js"
 
 export function isKernelPluginManager<entryPoint extends EntryPoint>(
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
@@ -46,12 +48,7 @@ export async function toKernelPluginManager<
         regular,
         pluginEnableSignature,
         validatorInitData,
-        executorData = {
-            executor: zeroAddress,
-            selector: toFunctionSelector(
-                "execute(address, uint256, bytes, uint8)"
-            )
-        },
+        action,
         validAfter = 0,
         validUntil = 0,
         entryPoint: entryPointAddress,
@@ -64,36 +61,41 @@ export async function toKernelPluginManager<
     if (!activeValidator) {
         throw new Error("One of `sudo` or `regular` validator must be set")
     }
-    const getValidatorSignature = async (
+    action = {
+        selector: action?.selector ?? getActionSelector(entryPointVersion),
+        address: action?.address ?? zeroAddress
+    }
+    if (!action) {
+        throw new Error("Action data must be set")
+    }
+
+    const getSignatureData = async (
         accountAddress: Address,
         selector: Hex,
-        sig?: Hex
+        userOpSignature: Hex = "0x"
     ): Promise<Hex> => {
+        if (!action) {
+            throw new Error("Action data must be set")
+        }
         if (entryPointVersion === "v0.6") {
             if (regular) {
-                if (await regular.isEnabled(accountAddress, selector)) {
+                if (await isPluginEnabled(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
-                ])
+                return getEncodedPluginsDataV1({
+                    accountAddress,
+                    enableSignature,
+                    action,
+                    validator: regular,
+                    validUntil,
+                    validAfter
+                })
             } else if (sudo) {
                 return ValidatorMode.sudo
             } else {
@@ -103,60 +105,43 @@ export async function toKernelPluginManager<
             }
         }
         if (regular) {
-            if (
-                (await isPluginInitialized_7579(accountAddress)) ||
-                (await regular.isEnabled(accountAddress, selector))
-            ) {
-                return sig ?? "0x"
+            if (await isPluginEnabled(accountAddress, action.selector)) {
+                return userOpSignature
             }
-            const enableData = await regular.getEnableData(accountAddress)
             const enableSignature =
                 await getPluginEnableSignature(accountAddress)
-            return concat([
-                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"
-                    ]
-                )
-            ])
+            return getEncodedPluginsDataV2({
+                accountAddress,
+                action,
+                enableSignature,
+                userOpSignature,
+                validator: regular
+            })
         } else if (sudo) {
-            return sig ?? "0x"
+            return userOpSignature
         } 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 isPluginEnabled = async (accountAddress: Address, selector: Hex) => {
+        if (!action) {
+            throw new Error("Action data must be set")
+        }
+        if (!regular) throw new Error("regular validator not set")
+        if (entryPointVersion === "v0.6") {
+            return regular.isEnabled(accountAddress, selector)
+        }
+        return (
+            (await regular.isEnabled(accountAddress, action.selector)) ||
+            (await isPluginInitialized(client, accountAddress, regular.address))
+        )
     }
 
     const getPluginEnableSignature = async (accountAddress: Address) => {
+        if (!action) {
+            throw new Error("Action data must be set")
+        }
         if (pluginEnableSignature) return pluginEnableSignature
         if (!sudo)
             throw new Error(
@@ -164,153 +149,74 @@ export async function toKernelPluginManager<
             )
         if (!regular) throw new Error("regular validator not set")
 
-        const kernelImplAddr = await getKernelImplementationAddress(
+        const { version } = await accountMetadata(
             client,
-            accountAddress
+            accountAddress,
+            entryPointAddress
         )
-        const _kernelVersion =
-            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"
+            const typeData = await getPluginsEnableTypedDataV1({
+                accountAddress,
+                chainId,
+                kernelVersion: kernelVersion ?? version,
+                action,
+                validator: regular,
+                validUntil,
+                validAfter
             })
+            ownerSig = await sudo.signTypedData(typeData)
             pluginEnableSignature = ownerSig
             return ownerSig
         }
-        ownerSig = await sudo.signTypedData({
-            domain: {
-                name: "Kernel",
-                version: _kernelVersion,
-                chainId,
-                verifyingContract: accountAddress
-            },
-            types: {
-                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: {
-                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: "Enable"
+        const validatorNonce = await getKernelV3Nonce(client, accountAddress)
+        const typedData = await getPluginsEnableTypedDataV2({
+            accountAddress,
+            chainId,
+            kernelVersion: version,
+            action,
+            validator: regular,
+            validatorNonce
         })
+        ownerSig = await sudo.signTypedData(typedData)
 
         return ownerSig
     }
-
-    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
-        }
+    const getIdentifier = (isSudo = false) => {
+        const validator = (isSudo ? sudo : regular) ?? activeValidator
+        return concat([
+            VALIDATOR_TYPE[validator.validatorType],
+            validator.getIdentifier()
+        ])
     }
 
     return {
         ...activeValidator,
-        getValidationId: (isSudo = false) => {
-            const validator = (isSudo ? sudo : regular) ?? activeValidator
-            return concat([
-                validator.isPermissionValidator
-                    ? VALIDATOR_TYPE.PERMISSION
-                    : VALIDATOR_TYPE.SECONDARY,
-                validator?.isPermissionValidator
-                    ? // @ts-ignore
-                      pad(validator.getPermissionId() as Hex, {
-                          size: 20,
-                          dir: "right"
-                      })
-                    : validator.address
-            ])
-        },
+        getIdentifier,
         signUserOperation: async (userOperation) => {
             const userOpSig =
                 await activeValidator.signUserOperation(userOperation)
             if (entryPointVersion === "v0.6") {
                 return concatHex([
-                    await getValidatorSignature(
+                    await getSignatureData(
                         userOperation.sender,
                         userOperation.callData.toString().slice(0, 10) as Hex
                     ),
                     userOpSig
                 ])
             }
-            return await getValidatorSignature(
+            return await getSignatureData(
                 userOperation.sender,
                 userOperation.callData.toString().slice(0, 10) as Hex,
                 userOpSig
             )
         },
-        getExecutorData: () => executorData,
+        getAction: () => {
+            if (!action) {
+                throw new Error("Action data must be set")
+            }
+            return action
+        },
         getValidityData: () => ({
             validAfter,
             validUntil
@@ -320,53 +226,76 @@ export async function toKernelPluginManager<
                 await activeValidator.getDummySignature(userOperation)
             if (entryPointVersion === "v0.6") {
                 return concatHex([
-                    await getValidatorSignature(
+                    await getSignatureData(
                         userOperation.sender,
                         userOperation.callData.toString().slice(0, 10) as Hex
                     ),
                     userOpSig
                 ])
             }
-            return await getValidatorSignature(
+            return await getSignatureData(
                 userOperation.sender,
                 userOperation.callData.toString().slice(0, 10) as Hex,
                 userOpSig
             )
         },
-        getNonceKey: async (accountAddress = zeroAddress) => {
-            if (entryPointVersion === "v0.6")
-                return await activeValidator.getNonceKey()
+        getNonceKey: async (
+            accountAddress = zeroAddress,
+            customNonceKey = 0n
+        ) => {
+            if (!action) {
+                throw new Error("Action data must be set")
+            }
+            if (entryPointVersion === "v0.6") {
+                if (customNonceKey > maxUint192) {
+                    throw new Error(
+                        "Custom nonce key must be equal or less than maxUint192 for v0.6"
+                    )
+                }
 
-            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 }
+                return await activeValidator.getNonceKey(
+                    accountAddress,
+                    customNonceKey
+                )
+            }
+
+            if (customNonceKey > maxUint16)
+                throw new Error(
+                    "Custom nonce key must be equal or less than 2 bytes(maxUint16) for v0.7"
                 )
+
+            const validatorMode =
+                !regular ||
+                (await isPluginEnabled(accountAddress, action.selector))
+                    ? VALIDATOR_MODE.DEFAULT
+                    : VALIDATOR_MODE.ENABLE
+            const validatorType = regular
+                ? VALIDATOR_TYPE[regular.validatorType]
+                : VALIDATOR_TYPE.SUDO
+            const encoding = pad(
+                concatHex([
+                    validatorMode, // 1 byte
+                    validatorType, // 1 byte
+                    pad(activeValidator.getIdentifier(), {
+                        size: 20,
+                        dir: "right"
+                    }), // 20 bytes
+                    pad(
+                        toHex(
+                            await activeValidator.getNonceKey(
+                                accountAddress,
+                                customNonceKey
+                            )
+                        ),
+                        {
+                            size: 2
+                        }
+                    ) // 2 byte
+                ]),
+                { size: 24 }
             )
+            const encodedNonceKey = BigInt(encoding)
+            return encodedNonceKey
         },
         getPluginEnableSignature,
         getValidatorInitData: async () => {
@@ -376,7 +305,9 @@ export async function toKernelPluginManager<
 
                 enableData:
                     (await sudo?.getEnableData()) ??
-                    (await activeValidator.getEnableData())
+                    (await activeValidator.getEnableData()),
+
+                identifier: pad(getIdentifier(true), { size: 21, dir: "right" })
             }
         }
     }

package/actions/account-client/getUserOperationGasPrice.ts

@@ -0,0 +1,26 @@
+import type { Account, Chain, Client, Transport } from "viem"
+import type { Prettify } from "viem/chains"
+import type { ZeroDevAccountClientRpcSchema } from "../../types/kernel.js"
+
+export type GetUserOperationGasPriceReturnType = {
+    maxFeePerGas: bigint
+    maxPriorityFeePerGas: bigint
+}
+
+export const getUserOperationGasPrice = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined
+>(
+    client: Client<TTransport, TChain, TAccount, ZeroDevAccountClientRpcSchema>
+): Promise<Prettify<GetUserOperationGasPriceReturnType>> => {
+    const gasPrice = await client.request({
+        method: "zd_getUserOperationGasPrice",
+        params: []
+    })
+
+    return {
+        maxFeePerGas: BigInt(gasPrice.standard.maxFeePerGas),
+        maxPriorityFeePerGas: BigInt(gasPrice.standard.maxPriorityFeePerGas)
+    }
+}

package/actions/index.ts

@@ -10,6 +10,11 @@ export {
     type SignUserOperationReturnType
 } from "./account-client/signUserOperation.js"
 
+export {
+    getUserOperationGasPrice,
+    type GetUserOperationGasPriceReturnType
+} from "./account-client/getUserOperationGasPrice.js"
+
 export {
     estimateGasInERC20,
     type EstimateGasInERC20Parameters,

package/actions/paymaster/estimateGasInERC20.ts

@@ -1,3 +1,4 @@
+import { ENTRYPOINT_ADDRESS_V06 } from "permissionless"
 import type { EntryPoint } from "permissionless/types"
 import type {
     UserOperation,
@@ -5,7 +6,6 @@ import type {
 } from "permissionless/types/userOperation.js"
 import { deepHexlify } from "permissionless/utils"
 import type { Address, Hex } from "viem"
-import { KERNEL_ADDRESSES } from "../../accounts/index.js"
 import type { ZeroDevPaymasterClient } from "../../clients/paymasterClient.js"
 
 export type EstimateGasInERC20Parameters = {
@@ -40,8 +40,7 @@ export const estimateGasInERC20 = async <entryPoint extends EntryPoint>(
                     args.userOperation
                 ) as UserOperationWithBigIntAsHex<"v0.6">,
                 tokenAddress: args.gasTokenAddress,
-                entryPointAddress:
-                    args.entryPoint ?? KERNEL_ADDRESSES.ENTRYPOINT_V0_6
+                entryPointAddress: args.entryPoint ?? ENTRYPOINT_ADDRESS_V06
             }
         ]
     })

package/actions/paymaster/sponsorUserOperation.ts

@@ -10,7 +10,6 @@ import type {
 import { ENTRYPOINT_ADDRESS_V06, deepHexlify } from "permissionless/utils"
 import type { Address, Hex } from "viem"
 import type { PartialBy } from "viem/types/utils"
-import { KERNEL_ADDRESSES } from "../../accounts/index.js"
 import type { ZeroDevPaymasterClient } from "../../clients/paymasterClient.js"
 
 export type SponsorUserOperationParameters<entryPoint extends EntryPoint> = {
@@ -70,8 +69,7 @@ export const sponsorUserOperation = async <entryPoint extends EntryPoint>(
                 ) as UserOperationWithBigIntAsHex<
                     GetEntryPointVersion<entryPoint>
                 >,
-                entryPointAddress:
-                    args.entryPoint ?? KERNEL_ADDRESSES.ENTRYPOINT_V0_6,
+                entryPointAddress: args.entryPoint,
                 gasTokenData: args.gasToken && {
                     tokenAddress: args.gasToken
                 },

package/clients/decorators/kernel.ts

@@ -1,8 +1,12 @@
 import { type SmartAccountActions, smartAccountActions } from "permissionless"
 import type { SmartAccount } from "permissionless/accounts/types"
 import { type Middleware } from "permissionless/actions/smartAccount"
-import type { EntryPoint } from "permissionless/types"
+import type { EntryPoint, Prettify } from "permissionless/types"
 import type { Chain, Client, Transport } from "viem"
+import {
+    type GetUserOperationGasPriceReturnType,
+    getUserOperationGasPrice
+} from "../../actions/account-client/getUserOperationGasPrice.js"
 import type {
     SignUserOperationParameters,
     SignUserOperationReturnType
@@ -38,10 +42,13 @@ export const zerodevPaymasterActions =
         sponsorUserOperation: async (
             args: Omit<SponsorUserOperationParameters<entryPoint>, "entryPoint">
         ) =>
-            sponsorUserOperation(client as ZeroDevPaymasterClient<entryPoint>, {
-                ...args,
-                entryPoint: entryPointAddress
-            }),
+            sponsorUserOperation<entryPoint>(
+                client as ZeroDevPaymasterClient<entryPoint>,
+                {
+                    ...args,
+                    entryPoint: entryPointAddress
+                }
+            ),
         estimateGasInERC20: async (args: EstimateGasInERC20Parameters) =>
             estimateGasInERC20(
                 client as ZeroDevPaymasterClient<entryPoint>,
@@ -72,6 +79,14 @@ export type KernelAccountClientActions<
             >
         >[1]
     ) => Promise<SignUserOperationReturnType>
+    /**
+     * Returns the live gas prices that you can use to send a user operation.
+     *
+     * @returns maxFeePerGas & maxPriorityFeePerGas {@link GetUserOperationGasPriceReturnType}
+     */
+    getUserOperationGasPrice: () => Promise<
+        Prettify<GetUserOperationGasPriceReturnType>
+    >
 }
 
 export const kernelAccountClientActions =
@@ -93,5 +108,6 @@ export const kernelAccountClientActions =
                     ...args,
                     middleware
                 } as SignUserOperationParameters<entryPoint, TSmartAccount>
-            )
+            ),
+        getUserOperationGasPrice: async () => getUserOperationGasPrice(client)
     })