@zerodev/sdk 4.7.4 → 5.0.0-alpha-0

package/accounts/utils/toKernelPluginManager.ts

@@ -0,0 +1,369 @@
+import { getAction, getEntryPointVersion } from "permissionless"
+import type { EntryPoint } from "permissionless/types/entrypoint"
+import {
+    type Address,
+    type Chain,
+    type Client,
+    type Hex,
+    type Transport,
+    concat,
+    concatHex,
+    encodeAbiParameters,
+    hexToBigInt,
+    pad,
+    parseAbiParameters,
+    toFunctionSelector,
+    toHex,
+    zeroAddress
+} from "viem"
+import { getChainId, readContract } 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"
+
+export function isKernelPluginManager<entryPoint extends EntryPoint>(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    plugin: any
+): plugin is KernelPluginManager<entryPoint> {
+    return plugin.getPluginEnableSignature !== undefined
+}
+
+export async function toKernelPluginManager<
+    entryPoint extends EntryPoint,
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined
+>(
+    client: Client<TTransport, TChain, undefined>,
+    {
+        sudo,
+        regular,
+        pluginEnableSignature,
+        validatorInitData,
+        executorData = {
+            executor: zeroAddress,
+            selector: toFunctionSelector(
+                "execute(address, uint256, bytes, uint8)"
+            )
+        },
+        validAfter = 0,
+        validUntil = 0,
+        entryPoint: entryPointAddress
+    }: KernelPluginManagerParams<entryPoint>
+): Promise<KernelPluginManager<entryPoint>> {
+    const entryPointVersion = getEntryPointVersion(entryPointAddress)
+    const chainId = await getChainId(client)
+    const activeValidator = regular || sudo
+    if (!activeValidator) {
+        throw new Error("One of `sudo` or `regular` validator must be set")
+    }
+    const getValidatorSignature = async (
+        accountAddress: Address,
+        selector: Hex,
+        sig?: Hex
+    ): Promise<Hex> => {
+        if (entryPointVersion === "v0.6") {
+            if (regular) {
+                if (await regular.isEnabled(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
+                ])
+            } else if (sudo) {
+                return ValidatorMode.sudo
+            } else {
+                throw new Error(
+                    "One of `sudo` or `regular` validator must be set"
+                )
+            }
+        }
+        if (regular) {
+            if (
+                (await isPluginInitialized_7579(accountAddress)) ||
+                (await regular.isEnabled(accountAddress, selector))
+            ) {
+                return sig ?? "0x"
+            }
+            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"
+                    ]
+                )
+            ])
+        } else if (sudo) {
+            return sig ?? "0x"
+        } 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 getPluginEnableSignature = async (accountAddress: Address) => {
+        if (pluginEnableSignature) return pluginEnableSignature
+        if (!sudo)
+            throw new Error(
+                "sudo validator not set -- need it to enable the validator"
+            )
+        if (!regular) throw new Error("regular validator not set")
+
+        const kernelImplAddr = await getKernelImplementationAddress(
+            client,
+            accountAddress
+        )
+        const 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"
+            })
+            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"
+        })
+
+        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
+        }
+    }
+
+    return {
+        ...activeValidator,
+        signUserOperation: async (userOperation) => {
+            const userOpSig =
+                await activeValidator.signUserOperation(userOperation)
+            if (entryPointVersion === "v0.6") {
+                return concatHex([
+                    await getValidatorSignature(
+                        userOperation.sender,
+                        userOperation.callData.toString().slice(0, 10) as Hex
+                    ),
+                    userOpSig
+                ])
+            }
+            return await getValidatorSignature(
+                userOperation.sender,
+                userOperation.callData.toString().slice(0, 10) as Hex,
+                userOpSig
+            )
+        },
+        getExecutorData: () => executorData,
+        getValidityData: () => ({
+            validAfter,
+            validUntil
+        }),
+        getDummySignature: async (userOperation) => {
+            const userOpSig =
+                await activeValidator.getDummySignature(userOperation)
+            if (entryPointVersion === "v0.6") {
+                return concatHex([
+                    await getValidatorSignature(
+                        userOperation.sender,
+                        userOperation.callData.toString().slice(0, 10) as Hex
+                    ),
+                    userOpSig
+                ])
+            }
+            return await getValidatorSignature(
+                userOperation.sender,
+                userOperation.callData.toString().slice(0, 10) as Hex,
+                userOpSig
+            )
+        },
+        getNonceKey: async (accountAddress = zeroAddress) => {
+            if (entryPointVersion === "v0.6")
+                return await activeValidator.getNonceKey()
+
+            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 }
+                )
+            )
+        },
+        getPluginEnableSignature,
+        getValidatorInitData: async () => {
+            if (validatorInitData) return validatorInitData
+            return {
+                validatorAddress: sudo?.address ?? activeValidator.address,
+
+                enableData:
+                    (await sudo?.getEnableData()) ??
+                    (await activeValidator.getEnableData())
+            }
+        }
+    }
+}

package/actions/account-client/signUserOperation.ts

