@zerodev/sdk 5.2.0-alpha-4 → 5.2.0

package/accounts/kernel/abi/kernel_v_3_0_0/KernelFactoryStakerAbi.ts

@@ -0,0 +1,199 @@
+export const KernelFactoryStakerAbi = [
+    {
+        type: "constructor",
+        inputs: [{ name: "_owner", type: "address", internalType: "address" }],
+        stateMutability: "nonpayable"
+    },
+    {
+        type: "function",
+        name: "approveFactory",
+        inputs: [
+            {
+                name: "factory",
+                type: "address",
+                internalType: "contract KernelFactory"
+            },
+            { name: "approval", type: "bool", internalType: "bool" }
+        ],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "approved",
+        inputs: [
+            {
+                name: "",
+                type: "address",
+                internalType: "contract KernelFactory"
+            }
+        ],
+        outputs: [{ name: "", type: "bool", internalType: "bool" }],
+        stateMutability: "view"
+    },
+    {
+        type: "function",
+        name: "cancelOwnershipHandover",
+        inputs: [],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "completeOwnershipHandover",
+        inputs: [
+            { name: "pendingOwner", type: "address", internalType: "address" }
+        ],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "deployWithFactory",
+        inputs: [
+            {
+                name: "factory",
+                type: "address",
+                internalType: "contract KernelFactory"
+            },
+            { name: "createData", type: "bytes", internalType: "bytes" },
+            { name: "salt", type: "bytes32", internalType: "bytes32" }
+        ],
+        outputs: [{ name: "", type: "address", internalType: "address" }],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "owner",
+        inputs: [],
+        outputs: [{ name: "result", type: "address", internalType: "address" }],
+        stateMutability: "view"
+    },
+    {
+        type: "function",
+        name: "ownershipHandoverExpiresAt",
+        inputs: [
+            { name: "pendingOwner", type: "address", internalType: "address" }
+        ],
+        outputs: [{ name: "result", type: "uint256", internalType: "uint256" }],
+        stateMutability: "view"
+    },
+    {
+        type: "function",
+        name: "renounceOwnership",
+        inputs: [],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "requestOwnershipHandover",
+        inputs: [],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "stake",
+        inputs: [
+            {
+                name: "entryPoint",
+                type: "address",
+                internalType: "contract IEntryPoint"
+            },
+            { name: "unstakeDelay", type: "uint32", internalType: "uint32" }
+        ],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "transferOwnership",
+        inputs: [
+            { name: "newOwner", type: "address", internalType: "address" }
+        ],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "unlockStake",
+        inputs: [
+            {
+                name: "entryPoint",
+                type: "address",
+                internalType: "contract IEntryPoint"
+            }
+        ],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "function",
+        name: "withdrawStake",
+        inputs: [
+            {
+                name: "entryPoint",
+                type: "address",
+                internalType: "contract IEntryPoint"
+            },
+            {
+                name: "recipient",
+                type: "address",
+                internalType: "address payable"
+            }
+        ],
+        outputs: [],
+        stateMutability: "payable"
+    },
+    {
+        type: "event",
+        name: "OwnershipHandoverCanceled",
+        inputs: [
+            {
+                name: "pendingOwner",
+                type: "address",
+                indexed: true,
+                internalType: "address"
+            }
+        ],
+        anonymous: false
+    },
+    {
+        type: "event",
+        name: "OwnershipHandoverRequested",
+        inputs: [
+            {
+                name: "pendingOwner",
+                type: "address",
+                indexed: true,
+                internalType: "address"
+            }
+        ],
+        anonymous: false
+    },
+    {
+        type: "event",
+        name: "OwnershipTransferred",
+        inputs: [
+            {
+                name: "oldOwner",
+                type: "address",
+                indexed: true,
+                internalType: "address"
+            },
+            {
+                name: "newOwner",
+                type: "address",
+                indexed: true,
+                internalType: "address"
+            }
+        ],
+        anonymous: false
+    },
+    { type: "error", name: "AlreadyInitialized", inputs: [] },
+    { type: "error", name: "NewOwnerIsZeroAddress", inputs: [] },
+    { type: "error", name: "NoHandoverRequest", inputs: [] },
+    { type: "error", name: "NotApprovedFactory", inputs: [] },
+    { type: "error", name: "Unauthorized", inputs: [] }
+] as const

package/accounts/kernel/createKernelAccount.ts

@@ -26,6 +26,7 @@ import {
     getTypesForEIP712Domain,
     hashMessage,
     hashTypedData,
+    toHex,
     validateTypedData,
     zeroAddress
 } from "viem"
