@zerodev/sdk 5.2.0-alpha-4 → 5.2.1-alpha-1

package/accounts/kernel/utils/plugins/ep0_7/getEncodedPluginsData.ts

@@ -0,0 +1,44 @@
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "permissionless/types/entrypoint"
+import {
+    type Address,
+    type Hex,
+    concat,
+    encodeAbiParameters,
+    parseAbiParameters,
+    zeroAddress
+} from "viem"
+import type { Kernel2_0_plugins } from "../ep0_6/getPluginsEnableTypedData.js"
+
+export const getEncodedPluginsData = async <
+    entryPoint extends EntryPoint = ENTRYPOINT_ADDRESS_V06_TYPE
+>({
+    accountAddress,
+    enableSignature,
+    userOpSignature,
+    action,
+    validator
+}: {
+    accountAddress: Address
+    enableSignature: Hex
+    userOpSignature: Hex
+} & Kernel2_0_plugins<entryPoint>) => {
+    const enableData = await validator.getEnableData(accountAddress)
+    return concat([
+        zeroAddress, // hook address 20 bytes
+        encodeAbiParameters(
+            parseAbiParameters(
+                "bytes validatorData, bytes hookData, bytes selectorData, bytes enableSig, bytes userOpSig"
+            ),
+            [
+                enableData,
+                "0x",
+                concat([action.selector, action.address, zeroAddress, "0x"]),
+                enableSignature,
+                userOpSignature
+            ]
+        )
+    ])
+}

package/accounts/kernel/utils/plugins/ep0_7/getPluginsEnableTypedData.ts

@@ -0,0 +1,61 @@
+import type {
+    ENTRYPOINT_ADDRESS_V07_TYPE,
+    EntryPoint
+} from "permissionless/types/entrypoint"
+import { type Address, type CustomSource, concat, pad, zeroAddress } from "viem"
+import { VALIDATOR_TYPE } from "../../../../../constants.js"
+import type { Kernel2_0_plugins } from "../ep0_6/getPluginsEnableTypedData.js"
+
+export const getPluginsEnableTypedData = async <
+    entryPoint extends EntryPoint = ENTRYPOINT_ADDRESS_V07_TYPE
+>({
+    accountAddress,
+    chainId,
+    kernelVersion,
+    action,
+    validator,
+    validatorNonce
+}: {
+    accountAddress: Address
+    chainId: number
+    kernelVersion: string
+    validatorNonce: number
+} & Kernel2_0_plugins<entryPoint>): Promise<
+    Parameters<CustomSource["signTypedData"]>[0]
+> => {
+    return {
+        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([
+                VALIDATOR_TYPE[validator.validatorType],
+                pad(validator.getIdentifier(), { size: 20, dir: "right" })
+            ]),
+            nonce: validatorNonce,
+            hook: zeroAddress,
+            validatorData: await validator.getEnableData(accountAddress),
+            hookData: "0x",
+            selectorData: concat([
+                action.selector,
+                action.address,
+                zeroAddress,
+                "0x"
+            ])
+        },
+        primaryType: "Enable"
+    }
+}

package/accounts/kernel/utils/plugins/ep0_7/isPluginInitialized.ts

@@ -0,0 +1,23 @@
+import { getAction } from "permissionless"
+import type { Address, Client } from "viem"
+import { readContract } from "viem/actions"
+import { KernelModuleIsInitializedAbi } from "../../../abi/kernel_v_3_0_0/KernelModuleAbi.js"
+
+export const isPluginInitialized = async (
+    client: Client,
+    accountAddress: Address,
+    pluginAddress: Address
+) => {
+    try {
+        return await getAction(
+            client,
+            readContract
+        )({
+            abi: KernelModuleIsInitializedAbi,
+            address: pluginAddress,
+            functionName: "isInitialized",
+            args: [accountAddress]
+        })
+    } catch (error) {}
+    return false
+}

package/accounts/kernel/v1/createKernelV1Account.ts