@@ -0,0 +1,71 @@
+import type { SmartAccount } from "permissionless/accounts/types"
+import {
+    type Middleware,
+    prepareUserOperationRequest
+} from "permissionless/actions/smartAccount"
+import type {
+    EntryPoint,
+    GetAccountParameter,
+    GetEntryPointVersion,
+    PartialBy,
+    Prettify,
+    UserOperation
+} from "permissionless/types"
+import {
+    AccountOrClientNotFoundError,
+    getAction,
+    parseAccount
+} from "permissionless/utils"
+import type { Chain, Client, Transport } from "viem"
+
+export type SignUserOperationParameters<
+    entryPoint extends EntryPoint,
+    TAccount extends SmartAccount<entryPoint> | undefined =
+        | SmartAccount<entryPoint>
+        | undefined
+> = {
+    userOperation: PartialBy<
+        UserOperation<"v0.6">,
+        | "nonce"
+        | "sender"
+        | "initCode"
+        | "signature"
+        | "callGasLimit"
+        | "maxFeePerGas"
+        | "maxPriorityFeePerGas"
+        | "preVerificationGas"
+        | "verificationGasLimit"
+        | "paymasterAndData"
+    >
+} & GetAccountParameter<entryPoint, TAccount> &
+    Middleware<entryPoint>
+
+export type SignUserOperationReturnType = UserOperation<"v0.6">
+
+export async function signUserOperation<
+    entryPoint extends EntryPoint,
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartAccount<entryPoint> | undefined =
+        | SmartAccount<entryPoint>
+        | undefined
+>(
+    client: Client<TTransport, TChain, TAccount>,
+    args: Prettify<SignUserOperationParameters<entryPoint, TAccount>>
+): Promise<SignUserOperationReturnType> {
+    const { account: account_ = client.account } = args
+    if (!account_) throw new AccountOrClientNotFoundError()
+
+    const account = parseAccount(account_) as SmartAccount<entryPoint>
+
+    const userOperation = await getAction(
+        client,
+        prepareUserOperationRequest<entryPoint, TTransport, TChain, TAccount>
+    )(args)
+
+    userOperation.signature = await account.signUserOperation(
+        userOperation as UserOperation<GetEntryPointVersion<entryPoint>>
+    )
+
+    return userOperation as SignUserOperationReturnType
+}

package/actions/index.ts

@@ -0,0 +1,17 @@
+export {
+    sponsorUserOperation,
+    type SponsorUserOperationParameters,
+    type SponsorUserOperationReturnType
+} from "./paymaster/sponsorUserOperation.js"
+
+export {
+    signUserOperation,
+    type SignUserOperationParameters,
+    type SignUserOperationReturnType
+} from "./account-client/signUserOperation.js"
+
+export {
+    estimateGasInERC20,
+    type EstimateGasInERC20Parameters,
+    type EstimateGasInERC20ReturnType
+} from "./paymaster/estimateGasInERC20.js"

package/actions/paymaster/estimateGasInERC20.ts

@@ -0,0 +1,58 @@
+import type { EntryPoint } from "permissionless/types"
+import type {
+    UserOperation,
+    UserOperationWithBigIntAsHex
+} 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 = {
+    userOperation: UserOperation<"v0.6">
+    gasTokenAddress: Hex
+    entryPoint?: Address
+}
+
+export type GetERC20TokenQuotesReturnType = {
+    maxGasCostToken: string
+    tokenDecimals: string
+}
+
+export type EstimateGasInERC20ReturnType = {
+    amount: number
+}
+
+/**
+ * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
+ */
+
+export const estimateGasInERC20 = async <entryPoint extends EntryPoint>(
+    client: ZeroDevPaymasterClient<entryPoint>,
+    args: EstimateGasInERC20Parameters
+): Promise<EstimateGasInERC20ReturnType> => {
+    const response = await client.request({
+        method: "stackup_getERC20TokenQuotes",
+        params: [
+            {
+                chainId: client.chain?.id as number,
+                userOp: deepHexlify(
+                    args.userOperation
+                ) as UserOperationWithBigIntAsHex<"v0.6">,
+                tokenAddress: args.gasTokenAddress,
+                entryPointAddress:
+                    args.entryPoint ?? KERNEL_ADDRESSES.ENTRYPOINT_V0_6
+            }
+        ]
+    })
+
+    const result: GetERC20TokenQuotesReturnType = {
+        maxGasCostToken: response.maxGasCostToken,
+        tokenDecimals: response.tokenDecimals
+    }
+
+    const amount =
+        Number(result.maxGasCostToken) / 10 ** Number(result.tokenDecimals)
+
+    return { amount }
+}

package/actions/paymaster/sponsorUserOperation.ts

