@zerodev/sdk 5.1.12 → 5.2.0-alpha-0

package/accounts/kernel/createKernelAccount.ts

@@ -1,8 +1,18 @@
-import { getAccountNonce, getAction, getSenderAddress } from "permissionless"
+import {
+    getAccountNonce,
+    getEntryPointVersion,
+    getSenderAddress,
+    isSmartAccountDeployed
+} from "permissionless"
 import {
     SignTransactionNotSupportedBySmartAccount,
     type SmartAccount
 } from "permissionless/accounts"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    ENTRYPOINT_ADDRESS_V07_TYPE,
+    EntryPoint
+} from "permissionless/types"
 import {
     type Address,
     type Chain,
@@ -21,37 +31,63 @@ import {
     hashMessage,
     hashTypedData,
     keccak256,
+    pad,
     parseAbi,
+    parseAbiParameters,
     publicActions,
     stringToHex,
-    validateTypedData
+    validateTypedData,
+    zeroAddress
 } from "viem"
 import { toAccount } from "viem/accounts"
-import { getBytecode, getStorageAt } from "viem/actions"
-import { KERNEL_NAME } from "../../constants.js"
+import { CALL_TYPE, EXEC_TYPE, KERNEL_NAME } from "../../constants.js"
 import type {
     KernelEncodeCallDataArgs,
     KernelPluginManager,
     KernelPluginManagerParams
 } from "../../types/kernel.js"
-import { getKernelVersion } from "../../utils.js"
-import { wrapSignatureWith6492 } from "../utils/6492.js"
+import {
+    KERNEL_FEATURES,
+    getExecMode,
+    getKernelVersion,
+    hasKernelFeature
+} from "../../utils.js"
+import {
+    getKernelImplementationAddress,
+    wrapSignatureWith6492
+} from "../utils/6492.js"
 import { parseFactoryAddressAndCallDataFromAccountInitCode } from "../utils/index.js"
 import {
     isKernelPluginManager,
     toKernelPluginManager
 } from "../utils/toKernelPluginManager.js"
 import { KernelExecuteAbi, KernelInitAbi } from "./abi/KernelAccountAbi.js"
+import {
+    KernelV3ExecuteAbi,
+    KernelV3InitAbi
+} from "./abi/kernel_v_3_0_0/KernelAccountAbi.js"
 
 export type KernelSmartAccount<
+    entryPoint extends EntryPoint,
     transport extends Transport = Transport,
     chain extends Chain | undefined = Chain | undefined
-> = SmartAccount<"kernelSmartAccount", transport, chain> & {
-    kernelPluginManager: KernelPluginManager
+> = SmartAccount<entryPoint, "kernelSmartAccount", transport, chain> & {
+    kernelPluginManager: KernelPluginManager<entryPoint>
     generateInitCode: () => Promise<Hex>
     encodeCallData: (args: KernelEncodeCallDataArgs) => Promise<Hex>
 }
 
+export type CreateKernelAccountParameters<entryPoint extends EntryPoint> = {
+    plugins:
+        | KernelPluginManagerParams<entryPoint>
+        | KernelPluginManager<entryPoint>
+    entryPoint: entryPoint
+    index?: bigint
+    factoryAddress?: Address
+    accountLogicAddress?: Address
+    deployedAccountAddress?: Address
+}
+
 /**
  * The account creation ABI for a kernel smart account (from the KernelFactory)
  */
@@ -133,15 +169,51 @@ export const EIP1271ABI = [
  * Default addresses for kernel smart account
  */
 export const KERNEL_ADDRESSES: {
-    ACCOUNT_LOGIC: Address
+    ACCOUNT_LOGIC_V0_6: Address
+    ACCOUNT_LOGIC_V0_7: Address
     FACTORY_ADDRESS: Address
     ENTRYPOINT_V0_6: Address
 } = {
-    ACCOUNT_LOGIC: "0xd3082872F8B06073A021b4602e022d5A070d7cfC",
+    ACCOUNT_LOGIC_V0_6: "0xd3082872F8B06073A021b4602e022d5A070d7cfC",
+    ACCOUNT_LOGIC_V0_7: "0x079D5D8A3275A230AF743cB59c341Ff74B82488D",
     FACTORY_ADDRESS: "0x5de4839a76cf55d0c90e2061ef4386d962E15ae3",
     ENTRYPOINT_V0_6: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789"
 }
 
+const getKernelInitData = <entryPoint extends EntryPoint>({
+    validatorAddress,
+    enableData,
+    entryPoint: entryPointAddress
+}: {
+    validatorAddress: Address
+    enableData: Hex
+    entryPoint: entryPoint
+}) => {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
+    if (entryPointVersion === "v0.6") {
+        return encodeFunctionData({
+            abi: KernelInitAbi,
+            functionName: "initialize",
+            args: [validatorAddress, enableData]
+        })
+    }
+
+    return encodeFunctionData({
+        abi: KernelV3InitAbi,
+        functionName: "initialize",
+        args: [
+            pad(concatHex(["0x1", validatorAddress]), {
+                size: 21,
+                dir: "left"
+            }),
+            zeroAddress,
+            enableData,
+            "0x"
+        ]
+    })
+}
+
 /**
  * Get the account initialization code for a kernel smart account
  * @param index
@@ -149,24 +221,26 @@ export const KERNEL_ADDRESSES: {
  * @param accountLogicAddress
  * @param ecdsaValidatorAddress
  */
-const getAccountInitCode = async ({
+const getAccountInitCode = async <entryPoint extends EntryPoint>({
     index,
     factoryAddress,
     accountLogicAddress,
     validatorAddress,
-    enableData
+    enableData,
+    entryPoint: entryPointAddress
 }: {
     index: bigint
     factoryAddress: Address
     accountLogicAddress: Address
     validatorAddress: Address
     enableData: Hex
+    entryPoint: entryPoint
 }): Promise<Hex> => {
     // Build the account initialization data
-    const initialisationData = encodeFunctionData({
-        abi: KernelInitAbi,
-        functionName: "initialize",
-        args: [validatorAddress, enableData]
+    const initialisationData = getKernelInitData<entryPoint>({
+        validatorAddress,
+        enableData,
+        entryPoint: entryPointAddress
     })
 
     // Build the account init code
@@ -187,24 +261,35 @@ const getAccountInitCode = async ({
  * @param initCodeProvider
  */
 const getAccountAddress = async <
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >({
     client,
-    entryPoint,
+    entryPoint: entryPointAddress,
     initCodeProvider
 }: {
     client: Client<TTransport, TChain, undefined>
     initCodeProvider: () => Promise<Hex>
-    entryPoint: Address
+    entryPoint: entryPoint
 }): Promise<Address> => {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+
     // Find the init code for this account
     const initCode = await initCodeProvider()
+    if (entryPointVersion === "v0.6") {
+        return getSenderAddress<ENTRYPOINT_ADDRESS_V06_TYPE>(client, {
+            initCode,
+            entryPoint: entryPointAddress as ENTRYPOINT_ADDRESS_V06_TYPE
+        })
+    }
 
     // Get the sender address based on the init code
-    return getSenderAddress(client, {
-        initCode,
-        entryPoint
+    return getSenderAddress<ENTRYPOINT_ADDRESS_V07_TYPE>(client, {
+        factory: parseFactoryAddressAndCallDataFromAccountInitCode(initCode)[0],
+        factoryData:
+            parseFactoryAddressAndCallDataFromAccountInitCode(initCode)[1],
+        entryPoint: entryPointAddress as ENTRYPOINT_ADDRESS_V07_TYPE
     })
 }
 
@@ -220,72 +305,80 @@ const getAccountAddress = async <
  * @param deployedAccountAddress
  */
 export async function createKernelAccount<
+    entryPoint extends EntryPoint,
     TTransport extends Transport = Transport,
     TChain extends Chain | undefined = Chain | undefined
 >(
     client: Client<TTransport, TChain, undefined>,
     {
         plugins,
-        entryPoint = KERNEL_ADDRESSES.ENTRYPOINT_V0_6,
+        entryPoint: entryPointAddress,
         index = 0n,
         factoryAddress = KERNEL_ADDRESSES.FACTORY_ADDRESS,
-        accountLogicAddress = KERNEL_ADDRESSES.ACCOUNT_LOGIC,
+        accountLogicAddress = KERNEL_ADDRESSES.ACCOUNT_LOGIC_V0_6,
         deployedAccountAddress
-    }: {
-        plugins: KernelPluginManagerParams | KernelPluginManager
-        entryPoint?: Address
-        index?: bigint
-        factoryAddress?: Address
-        accountLogicAddress?: Address
-        deployedAccountAddress?: Address
-    }
-): Promise<KernelSmartAccount<TTransport, TChain>> {
-    const kernelPluginManager = isKernelPluginManager(plugins)
+    }: CreateKernelAccountParameters<entryPoint>
+): Promise<KernelSmartAccount<entryPoint, TTransport, TChain>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+    accountLogicAddress =
+        entryPointVersion === "v0.6"
+            ? KERNEL_ADDRESSES.ACCOUNT_LOGIC_V0_6
+            : KERNEL_ADDRESSES.ACCOUNT_LOGIC_V0_7
+
+    const kernelPluginManager = isKernelPluginManager<entryPoint>(plugins)
         ? plugins
-        : await toKernelPluginManager(client, {
+        : await toKernelPluginManager<entryPoint>(client, {
               sudo: plugins.sudo,
               regular: plugins.regular,
               executorData: plugins.executorData,
-              pluginEnableSignature: plugins.pluginEnableSignature
+              pluginEnableSignature: plugins.pluginEnableSignature,
+              entryPoint: entryPointAddress
           })
     // Helper to generate the init code for the smart account
     const generateInitCode = async () => {
         const validatorInitData =
             await kernelPluginManager.getValidatorInitData()
-        return getAccountInitCode({
+        return getAccountInitCode<entryPoint>({
             index,
             factoryAddress,
             accountLogicAddress,
             validatorAddress: validatorInitData.validatorAddress,
-            enableData: validatorInitData.enableData
+            enableData: validatorInitData.enableData,
+            entryPoint: entryPointAddress
         })
     }
 
     // Fetch account address and chain id
     const accountAddress =
         deployedAccountAddress ??
-        (await getAccountAddress<TTransport, TChain>({
+        (await getAccountAddress<entryPoint, TTransport, TChain>({
             client,
-            entryPoint,
+            entryPoint: entryPointAddress,
             initCodeProvider: generateInitCode
         }))
 
     if (!accountAddress) throw new Error("Account address not found")
 
+    let smartAccountDeployed = await isSmartAccountDeployed(
+        client,
+        accountAddress
+    )
+
     const signHashedMessage = async (messageHash: Hex): Promise<Hex> => {
-        let kernelImplAddr: Address | undefined
-        try {
-            const strgAddr = await getAction(
-                client,
-                getStorageAt
-            )({
-                address: accountAddress,
-                slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"
-            })
-            if (strgAddr) kernelImplAddr = `0x${strgAddr.slice(26)}` as Hex
-        } catch (error) {}
-        const kernelVersion = getKernelVersion(kernelImplAddr)
-        if (kernelVersion !== "0.2.3" && kernelVersion !== "0.2.4") {
+        const kernelImplAddr = await getKernelImplementationAddress(
+            client,
+            accountAddress
+        )
+        const kernelVersion = getKernelVersion(
+            entryPointAddress,
+            kernelImplAddr
+        )
+        if (
+            !hasKernelFeature(
+                KERNEL_FEATURES.ERC1271_SIG_WRAPPER,
+                kernelVersion
+            )
+        ) {
             return kernelPluginManager.signMessage({
                 message: {
                     raw: messageHash
@@ -351,8 +444,27 @@ export async function createKernelAccount<
         )
 
         const domainSeparator = keccak256(encoded)
+
+        let finalMessageHash = messageHash
+        if (
+            hasKernelFeature(
+                KERNEL_FEATURES.ERC1271_SIG_WRAPPER_WITH_WRAPPED_HASH,
+                kernelVersion
+            )
+        ) {
+            finalMessageHash = keccak256(
+                encodeAbiParameters(
+                    [{ type: "bytes32" }, { type: "bytes32" }],
+                    [
+                        keccak256(stringToHex("Kernel(bytes32 hash)")),
+                        messageHash
+                    ]
+                )
+            )
+        }
+
         const digest = keccak256(
-            concatHex(["0x1901", domainSeparator, messageHash])
+            concatHex(["0x1901", domainSeparator, finalMessageHash])
         )
         return kernelPluginManager.signMessage({
             message: {
@@ -367,15 +479,54 @@ export async function createKernelAccount<
         async signMessage({ message }) {
             const messageHash = hashMessage(message)
             const [isDeployed, signature] = await Promise.all([
-                isAccountDeployed(),
+                isSmartAccountDeployed(client, accountAddress),
                 signHashedMessage(messageHash)
             ])
-            return create6492Signature(isDeployed, signature)
+            const kernelImplAddr = await getKernelImplementationAddress(
+                client,
+                accountAddress
+            )
+            const kernelVersion = getKernelVersion(
+                entryPointAddress,
+                kernelImplAddr
+            )
+            if (
+                !hasKernelFeature(
+                    KERNEL_FEATURES.ERC1271_WITH_VALIDATOR,
+                    kernelVersion
+                )
+            ) {
+                return create6492Signature(isDeployed, signature)
+            }
+
+            const validatorInitData =
+                await kernelPluginManager.getValidatorInitData()
+            return create6492Signature(
+                isDeployed,
+                concatHex([
+                    pad(
+                        concatHex(["0x1", validatorInitData.validatorAddress]),
+                        {
+                            size: 21,
+                            dir: "left"
+                        }
+                    ),
+                    signature
+                ])
+            )
         },
         async signTransaction(_, __) {
             throw new SignTransactionNotSupportedBySmartAccount()
         },
         async signTypedData(typedData) {
+            const kernelImplAddr = await getKernelImplementationAddress(
+                client,
+                accountAddress
+            )
+            const kernelVersion = getKernelVersion(
+                entryPointAddress,
+                kernelImplAddr
+            )
             const types = {
                 EIP712Domain: getTypesForEIP712Domain({
                     domain: typedData.domain
@@ -394,21 +545,36 @@ export async function createKernelAccount<
 
             const typedHash = hashTypedData(typedData)
             const [isDeployed, signature] = await Promise.all([
-                isAccountDeployed(),
+                isSmartAccountDeployed(client, accountAddress),
                 signHashedMessage(typedHash)
             ])
-            return create6492Signature(isDeployed, signature)
+            if (
+                !hasKernelFeature(
+                    KERNEL_FEATURES.ERC1271_WITH_VALIDATOR,
+                    kernelVersion
+                )
+            ) {
+                return create6492Signature(isDeployed, signature)
+            }
+            const validatorInitData =
+                await kernelPluginManager.getValidatorInitData()
+            return create6492Signature(
+                isDeployed,
+                concatHex([
+                    pad(
+                        // [TODO] - Make the Validator type dynamic to support permission validators
+                        concatHex(["0x1", validatorInitData.validatorAddress]),
+                        {
+                            size: 21,
+                            dir: "left"
+                        }
+                    ),
+                    signature
+                ])
+            )
         }
     })
 
-    const isAccountDeployed = async (): Promise<boolean> => {
-        const contractCode = await getBytecode(client, {
-            address: accountAddress
-        })
-
-        return (contractCode?.length ?? 0) > 2
-    }
-
     const create6492Signature = async (
         isDeployed: boolean,
         signature: Hash
@@ -433,17 +599,45 @@ export async function createKernelAccount<
         ...account,
         client: client,
         publicKey: accountAddress,
-        entryPoint: entryPoint,
+        entryPoint: entryPointAddress,
         source: "kernelSmartAccount",
         kernelPluginManager,
         generateInitCode,
 
+        async getFactory() {
+            if (smartAccountDeployed) return undefined
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return undefined
+
+            return factoryAddress
+        },
+
+        async getFactoryData() {
+            if (smartAccountDeployed) return undefined
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return undefined
+
+            return parseFactoryAddressAndCallDataFromAccountInitCode(
+                await generateInitCode()
+            )[1]
+        },
+
         // Get the nonce of the smart account
         async getNonce() {
-            const key = await kernelPluginManager.getNonceKey()
+            const key = await kernelPluginManager.getNonceKey(accountAddress)
             return getAccountNonce(client, {
                 sender: accountAddress,
-                entryPoint: entryPoint,
+                entryPoint: entryPointAddress,
                 key
             })
         },
@@ -455,32 +649,66 @@ export async function createKernelAccount<
 
         // Encode the init code
         async getInitCode() {
-            if (await isAccountDeployed()) {
-                return "0x"
-            } else {
-                return generateInitCode()
-            }
+            if (smartAccountDeployed) return "0x"
+
+            smartAccountDeployed = await isSmartAccountDeployed(
+                client,
+                accountAddress
+            )
+
+            if (smartAccountDeployed) return "0x"
+            return generateInitCode()
         },
 
+        // [TODO] - CLeanup the encoding functions
+
         // Encode the deploy call data
         async encodeDeployCallData(_tx) {
+            if (entryPointVersion === "v0.6") {
+                return encodeFunctionData({
+                    abi: KernelExecuteAbi,
+                    functionName: "executeDelegateCall",
+                    args: [
+                        createCallAddress,
+                        encodeFunctionData({
+                            abi: createCallAbi,
+                            functionName: "performCreate",
+                            args: [
+                                0n,
+                                encodeDeployData({
+                                    abi: _tx.abi,
+                                    bytecode: _tx.bytecode,
+                                    args: _tx.args
+                                } as EncodeDeployDataParameters)
+                            ]
+                        })
+                    ]
+                })
+            }
+
             return encodeFunctionData({
-                abi: KernelExecuteAbi,
-                functionName: "executeDelegateCall",
+                abi: KernelV3ExecuteAbi,
+                functionName: "execute",
                 args: [
-                    createCallAddress,
-                    encodeFunctionData({
-                        abi: createCallAbi,
-                        functionName: "performCreate",
-                        args: [
-                            0n,
-                            encodeDeployData({
-                                abi: _tx.abi,
-                                bytecode: _tx.bytecode,
-                                args: _tx.args
-                            } as EncodeDeployDataParameters)
+                    getExecMode(CALL_TYPE.DELEGATE_CALL, EXEC_TYPE.DEFAULT),
+                    encodeAbiParameters(
+                        parseAbiParameters("address to, bytes data"),
+                        [
+                            createCallAddress,
+                            encodeFunctionData({
+                                abi: createCallAbi,
+                                functionName: "performCreate",
+                                args: [
+                                    0n,
+                                    encodeDeployData({
+                                        abi: _tx.abi,
+                                        bytecode: _tx.bytecode,
+                                        args: _tx.args
+                                    } as EncodeDeployDataParameters)
+                                ]
+                            })
                         ]
-                    })
+                    )
                 ]
             })
         },
@@ -490,20 +718,65 @@ export async function createKernelAccount<
             const tx = _tx as KernelEncodeCallDataArgs
             if (Array.isArray(tx)) {
                 // Encode a batched call
+                if (entryPointVersion === "v0.6") {
+                    return encodeFunctionData({
+                        abi: KernelExecuteAbi,
+                        functionName: "executeBatch",
+                        args: [
+                            tx.map((txn) => {
+                                if (txn.callType === "delegatecall") {
+                                    throw new Error("Cannot batch delegatecall")
+                                }
+                                return {
+                                    to: txn.to,
+                                    value: txn.value,
+                                    data: txn.data
+                                }
+                            })
+                        ]
+                    })
+                }
                 return encodeFunctionData({
-                    abi: KernelExecuteAbi,
-                    functionName: "executeBatch",
+                    abi: KernelV3ExecuteAbi,
+                    functionName: "execute",
                     args: [
-                        tx.map((txn) => {
-                            if (txn.callType === "delegatecall") {
-                                throw new Error("Cannot batch delegatecall")
-                            }
-                            return {
-                                to: txn.to,
-                                value: txn.value,
-                                data: txn.data
-                            }
-                        })
+                        getExecMode(CALL_TYPE.BATCH, EXEC_TYPE.DEFAULT),
+                        encodeAbiParameters(
+                            [
+                                {
+                                    name: "executionBatch",
+                                    type: "tuple[]",
+                                    components: [
+                                        {
+                                            name: "target",
+                                            type: "address"
+                                        },
+                                        {
+                                            name: "value",
+                                            type: "uint256"
+                                        },
+                                        {
+                                            name: "callData",
+                                            type: "bytes"
+                                        }
+                                    ]
+                                }
+                            ],
+                            [
+                                tx.map((txn) => {
+                                    if (txn.callType === "delegatecall") {
+                                        throw new Error(
+                                            "Cannot batch delegatecall"
+                                        )
+                                    }
+                                    return {
+                                        target: txn.to,
+                                        value: txn.value,
+                                        callData: txn.data
+                                    }
+                                })
+                            ]
+                        )
                     ]
                 })
             }
@@ -513,18 +786,48 @@ export async function createKernelAccount<
                 if (tx.to.toLowerCase() === accountAddress.toLowerCase()) {
                     return tx.data
                 }
+                if (entryPointVersion === "v0.6") {
+                    return encodeFunctionData({
+                        abi: KernelExecuteAbi,
+                        functionName: "execute",
+                        args: [tx.to, tx.value, tx.data, 0]
+                    })
+                }
                 return encodeFunctionData({
-                    abi: KernelExecuteAbi,
+                    abi: KernelV3ExecuteAbi,
                     functionName: "execute",
-                    args: [tx.to, tx.value, tx.data, 0]
+                    args: [
+                        getExecMode(CALL_TYPE.SINGLE, EXEC_TYPE.DEFAULT),
+                        encodeAbiParameters(
+                            parseAbiParameters(
+                                "address target, uint256 value, bytes calldata callData"
+                            ),
+                            [tx.to, tx.value, tx.data]
+                        )
+                    ]
                 })
             }
 
             if (tx.callType === "delegatecall") {
+                if (entryPointVersion === "v0.6") {
+                    return encodeFunctionData({
+                        abi: KernelExecuteAbi,
+                        functionName: "executeDelegateCall",
+                        args: [tx.to, tx.data]
+                    })
+                }
                 return encodeFunctionData({
-                    abi: KernelExecuteAbi,
-                    functionName: "executeDelegateCall",
-                    args: [tx.to, tx.data]
+                    abi: KernelV3ExecuteAbi,
+                    functionName: "execute",
+                    args: [
+                        getExecMode(CALL_TYPE.DELEGATE_CALL, EXEC_TYPE.DEFAULT),
+                        encodeAbiParameters(
+                            parseAbiParameters(
+                                "address target, bytes calldata callData"
+                            ),
+                            [tx.to, tx.data]
+                        )
+                    ]
                 })
             }