@@ -1,6 +1,7 @@
 import {
     ENTRYPOINT_ADDRESS_V06,
     getAccountNonce,
+    getEntryPointVersion,
     getSenderAddress,
     getUserOperationHash,
     isSmartAccountDeployed
@@ -9,7 +10,10 @@ import {
     SignTransactionNotSupportedBySmartAccount,
     type SmartAccountSigner
 } from "permissionless/accounts"
-import type { EntryPoint } from "permissionless/types/entrypoint.js"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "permissionless/types/entrypoint.js"
 import {
     type Address,
     type Chain,
@@ -96,15 +100,20 @@ export async function createKernelV1Account<
     client: Client<TTransport, TChain, undefined>,
     {
         signer,
-        entrypoint: entryPointAddress = ENTRYPOINT_ADDRESS_V06 as entryPoint,
+        entrypoint: entryPointAddress,
         index = 0n
     }: {
         signer: SmartAccountSigner<TSource, TAddress>
-        entrypoint?: entryPoint
+        entrypoint: entryPoint
         index?: bigint
     }
 ): Promise<KernelV1SmartAccount<entryPoint, TTransport, TChain>> {
-    if (entryPointAddress !== ENTRYPOINT_ADDRESS_V06) {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (
+        entryPointVersion !== "v0.6" ||
+        entryPointAddress !== ENTRYPOINT_ADDRESS_V06
+    ) {
         throw new Error("Only EntryPoint 0.6 is supported")
     }
 
@@ -130,10 +139,13 @@ export async function createKernelV1Account<
     }
 
     const initCode = await generateInitCode()
-    const accountAddress = await getSenderAddress(client, {
-        initCode,
-        entryPoint: entryPointAddress
-    })
+    const accountAddress = await getSenderAddress<ENTRYPOINT_ADDRESS_V06_TYPE>(
+        client,
+        {
+            initCode,
+            entryPoint: entryPointAddress
+        }
+    )
 
     if (!accountAddress) throw new Error("Account address not found")
 

package/accounts/kernel/v2/createKernelV2Account.ts

@@ -1,6 +1,6 @@
 import {
-    ENTRYPOINT_ADDRESS_V06,
     getAccountNonce,
+    getEntryPointVersion,
     getSenderAddress,
     isSmartAccountDeployed
 } from "permissionless"
@@ -56,6 +56,8 @@ export type KernelSmartAccount<
     chain extends Chain | undefined = Chain | undefined
 > = SmartAccount<entryPoint, "kernelSmartAccount", transport, chain> & {
     kernelPluginManager: KernelPluginManager<entryPoint>
+    getNonce: (customNonceKey?: bigint) => Promise<bigint>
+    generateInitCode: () => Promise<Hex>
     encodeCallData: (args: KernelEncodeCallDataArgs) => Promise<Hex>
 }
 
@@ -154,7 +156,7 @@ export async function createKernelV2Account<
     client: Client<TTransport, TChain, undefined>,
     {
         plugins,
-        entryPoint: entryPointAddress = ENTRYPOINT_ADDRESS_V06 as entryPoint,
+        entryPoint: entryPointAddress,
         index = 0n,
         factoryAddress = KERNEL_ADDRESSES.FACTORY_ADDRESS,
         deployedAccountAddress
@@ -162,18 +164,23 @@ export async function createKernelV2Account<
         plugins:
             | KernelPluginManagerParams<entryPoint>
             | KernelPluginManager<entryPoint>
-        entryPoint?: entryPoint
+        entryPoint: entryPoint
         index?: bigint
         factoryAddress?: Address
         deployedAccountAddress?: Address
     }
 ): Promise<KernelSmartAccount<entryPoint, TTransport, TChain>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (entryPointVersion !== "v0.6") {
+        throw new Error("Only EntryPoint 0.6 is supported")
+    }
     const kernelPluginManager = isKernelPluginManager<entryPoint>(plugins)
         ? plugins
         : await toKernelPluginManager(client, {
               sudo: plugins.sudo,
               regular: plugins.regular,
-              executorData: plugins.executorData,
+              action: plugins.action,
               pluginEnableSignature: plugins.pluginEnableSignature,
               kernelVersion: "0.0.2" ?? plugins.kernelVersion,
               entryPoint: entryPointAddress
@@ -281,6 +288,7 @@ export async function createKernelV2Account<
         entryPoint: entryPointAddress,
         source: "kernelSmartAccount",
         kernelPluginManager,
+        generateInitCode,
         async getFactory() {
             if (smartAccountDeployed) return undefined
 
@@ -310,8 +318,11 @@ export async function createKernelV2Account<
         },
 
         // Get the nonce of the smart account
-        async getNonce() {
-            const key = await kernelPluginManager.getNonceKey()
+        async getNonce(customNonceKey?: bigint) {
+            const key = await kernelPluginManager.getNonceKey(
+                accountAddress,
+                customNonceKey
+            )
             return getAccountNonce(client, {
                 sender: accountAddress,
                 entryPoint: entryPointAddress,