@@ -0,0 +1,143 @@
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint,
+    GetEntryPointVersion
+} from "permissionless/types/entrypoint"
+import type {
+    UserOperation,
+    UserOperationWithBigIntAsHex
+} from "permissionless/types/userOperation.js"
+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> = {
+    userOperation: entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+        ? PartialBy<
+              UserOperation<"v0.6">,
+              "callGasLimit" | "preVerificationGas" | "verificationGasLimit"
+          >
+        : PartialBy<
+              UserOperation<"v0.7">,
+              | "callGasLimit"
+              | "preVerificationGas"
+              | "verificationGasLimit"
+              | "paymasterVerificationGasLimit"
+              | "paymasterPostOpGasLimit"
+          >
+    entryPoint: entryPoint
+    gasToken?: Hex
+    shouldOverrideFee?: boolean
+    shouldConsume?: boolean
+}
+
+export type SponsorUserOperationReturnType<entryPoint extends EntryPoint> =
+    entryPoint extends ENTRYPOINT_ADDRESS_V06_TYPE
+        ? Pick<
+              UserOperation<"v0.6">,
+              | "callGasLimit"
+              | "verificationGasLimit"
+              | "preVerificationGas"
+              | "paymasterAndData"
+          >
+        : Pick<
+              UserOperation<"v0.7">,
+              | "callGasLimit"
+              | "verificationGasLimit"
+              | "preVerificationGas"
+              | "paymaster"
+              | "paymasterVerificationGasLimit"
+              | "paymasterPostOpGasLimit"
+              | "paymasterData"
+          >
+
+/**
+ * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
+ */
+export const sponsorUserOperation = async <entryPoint extends EntryPoint>(
+    client: ZeroDevPaymasterClient<entryPoint>,
+    args: SponsorUserOperationParameters<entryPoint>
+): Promise<SponsorUserOperationReturnType<entryPoint>> => {
+    const response = await client.request({
+        method: "zd_sponsorUserOperation",
+        params: [
+            {
+                chainId: client.chain?.id as number,
+                userOp: deepHexlify(
+                    args.userOperation
+                ) as UserOperationWithBigIntAsHex<
+                    GetEntryPointVersion<entryPoint>
+                >,
+                entryPointAddress:
+                    args.entryPoint ?? KERNEL_ADDRESSES.ENTRYPOINT_V0_6,
+                gasTokenData: args.gasToken && {
+                    tokenAddress: args.gasToken
+                },
+                shouldOverrideFee: args.shouldOverrideFee ?? false,
+                shouldConsume: args.shouldConsume ?? true
+            }
+        ]
+    })
+    if (args.entryPoint === ENTRYPOINT_ADDRESS_V06) {
+        const responseV06 = response as {
+            paymasterAndData: Hex
+            preVerificationGas: Hex
+            verificationGasLimit: Hex
+            callGasLimit: Hex
+            paymaster?: never
+            paymasterVerificationGasLimit?: never
+            paymasterPostOpGasLimit?: never
+            paymasterData?: never
+        }
+        return {
+            paymasterAndData: responseV06.paymasterAndData,
+            preVerificationGas: BigInt(responseV06.preVerificationGas),
+            verificationGasLimit: BigInt(responseV06.verificationGasLimit),
+            callGasLimit: BigInt(responseV06.callGasLimit)
+        } as SponsorUserOperationReturnType<entryPoint>
+    }
+    const responseV07 = response as {
+        preVerificationGas: Hex
+        verificationGasLimit: Hex
+        callGasLimit: Hex
+        paymaster: Address
+        paymasterVerificationGasLimit: Hex
+        paymasterPostOpGasLimit: Hex
+        paymasterData: Hex
+        paymasterAndData?: never
+    }
+
+    return {
+        callGasLimit: BigInt(responseV07.callGasLimit),
+        verificationGasLimit: BigInt(responseV07.verificationGasLimit),
+        preVerificationGas: BigInt(responseV07.preVerificationGas),
+        paymaster: responseV07.paymaster,
+        paymasterVerificationGasLimit: BigInt(
+            responseV07.paymasterVerificationGasLimit
+        ),
+        paymasterPostOpGasLimit: BigInt(responseV07.paymasterPostOpGasLimit),
+        paymasterData: responseV07.paymasterData
+    } as SponsorUserOperationReturnType<entryPoint>
+    // [TODO] Add gas price params in the response in permissionless
+    // let result: UserOperation<"v0.6"> = {
+    //     ...args.userOperation,
+    //     paymasterAndData: response.paymasterAndData,
+    //     preVerificationGas: BigInt(response.preVerificationGas),
+    //     verificationGasLimit: BigInt(response.verificationGasLimit),
+    //     callGasLimit: BigInt(response.callGasLimit)
+    // }
+    // if (
+    //     response.maxFeePerGas !== undefined &&
+    //     response.maxPriorityFeePerGas !== undefined
+    // ) {
+    //     result = {
+    //         ...result,
+    //         maxFeePerGas: BigInt(response.maxFeePerGas),
+    //         maxPriorityFeePerGas: BigInt(response.maxPriorityFeePerGas)
+    //     }
+    // }
+
+    // return result
+}

package/clients/decorators/index.ts

@@ -0,0 +1,4 @@
+export {
+    zerodevPaymasterActions,
+    type ZeroDevPaymasterClientActions
+} from "./kernel.js"