@@ -42,6 +43,7 @@ import {
 } from "../utils/toKernelPluginManager.js"
 import { KernelInitAbi } from "./abi/KernelAccountAbi.js"
 import { KernelV3InitAbi } from "./abi/kernel_v_3_0_0/KernelAccountAbi.js"
+import { KernelFactoryStakerAbi } from "./abi/kernel_v_3_0_0/KernelFactoryStakerAbi.js"
 import { encodeCallData as encodeCallDataEpV06 } from "./utils/account/ep0_6/encodeCallData.js"
 import { encodeDeployCallData as encodeDeployCallDataV06 } from "./utils/account/ep0_6/encodeDeployCallData.js"
 import { encodeCallData as encodeCallDataEpV07 } from "./utils/account/ep0_7/encodeCallData.js"
@@ -55,18 +57,20 @@ 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>
 }
 
 export type CreateKernelAccountParameters<entryPoint extends EntryPoint> = {
     plugins:
-        | KernelPluginManagerParams<entryPoint>
+        | Omit<KernelPluginManagerParams<entryPoint>, "entryPoint">
         | KernelPluginManager<entryPoint>
     entryPoint: entryPoint
     index?: bigint
     factoryAddress?: Address
     accountLogicAddress?: Address
+    factoryStakerAddress?: Address
     deployedAccountAddress?: Address
 }
 
