@zerodev/sdk 5.2.0-alpha-1 → 5.2.0-alpha-3

package/accounts/kernel/utils/account/ep0_6/encodeCallData.ts

@@ -0,0 +1,32 @@
+import type { EntryPoint } from "permissionless/types/entrypoint.js"
+import type { KernelSmartAccount } from "../../../createKernelAccount.js"
+import { encodeExecuteBatchCall } from "../../ep0_6/encodeExecuteBatchCall.js"
+import { encodeExecuteDelegateCall } from "../../ep0_6/encodeExecuteDelegateCall.js"
+import { encodeExecuteSingleCall } from "../../ep0_6/encodeExecuteSingleCall.js"
+
+export const encodeCallData = async <
+    entryPoint extends EntryPoint = EntryPoint
+>(
+    tx: Parameters<KernelSmartAccount<entryPoint>["encodeCallData"]>[0]
+) => {
+    if (Array.isArray(tx)) {
+        if (tx.some((t) => t.callType === "delegatecall")) {
+            throw new Error("Cannot batch delegatecall")
+        }
+        return encodeExecuteBatchCall(tx)
+    }
+
+    // Default to `call`
+    if (!tx.callType || tx.callType === "call") {
+        return encodeExecuteSingleCall(tx)
+    }
+
+    if (tx.callType === "delegatecall") {
+        return encodeExecuteDelegateCall({
+            to: tx.to,
+            data: tx.data
+        })
+    }
+
+    throw new Error("Invalid call type")
+}

package/accounts/kernel/utils/account/ep0_6/encodeDeployCallData.ts

@@ -0,0 +1,18 @@
+import { toSmartAccount } from "permissionless/accounts"
+import { encodeDeployData } from "viem"
+import { safeCreateCallAddress } from "../../../../../constants.js"
+import { encodeSafeCreateCall } from "../../common/encodeSafeCreateCall.js"
+import { encodeExecuteDelegateCall } from "../../ep0_6/encodeExecuteDelegateCall.js"
+import type { DelegateCallArgs } from "../../types.js"
+
+export const encodeDeployCallData = (
+    tx: Parameters<
+        Parameters<typeof toSmartAccount>[0]["encodeDeployCallData"]
+    >[0]
+) => {
+    const deployCalldataArgs: DelegateCallArgs = {
+        to: safeCreateCallAddress,
+        data: encodeSafeCreateCall([0n, encodeDeployData(tx)])
+    }
+    return encodeExecuteDelegateCall(deployCalldataArgs)
+}

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

@@ -0,0 +1,40 @@
+import type { EntryPoint } from "permissionless/types/entrypoint.js"
+import { EXEC_TYPE } from "../../../../../constants.js"
+import type { KernelSmartAccount } from "../../../createKernelAccount.js"
+import { encodeExecuteBatchCall } from "../../ep0_7/encodeExecuteBatchCall.js"
+import { encodeExecuteDelegateCall } from "../../ep0_7/encodeExecuteDelegateCall.js"
+import { encodeExecuteSingleCall } from "../../ep0_7/encodeExecuteSingleCall.js"
+
+export const encodeCallData = async <
+    entryPoint extends EntryPoint = EntryPoint
+>(
+    tx: Parameters<KernelSmartAccount<entryPoint>["encodeCallData"]>[0]
+) => {
+    if (Array.isArray(tx)) {
+        if (tx.some((t) => t.callType === "delegatecall")) {
+            throw new Error("Cannot batch delegatecall")
+        }
+        // Encode a batched call
+        return encodeExecuteBatchCall(tx, {
+            execType: EXEC_TYPE.DEFAULT
+        })
+    }
+
+    // Default to `call`
+    if (!tx.callType || tx.callType === "call") {
+        return encodeExecuteSingleCall(tx, {
+            execType: EXEC_TYPE.DEFAULT
+        })
+    }
+
+    if (tx.callType === "delegatecall") {
+        return encodeExecuteDelegateCall(
+            { to: tx.to, data: tx.data },
+            {
+                execType: EXEC_TYPE.DEFAULT
+            }
+        )
+    }
+
+    throw new Error("Invalid call type")
+}

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

@@ -0,0 +1,20 @@
+import { toSmartAccount } from "permissionless/accounts"
+import { encodeDeployData } from "viem"
+import { EXEC_TYPE, safeCreateCallAddress } from "../../../../../constants.js"
+import { encodeSafeCreateCall } from "../../common/encodeSafeCreateCall.js"
+import { encodeExecuteDelegateCall } from "../../ep0_7/encodeExecuteDelegateCall.js"
+import type { DelegateCallArgs } from "../../types.js"
+
+export const encodeDeployCallData = (
+    tx: Parameters<
+        Parameters<typeof toSmartAccount>[0]["encodeDeployCallData"]
+    >[0]
+) => {
+    const deployCalldataArgs: DelegateCallArgs = {
+        to: safeCreateCallAddress,
+        data: encodeSafeCreateCall([0n, encodeDeployData(tx)])
+    }
+    return encodeExecuteDelegateCall(deployCalldataArgs, {
+        execType: EXEC_TYPE.DEFAULT
+    })
+}

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

@@ -0,0 +1,62 @@
+import type { EntryPoint } from "permissionless/types/entrypoint.js"
+import {
+    type Address,
+    type Chain,
+    type Client,
+    type Transport,
+    decodeFunctionResult,
+    encodeFunctionData,
+    publicActions
+} from "viem"
+import { KERNEL_NAME } from "../../../../constants.js"
+import { getKernelVersion } from "../../../../utils.js"
+import { EIP1271Abi } from "../../abi/EIP1271Abi.js"
+
+type AccountMetadata = {
+    name: string
+    version: string
+    chainId: bigint
+}
+export const accountMetadata = async <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>(
+    client: Client<TTransport, TChain, undefined>,
+    accountAddress: Address,
+    entryPointAddress: EntryPoint
+): Promise<AccountMetadata> => {
+    try {
+        const domain = await client.request({
+            method: "eth_call",
+            params: [
+                {
+                    to: accountAddress,
+                    data: encodeFunctionData({
+                        abi: EIP1271Abi,
+                        functionName: "eip712Domain"
+                    })
+                },
+                "latest"
+            ]
+        })
+        if (domain !== "0x") {
+            const decoded = decodeFunctionResult({
+                abi: [...EIP1271Abi],
+                functionName: "eip712Domain",
+                data: domain
+            })
+            return {
+                name: decoded[1],
+                version: decoded[2],
+                chainId: decoded[3]
+            }
+        }
+    } catch (error) {}
+    return {
+        name: KERNEL_NAME,
+        version: getKernelVersion(entryPointAddress),
+        chainId: client.chain
+            ? BigInt(client.chain.id)
+            : BigInt(await client.extend(publicActions).getChainId())
+    }
+}

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

@@ -0,0 +1,48 @@
+import {
+    type Hex,
+    type TypedDataDomain,
+    concatHex,
+    domainSeparator,
+    keccak256
+} from "viem"
+import type { WithRequired } from "../../../../types/index.js"
+import { KERNEL_FEATURES, hasKernelFeature } from "../../../../utils.js"
+import { hashKernelMessageHashWrapper } from "../ep0_7/hashKernelSignatureWrapper.js"
+
+export const eip712WrapHash = async (
+    messageHash: Hex,
+    domain: WithRequired<
+        TypedDataDomain,
+        "name" | "chainId" | "verifyingContract" | "version"
+    >
+): Promise<Hex> => {
+    const { name, version, chainId, verifyingContract } = domain
+
+    if (!hasKernelFeature(KERNEL_FEATURES.ERC1271_SIG_WRAPPER, version)) {
+        return messageHash
+    }
+
+    const _domainSeparator = domainSeparator({
+        domain: {
+            name,
+            version,
+            chainId,
+            verifyingContract
+        }
+    })
+
+    let finalMessageHash = messageHash
+    if (
+        hasKernelFeature(
+            KERNEL_FEATURES.ERC1271_SIG_WRAPPER_WITH_WRAPPED_HASH,
+            version
+        )
+    ) {
+        finalMessageHash = hashKernelMessageHashWrapper(finalMessageHash)
+    }
+
+    const digest = keccak256(
+        concatHex(["0x1901", _domainSeparator, finalMessageHash])
+    )
+    return digest
+}

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