@@ -111,13 +115,15 @@ const createAccountAbi = [
 export const KERNEL_ADDRESSES: {
     ACCOUNT_LOGIC_V0_6: Address
     ACCOUNT_LOGIC_V0_7: Address
-    FACTORY_ADDRESS: Address
-    ENTRYPOINT_V0_6: Address
+    FACTORY_ADDRESS_V0_6: Address
+    FACTORY_ADDRESS_V0_7: Address
+    FACTORY_STAKER: Address
 } = {
     ACCOUNT_LOGIC_V0_6: "0xd3082872F8B06073A021b4602e022d5A070d7cfC",
-    ACCOUNT_LOGIC_V0_7: "0x079D5D8A3275A230AF743cB59c341Ff74B82488D",
-    FACTORY_ADDRESS: "0x5de4839a76cf55d0c90e2061ef4386d962E15ae3",
-    ENTRYPOINT_V0_6: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789"
+    ACCOUNT_LOGIC_V0_7: "0x94F097E1ebEB4ecA3AAE54cabb08905B239A7D27",
+    FACTORY_ADDRESS_V0_6: "0x5de4839a76cf55d0c90e2061ef4386d962E15ae3",
+    FACTORY_ADDRESS_V0_7: "0x6723b44Abeec4E71eBE3232BD5B455805baDD22f",
+    FACTORY_STAKER: "0xd703aaE79538628d27099B8c4f621bE4CCd142d5"
 }
 
 const getKernelInitData = async <entryPoint extends EntryPoint>({
@@ -128,7 +134,7 @@ const getKernelInitData = async <entryPoint extends EntryPoint>({
     kernelPluginManager: KernelPluginManager<entryPoint>
 }) => {
     const entryPointVersion = getEntryPointVersion(entryPointAddress)
-    const { enableData, validatorAddress } =
+    const { enableData, identifier, validatorAddress } =
         await kernelPluginManager.getValidatorInitData()
 
     if (entryPointVersion === "v0.6") {
@@ -142,12 +148,7 @@ const getKernelInitData = async <entryPoint extends EntryPoint>({
     return encodeFunctionData({
         abi: KernelV3InitAbi,
         functionName: "initialize",
-        args: [
-            kernelPluginManager.getValidationId(true),
-            zeroAddress,
-            enableData,
-            "0x"
-        ]
+        args: [identifier, zeroAddress, enableData, "0x"]
     })
 }
 
@@ -162,12 +163,14 @@ const getAccountInitCode = async <entryPoint extends EntryPoint>({
     index,
     factoryAddress,
     accountLogicAddress,
+    factoryStakerAddress,
     entryPoint: entryPointAddress,
     kernelPluginManager
 }: {
     index: bigint
     factoryAddress: Address
     accountLogicAddress: Address
+    factoryStakerAddress: Address
     entryPoint: entryPoint
     kernelPluginManager: KernelPluginManager<entryPoint>
 }): Promise<Hex> => {
@@ -176,15 +179,31 @@ const getAccountInitCode = async <entryPoint extends EntryPoint>({
         entryPoint: entryPointAddress,
         kernelPluginManager
     })
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
 
     // Build the account init code
+    if (entryPointVersion === "v0.6") {
+        return concatHex([
+            factoryAddress,
+            encodeFunctionData({
+                abi: createAccountAbi,
+                functionName: "createAccount",
+                args: [accountLogicAddress, initialisationData, index]
+            }) as Hex
+        ])
+    }
+
     return concatHex([
-        factoryAddress,
+        factoryStakerAddress,
         encodeFunctionData({
-            abi: createAccountAbi,
-            functionName: "createAccount",
-            args: [accountLogicAddress, initialisationData, index]
-        }) as Hex
+            abi: KernelFactoryStakerAbi,
+            functionName: "deployWithFactory",
+            args: [
+                factoryAddress,
+                initialisationData,
+                toHex(index, { size: 32 })
+            ]
+        })
     ])
 }
 
@@ -248,8 +267,9 @@ export async function createKernelAccount<
         plugins,
         entryPoint: entryPointAddress,
         index = 0n,
-        factoryAddress = KERNEL_ADDRESSES.FACTORY_ADDRESS,
+        factoryAddress = KERNEL_ADDRESSES.FACTORY_ADDRESS_V0_6,
         accountLogicAddress = KERNEL_ADDRESSES.ACCOUNT_LOGIC_V0_6,
+        factoryStakerAddress = KERNEL_ADDRESSES.FACTORY_STAKER,
         deployedAccountAddress
     }: CreateKernelAccountParameters<entryPoint>
 ): Promise<KernelSmartAccount<entryPoint, TTransport, TChain>> {
@@ -258,13 +278,17 @@ export async function createKernelAccount<
         entryPointVersion === "v0.6"
             ? KERNEL_ADDRESSES.ACCOUNT_LOGIC_V0_6
             : KERNEL_ADDRESSES.ACCOUNT_LOGIC_V0_7
+    factoryAddress =
+        entryPointVersion === "v0.6"
+            ? KERNEL_ADDRESSES.FACTORY_ADDRESS_V0_6
+            : KERNEL_ADDRESSES.FACTORY_ADDRESS_V0_7
 
     const kernelPluginManager = isKernelPluginManager<entryPoint>(plugins)
         ? plugins
         : await toKernelPluginManager<entryPoint>(client, {
               sudo: plugins.sudo,
               regular: plugins.regular,
-              executorData: plugins.executorData,
+              action: plugins.action,
               pluginEnableSignature: plugins.pluginEnableSignature,
               entryPoint: entryPointAddress
           })
@@ -274,6 +298,7 @@ export async function createKernelAccount<
             index,
             factoryAddress,
             accountLogicAddress,
+            factoryStakerAddress,
             entryPoint: entryPointAddress,
             kernelPluginManager
         })
@@ -335,7 +360,11 @@ export async function createKernelAccount<
 
                 if (smartAccountDeployed) return undefined
 
-                return factoryAddress
+                const entryPointVersion =
+                    getEntryPointVersion(entryPointAddress)
+                return entryPointVersion === "v0.6"
+                    ? factoryAddress
+                    : factoryStakerAddress
             },
 
             async getFactoryData() {
@@ -379,7 +408,7 @@ export async function createKernelAccount<
                 }
 
                 return concatHex([
-                    kernelPluginManager.getValidationId(),
+                    kernelPluginManager.getIdentifier(),
                     signature
                 ])
             },
@@ -428,14 +457,16 @@ export async function createKernelAccount<
                     return signature
                 }
                 return concatHex([
-                    kernelPluginManager.getValidationId(),
+                    kernelPluginManager.getIdentifier(),
                     signature
                 ])
             },
             // Get the nonce of the smart account