@@ -0,0 +1,14 @@
+import { encodeFunctionData } from "viem"
+import { SafeCreateCallAbi } from "../../abi/SafeCreateCallAbi.js"
+
+type EncodeExecuteDelegateCallArgs = Parameters<
+    typeof encodeFunctionData<typeof SafeCreateCallAbi, "performCreate">
+>[0]["args"]
+
+export const encodeSafeCreateCall = (args: EncodeExecuteDelegateCallArgs) => {
+    return encodeFunctionData({
+        abi: SafeCreateCallAbi,
+        functionName: "performCreate",
+        args
+    })
+}

package/accounts/kernel/utils/ep0_6/encodeExecuteBatchCall.ts

@@ -0,0 +1,19 @@
+import { encodeFunctionData } from "viem"
+import { KernelExecuteAbi } from "../../abi/KernelAccountAbi.js"
+import type { CallArgs } from "../types.js"
+
+export const encodeExecuteBatchCall = (args: CallArgs[]) => {
+    return encodeFunctionData({
+        abi: KernelExecuteAbi,
+        functionName: "executeBatch",
+        args: [
+            args.map((arg) => {
+                return {
+                    to: arg.to,
+                    value: arg.value,
+                    data: arg.data
+                }
+            })
+        ]
+    })
+}

package/accounts/kernel/utils/ep0_6/encodeExecuteDelegateCall.ts

@@ -0,0 +1,11 @@
+import { encodeFunctionData } from "viem"
+import { KernelExecuteAbi } from "../../abi/KernelAccountAbi.js"
+import type { DelegateCallArgs } from "../types.js"
+
+export const encodeExecuteDelegateCall = (args: DelegateCallArgs) => {
+    return encodeFunctionData({
+        abi: KernelExecuteAbi,
+        functionName: "executeDelegateCall",
+        args: [args.to, args.data]
+    })
+}

package/accounts/kernel/utils/ep0_6/encodeExecuteSingleCall.ts

@@ -0,0 +1,11 @@
+import { encodeFunctionData } from "viem"
+import { KernelExecuteAbi } from "../../abi/KernelAccountAbi.js"
+import type { CallArgs } from "../types.js"
+
+export const encodeExecuteSingleCall = (args: CallArgs) => {
+    return encodeFunctionData({
+        abi: KernelExecuteAbi,
+        functionName: "execute",
+        args: [args.to, args.value, args.data, 0]
+    })
+}

package/accounts/kernel/utils/ep0_7/encodeExecuteBatchCall.ts

@@ -0,0 +1,51 @@
+import { encodeAbiParameters } from "viem"
+import { CALL_TYPE } from "../../../../constants.js"
+import type { CallArgs } from "../types.js"
+import {
+    type EncodeExecuteOptions,
+    encodeExecuteCall
+} from "./encodeExecuteCall.js"
+
+export const encodeExecuteBatchCall = (
+    args: CallArgs[],
+    options: Omit<EncodeExecuteOptions, "callType">
+) => {
+    const calldata = encodeAbiParameters(
+        [
+            {
+                name: "executionBatch",
+                type: "tuple[]",
+                components: [
+                    {
+                        name: "target",
+                        type: "address"
+                    },
+                    {
+                        name: "value",
+                        type: "uint256"
+                    },
+                    {
+                        name: "callData",
+                        type: "bytes"
+                    }
+                ]
+            }
+        ],
+        [
+            args.map((arg) => {
+                return {
+                    target: arg.to,
+                    value: arg.value,
+                    callData: arg.data
+                }
+            })
+        ]
+    )
+    return encodeExecuteCall(
+        { calldata },
+        {
+            callType: CALL_TYPE.BATCH,
+            execType: options.execType
+        }
+    )
+}

package/accounts/kernel/utils/ep0_7/encodeExecuteCall.ts