-            async getNonce() {
-                const key =
-                    await kernelPluginManager.getNonceKey(accountAddress)
+            async getNonce(customNonceKey?: bigint) {
+                const key = await kernelPluginManager.getNonceKey(
+                    accountAddress,
+                    customNonceKey
+                )
                 return getAccountNonce(client, {
                     sender: accountAddress,
                     entryPoint: entryPointAddress,

package/accounts/kernel/utils/account/ep0_7/getKernelV3Nonce.ts

@@ -0,0 +1,24 @@
+import { getAction } from "permissionless"
+import type { Address, Client } from "viem"
+import { readContract } from "viem/actions"
+import { KernelV3AccountAbi } from "../../../abi/kernel_v_3_0_0/KernelAccountAbi.js"
+
+export const getKernelV3Nonce = async (
+    client: Client,
+    accountAddress: Address
+): Promise<number> => {
+    try {
+        const nonce = await getAction(
+            client,
+            readContract
+        )({
+            abi: KernelV3AccountAbi,
+            address: accountAddress,
+            functionName: "currentNonce",
+            args: []
+        })
+        return nonce
+    } catch (error) {
+        return 1
+    }
+}

package/accounts/kernel/utils/common/getActionSelector.ts

@@ -0,0 +1,20 @@
+import type { EntryPointVersion } from "permissionless/types/entrypoint"
+import { type Hex, getAbiItem, toFunctionSelector } from "viem"
+import { KernelAccountAbi } from "../../abi/KernelAccountAbi.js"
+import { KernelV3AccountAbi } from "../../abi/kernel_v_3_0_0/KernelAccountAbi.js"
+
+export const getActionSelector = (
+    entryPointVersion: EntryPointVersion
+): Hex => {
+    if (entryPointVersion === "v0.6") {
+        return toFunctionSelector(
+            getAbiItem({ abi: KernelAccountAbi, name: "execute" })
+        )
+    } else if (entryPointVersion === "v0.7") {
+        return toFunctionSelector(
+            getAbiItem({ abi: KernelV3AccountAbi, name: "execute" })
+        )
+    } else {
+        throw new Error("Unsupported entry point version")
+    }
+}

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

@@ -0,0 +1,39 @@
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "permissionless/types/entrypoint"
+import { type Address, type Hex, concat, pad, toHex } from "viem"
+import {
+    type PluginValidityData,
+    ValidatorMode
+} from "../../../../../types/index.js"
+import type { Kernel2_0_plugins } from "./getPluginsEnableTypedData.js"
+
+export const getEncodedPluginsData = async <
+    entryPoint extends EntryPoint = ENTRYPOINT_ADDRESS_V06_TYPE
+>({
+    accountAddress,
+    enableSignature,
+    action,
+    validator,
+    validUntil,
+    validAfter
+}: {
+    accountAddress: Address
+    enableSignature: Hex
+} & Kernel2_0_plugins<entryPoint> &
+    PluginValidityData) => {
+    const enableData = await validator.getEnableData(accountAddress)
+    const enableDataLength = enableData.length / 2 - 1
+    return concat([
+        ValidatorMode.enable,
+        pad(toHex(validUntil, { size: 6 }), { size: 6 }), // 6 bytes 4 - 10
+        pad(toHex(validAfter), { size: 6 }), // 6 bytes 10 - 16
+        pad(validator.address, { size: 20 }), // 20 bytes 16 - 36
+        pad(action.address, { 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
+    ])
+}

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

@@ -0,0 +1,76 @@
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "permissionless/types/entrypoint"
+import {
+    type Address,
+    type CustomSource,
+    concatHex,
+    hexToBigInt,
+    pad,
+    toHex
+} from "viem"
+import type {
+    Action,
+    KernelValidator,
+    PluginValidityData
+} from "../../../../../types/index.js"
+
+export type Kernel2_0_plugins<entryPoint extends EntryPoint> = {
+    validator: KernelValidator<entryPoint>
+    action: Action
+}
+export const getPluginsEnableTypedData = async <
+    entryPoint extends EntryPoint = ENTRYPOINT_ADDRESS_V06_TYPE
+>({
+    accountAddress,
+    chainId,
+    kernelVersion,
+    action,
+    validator,
+    validUntil,
+    validAfter
+}: {
+    accountAddress: Address
+    chainId: number
+    kernelVersion: string
+    // { action, validator }: Kernel2_0_plugins
+} & Kernel2_0_plugins<entryPoint> &
+    PluginValidityData): Promise<
+    Parameters<CustomSource["signTypedData"]>[0]
+> => {
+    return {
+        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: action.selector,
+            validatorData: hexToBigInt(
+                concatHex([
+                    pad(toHex(validUntil ?? 0), {
+                        size: 6
+                    }),
+                    pad(toHex(validAfter ?? 0), {
+                        size: 6
+                    }),
+                    validator.address
+                ]),
+                { size: 32 }
+            ),
+            executor: action.address as Address,
+            enableData: await validator.getEnableData(accountAddress)
+        },
+        primaryType: "ValidatorApproved"
+    }
+}

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

@@ -0,0 +1,47 @@
+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",
+                // [TODO]: Integrate custom target contract and hook
+                concat([
+                    action.selector /*, action.address, zeroAddress, "0x"*/
+                ]),
+                enableSignature,
+                userOpSignature
+            ]
+        )
+    ])
+}

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

@@ -0,0 +1,63 @@
+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"
+    }
+}