@@ -0,0 +1,38 @@
+import { type Hex, concatHex, encodeFunctionData, toHex } from "viem"
+import { CALL_TYPE } from "../../../../constants.js"
+import { getExecMode } from "../../../../utils.js"
+import { KernelV3ExecuteAbi } from "../../abi/kernel_v_3_0_0/KernelAccountAbi.js"
+import type { CallArgs, DelegateCallArgs } from "../types.js"
+
+export type EncodeExecuteOptions = Parameters<typeof getExecMode>[0]
+
+type EncodeExecuteCallArgs<TOptions> =
+    | (TOptions extends {
+          callType: CALL_TYPE.DELEGATE_CALL
+      }
+          ? DelegateCallArgs
+          : CallArgs)
+    | { calldata: Hex }
+
+export const encodeExecuteCall = <TOptions extends EncodeExecuteOptions>(
+    args: EncodeExecuteCallArgs<TOptions>,
+    options: TOptions
+) => {
+    let calldata: Hex
+    if ("calldata" in args) {
+        calldata = args.calldata
+    } else {
+        calldata = concatHex([
+            args.to,
+            options.callType !== CALL_TYPE.DELEGATE_CALL
+                ? toHex(args.value, { size: 32 })
+                : "0x", // No value if delegate call
+            args.data
+        ])
+    }
+    return encodeFunctionData({
+        abi: KernelV3ExecuteAbi,
+        functionName: "execute",
+        args: [getExecMode(options), calldata]
+    })
+}

package/accounts/kernel/utils/ep0_7/encodeExecuteDelegateCall.ts

@@ -0,0 +1,16 @@
+import { CALL_TYPE } from "../../../../constants.js"
+import type { DelegateCallArgs } from "../types.js"
+import {
+    type EncodeExecuteOptions,
+    encodeExecuteCall
+} from "./encodeExecuteCall.js"
+
+export const encodeExecuteDelegateCall = (
+    args: DelegateCallArgs,
+    options: Omit<EncodeExecuteOptions, "callType">
+) => {
+    return encodeExecuteCall(args, {
+        callType: CALL_TYPE.DELEGATE_CALL,
+        execType: options.execType
+    })
+}

package/accounts/kernel/utils/ep0_7/encodeExecuteSingleCall.ts

@@ -0,0 +1,16 @@
+import { CALL_TYPE } from "../../../../constants.js"
+import type { CallArgs } from "../types.js"
+import {
+    type EncodeExecuteOptions,
+    encodeExecuteCall
+} from "./encodeExecuteCall.js"
+
+export const encodeExecuteSingleCall = (
+    args: CallArgs,
+    options: Omit<EncodeExecuteOptions, "callType">
+) => {
+    return encodeExecuteCall(args, {
+        callType: CALL_TYPE.SINGLE,
+        execType: options.execType
+    })
+}

package/accounts/kernel/utils/ep0_7/hashKernelSignatureWrapper.ts

@@ -0,0 +1,11 @@
+import type { Hex } from "viem"
+import { encodeAbiParameters, keccak256, stringToHex } from "viem"
+
+export const hashKernelMessageHashWrapper = (messageHash: Hex) => {
+    return keccak256(
+        encodeAbiParameters(
+            [{ type: "bytes32" }, { type: "bytes32" }],
+            [keccak256(stringToHex("Kernel(bytes32 hash)")), messageHash]
+        )
+    )
+}

package/accounts/kernel/utils/types.ts

@@ -0,0 +1,8 @@
+import type { Address, Hex } from "viem"
+
+export type CallArgs = {
+    to: Address
+    data: Hex
+    value: bigint
+}
+export type DelegateCallArgs = Omit<CallArgs, "value">

package/accounts/kernel/v1/createKernelV1Account.ts

@@ -28,12 +28,12 @@ import { getChainId, signMessage, signTypedData } from "viem/actions"
 import { type KernelEncodeCallDataArgs } from "../../../types/kernel.js"
 import { wrapSignatureWith6492 } from "../../utils/6492.js"
 import { parseFactoryAddressAndCallDataFromAccountInitCode } from "../../utils/index.js"
-import { type KernelSmartAccount } from "../createKernelAccount.js"
 import {
     MULTISEND_ADDRESS,
     encodeMultiSend,
     multiSendAbi
-} from "./multisend.js"
+} from "../../utils/multisend.js"
+import { type KernelSmartAccount } from "../createKernelAccount.js"
 
 export type KernelV1SmartAccount<
     entryPoint extends EntryPoint,
@@ -204,7 +204,6 @@ export async function createKernelV1Account<
         publicKey: accountAddress,
         entryPoint: entryPointAddress,
         source: "kernelSmartAccount",
-        generateInitCode,
         async getFactory() {
             if (smartAccountDeployed) return undefined