@zerodev/sdk 4.0.0

package/src/kernel-zerodev/validator/base.ts

@@ -0,0 +1,265 @@
+import {
+  type SmartAccountSigner,
+  type UserOperationRequest,
+} from "@alchemy/aa-core";
+import {
+  concat,
+  type Chain,
+  type Hex,
+  pad,
+  toHex,
+  type Address,
+  concatHex,
+  hexToBigInt,
+  type PublicClient,
+  type Transport,
+  createPublicClient,
+  http,
+} from "viem";
+import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+import {
+  BUNDLER_URL,
+  CHAIN_ID_TO_NODE,
+  ECDSA_VALIDATOR_ADDRESS,
+  ENTRYPOINT_ADDRESS,
+} from "../constants.js";
+import type { PaymasterAndBundlerProviders } from "../paymaster/types.js";
+import { polygonMumbai } from "viem/chains";
+
+export enum ValidatorMode {
+  sudo = "0x00000000",
+  plugin = "0x00000001",
+  enable = "0x00000002",
+}
+
+export interface KernelBaseValidatorParams {
+  projectId: string;
+  validatorAddress?: Hex;
+  mode?: ValidatorMode;
+  chain?: Chain;
+  entryPointAddress?: Address;
+  enableSignature?: Hex;
+  validUntil?: number;
+  validAfter?: number;
+  executor?: Address;
+  selector?: string;
+  rpcUrl?: string;
+  bundlerProvider?: PaymasterAndBundlerProviders;
+}
+
+//Kernel wallet implementation separates out validation and execution phase. It allows you to have
+// custom wrapper logic for the validation phase in addition to signature of choice.
+export abstract class KernelBaseValidator {
+  readonly validatorAddress: Hex;
+  mode: ValidatorMode;
+  protected projectId: string;
+  protected chain?: Chain;
+  protected entryPointAddress: Address;
+  protected enableSignature?: Hex;
+  protected validUntil: number;
+  protected validAfter: number;
+  protected executor?: Address;
+  protected selector?: string;
+  protected rpcUrl?: string;
+  protected bundlerProvider?: PaymasterAndBundlerProviders;
+  publicClient?: PublicClient<Transport, Chain>;
+
+  constructor(params: KernelBaseValidatorParams) {
+    this.projectId = params.projectId;
+    this.validatorAddress = params.validatorAddress ?? ECDSA_VALIDATOR_ADDRESS;
+    this.mode = params.mode ?? ValidatorMode.sudo;
+    this.entryPointAddress = params.entryPointAddress ?? ENTRYPOINT_ADDRESS;
+    this.enableSignature = params.enableSignature;
+    this.validUntil = params.validUntil ?? 0;
+    this.validAfter = params.validAfter ?? 0;
+    this.executor = params.executor;
+    this.selector = params.selector;
+    this.chain = params.chain;
+    this.rpcUrl = params.rpcUrl ?? BUNDLER_URL;
+    this.bundlerProvider = params.bundlerProvider;
+    this.publicClient = createPublicClient({
+      transport: http(CHAIN_ID_TO_NODE[this.chain?.id ?? polygonMumbai.id]),
+      chain: this.chain ?? polygonMumbai,
+    });
+  }
+
+  abstract encodeEnable(enableData: Hex): Hex;
+
+  abstract encodeDisable(enableData: Hex): Hex;
+
+  abstract getEnableData(): Promise<Hex>;
+
+  abstract signMessage(message: Uint8Array | string | Hex): Promise<Hex>;
+
+  abstract signUserOp(userOp: UserOperationRequest): Promise<Hex>;
+
+  abstract signer(): Promise<SmartAccountSigner>;
+
+  abstract getDummyUserOpSignature(): Promise<Hex>;
+
+  abstract isPluginEnabled(
+    kernelAccountAddress: Address,
+    selector: Hex
+  ): Promise<boolean>;
+
+  async getDynamicDummySignature(
+    kernelAccountAddress: Address,
+    calldata: Hex
+  ): Promise<Hex> {
+    const dummyECDSASig =
+      "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+    const validatorMode = await this.resolveValidatorMode(
+      kernelAccountAddress,
+      calldata
+    );
+    if (validatorMode === ValidatorMode.enable) {
+      const enableData = await this.getEnableData();
+      const enableDataLength = enableData.length / 2 - 1;
+      const enableSigLength = 65;
+      const staticDummySig = concatHex([
+        "0x000000000000000000000000",
+        this.getAddress(),
+        "0x53dd285022D1512635823952d109dB39467a457E",
+      ]);
+
+      return concatHex([
+        ValidatorMode.enable,
+        staticDummySig,
+        pad(toHex(enableDataLength), { size: 32 }),
+        enableData,
+        pad(toHex(enableSigLength), { size: 32 }),
+        dummyECDSASig,
+        await this.getDummyUserOpSignature(),
+      ]);
+    }
+    return concatHex([validatorMode, await this.getDummyUserOpSignature()]);
+  }
+
+  setEnableSignature(enableSignature: Hex) {
+    this.enableSignature = enableSignature;
+  }
+
+  getEnableSignature(): Hex | undefined {
+    return this.enableSignature;
+  }
+
+  getAddress(): Hex {
+    return this.validatorAddress;
+  }
+
+  async approveExecutor(
+    kernel: Address,
+    selector: Hex,
+    executor: Address,
+    validUntil: number,
+    validAfter: number,
+    validator: KernelBaseValidator
+  ): Promise<Hex> {
+    if (!this.chain) {
+      throw new Error("Validator uninitialized");
+    }
+    const sender = kernel;
+    const signer = await this.signer();
+    const ownerSig = await (signer as any).signTypedData({
+      domain: {
+        name: "Kernel",
+        version: "0.2.1",
+        chainId: this.chain.id,
+        verifyingContract: sender,
+      },
+      types: {
+        ValidatorApproved: [
+          { name: "sig", type: "bytes4" },
+          { name: "validatorData", type: "uint256" },
+          { name: "executor", type: "address" },
+          { name: "enableData", type: "bytes" },
+        ],
+      },
+      message: {
+        sig: selector as Hex,
+        validatorData: hexToBigInt(
+          concatHex([
+            pad(toHex(validUntil), { size: 6 }),
+            pad(toHex(validAfter), { size: 6 }),
+            validator.getAddress(),
+          ]),
+          { size: 32 }
+        ),
+        executor: executor as Address,
+        enableData: await validator.getEnableData(),
+      },
+      primaryType: "ValidatorApproved",
+    });
+    return ownerSig;
+  }
+
+  async resolveValidatorMode(
+    kernelAccountAddress: Address,
+    callData: Hex
+  ): Promise<ValidatorMode> {
+    if (!this.chain || !this.publicClient) {
+      throw new Error("Validator uninitialized");
+    }
+
+    let mode: ValidatorMode;
+    try {
+      const defaultValidatorAddress = await this.publicClient.readContract({
+        abi: KernelAccountAbi,
+        address: kernelAccountAddress,
+        functionName: "getDefaultValidator",
+      });
+      if (
+        defaultValidatorAddress?.toLowerCase() ===
+          this.validatorAddress.toLowerCase() ||
+        this.mode === ValidatorMode.sudo
+      ) {
+        mode = ValidatorMode.sudo;
+      } else if (
+        await this.isPluginEnabled(
+          kernelAccountAddress,
+          callData.toString().slice(0, 10) as Hex
+        )
+      ) {
+        mode = ValidatorMode.plugin;
+      } else {
+        mode = ValidatorMode.enable;
+      }
+    } catch (error) {
+      if (this.mode === ValidatorMode.plugin) {
+        mode = ValidatorMode.enable;
+      } else {
+        mode = this.mode;
+      }
+    }
+    return mode;
+  }
+
+  async getSignature(userOp: UserOperationRequest): Promise<Hex> {
+    const mode = await this.resolveValidatorMode(
+      userOp.sender,
+      userOp.callData
+    );
+    if (mode === ValidatorMode.sudo || mode === ValidatorMode.plugin) {
+      return concatHex([this.mode, await this.signUserOp(userOp)]);
+    } else {
+      const enableData = await this.getEnableData();
+      const enableDataLength = enableData.length / 2 - 1;
+      const enableSignature = this.getEnableSignature();
+      if (!enableSignature) {
+        throw new Error("Enable signature not set");
+      }
+      return concat([
+        mode, // 4 bytes 0 - 4
+        pad(toHex(this.validUntil), { size: 6 }), // 6 bytes 4 - 10
+        pad(toHex(this.validAfter), { size: 6 }), // 6 bytes 10 - 16
+        pad(this.validatorAddress, { size: 20 }), // 20 bytes 16 - 36
+        pad(this.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
+        await this.signUserOp(userOp), // 120 + enableData.length + enableSignature.length - 120 + enableData.length + enableSignature.length + userOperation.length
+      ]);
+    }
+  }
+}

package/src/kernel-zerodev/validator/ecdsa-validator.ts

@@ -0,0 +1,117 @@
+import {
+  getChain,
+  getUserOperationHash,
+  type Address,
+  type Hex,
+  type SmartAccountSigner,
+  type UserOperationRequest,
+} from "@alchemy/aa-core";
+import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
+import { encodeFunctionData, toBytes } from "viem";
+import { ECDSAValidatorAbi } from "../abis/ESCDAValidatorAbi.js";
+import { getChainId } from "../api/index.js";
+import { DUMMY_ECDSA_SIG } from "../constants.js";
+import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+
+export interface ECDSAValidatorParams extends KernelBaseValidatorParams {
+  owner: SmartAccountSigner;
+}
+
+export class ECDSAValidator extends KernelBaseValidator {
+  protected owner: SmartAccountSigner;
+
+  constructor(params: ECDSAValidatorParams) {
+    super(params);
+    this.owner = params.owner;
+  }
+
+  public static async init(
+    params: ECDSAValidatorParams
+  ): Promise<ECDSAValidator> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const instance = new ECDSAValidator({ ...params, chain });
+    return instance;
+  }
+
+  async signer(): Promise<SmartAccountSigner> {
+    return await Promise.resolve(this.owner);
+  }
+
+  async getOwner(): Promise<Hex> {
+    return this.owner.getAddress();
+  }
+
+  async getEnableData(): Promise<Hex> {
+    return this.getOwner();
+  }
+
+  encodeEnable(newOwner: Hex): Hex {
+    return encodeFunctionData({
+      abi: ECDSAValidatorAbi,
+      functionName: "enable",
+      args: [newOwner],
+    });
+  }
+
+  encodeDisable(disableData: Hex = "0x"): Hex {
+    return encodeFunctionData({
+      abi: ECDSAValidatorAbi,
+      functionName: "disable",
+      args: [disableData],
+    });
+  }
+
+  async getDummyUserOpSignature(): Promise<Hex> {
+    return DUMMY_ECDSA_SIG;
+  }
+
+  async isPluginEnabled(
+    kernelAccountAddress: Address,
+    selector: Hex
+  ): Promise<boolean> {
+    if (!this.publicClient) {
+      throw new Error("Validator uninitialized: PublicClient missing");
+    }
+    const execDetail = await this.publicClient.readContract({
+      abi: KernelAccountAbi,
+      address: kernelAccountAddress,
+      functionName: "getExecution",
+      args: [selector],
+    });
+    const enableData = await this.publicClient.readContract({
+      abi: ECDSAValidatorAbi,
+      address: this.validatorAddress,
+      functionName: "ecdsaValidatorStorage",
+      args: [kernelAccountAddress],
+    });
+    return (
+      execDetail.validator.toLowerCase() ===
+        this.validatorAddress.toLowerCase() &&
+      enableData.toLowerCase() === (await this.getEnableData()).toLowerCase()
+    );
+  }
+
+  async signMessage(message: string | Uint8Array): Promise<Hex> {
+    return await this.owner.signMessage(message);
+  }
+
+  async signUserOp(userOp: UserOperationRequest): Promise<Hex> {
+    if (!this.chain) {
+      throw new Error("Validator uninitialized");
+    }
+    const hash = getUserOperationHash(
+      {
+        ...userOp,
+        signature: "0x",
+      },
+      this.entryPointAddress,
+      BigInt(this.chain.id)
+    );
+    const formattedMessage = typeof hash === "string" ? toBytes(hash) : hash;
+    return await this.owner.signMessage(formattedMessage);
+  }
+}

package/src/kernel-zerodev/validator/erc165-session-key-validator.ts

@@ -0,0 +1,127 @@
+import {
+  getUserOperationHash,
+  type Address,
+  type Hex,
+  type SmartAccountSigner,
+  type UserOperationRequest,
+} from "@alchemy/aa-core";
+import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
+import { encodeFunctionData, toBytes, concat, pad, toHex } from "viem";
+import { ERC165SessionKeyValidatorAbi } from "../abis/ERC165SessionKeyValidatorAbi.js";
+import { DUMMY_ECDSA_SIG } from "../constants.js";
+import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+
+export interface ERC165SessionKeyValidatorParams
+  extends KernelBaseValidatorParams {
+  sessionKey: SmartAccountSigner;
+  sessionKeyData: SessionKeyData;
+}
+
+interface SessionKeyData {
+  selector: Hex;
+  erc165InterfaceId: Hex;
+  validUntil: number;
+  validAfter: number;
+  addressOffset: number;
+}
+
+export class ERC165SessionKeyValidator extends KernelBaseValidator {
+  protected sessionKey: SmartAccountSigner;
+  sessionKeyData: SessionKeyData;
+
+  constructor(params: ERC165SessionKeyValidatorParams) {
+    super(params);
+    this.sessionKey = params.sessionKey;
+    this.sessionKeyData = params.sessionKeyData;
+  }
+
+  async signer(): Promise<SmartAccountSigner> {
+    return await Promise.resolve(this.sessionKey);
+  }
+
+  async getEnableData(): Promise<Hex> {
+    return concat([
+      await this.sessionKey.getAddress(),
+      pad(this.sessionKeyData.erc165InterfaceId, { size: 4 }),
+      pad(this.sessionKeyData.selector, { size: 4 }),
+      pad(toHex(this.sessionKeyData.validUntil), { size: 6 }),
+      pad(toHex(this.sessionKeyData.validAfter), { size: 6 }),
+      pad(toHex(this.sessionKeyData.addressOffset), { size: 4 }),
+    ]);
+  }
+
+  async isPluginEnabled(
+    kernelAccountAddress: Address,
+    selector: Hex
+  ): Promise<boolean> {
+    if (!this.publicClient) {
+      throw new Error("Validator uninitialized: PublicClient missing");
+    }
+    const execDetail = await this.publicClient.readContract({
+      abi: KernelAccountAbi,
+      address: kernelAccountAddress,
+      functionName: "getExecution",
+      args: [selector],
+    });
+    const enableData = await this.publicClient.readContract({
+      abi: ERC165SessionKeyValidatorAbi,
+      address: this.validatorAddress,
+      functionName: "sessionKeys",
+      args: [await this.sessionKey.getAddress(), kernelAccountAddress],
+    });
+    const enableDataHex = concat([
+      await this.sessionKey.getAddress(),
+      pad(enableData[2], { size: 4 }),
+      pad(enableData[1], { size: 4 }),
+      pad(toHex(enableData[3]), { size: 6 }),
+      pad(toHex(enableData[4]), { size: 6 }),
+      pad(toHex(enableData[5]), { size: 4 }),
+    ]);
+    return (
+      execDetail.validator.toLowerCase() ===
+        this.validatorAddress.toLowerCase() &&
+      enableData[0] &&
+      enableDataHex.toLowerCase() === (await this.getEnableData()).toLowerCase()
+    );
+  }
+
+  async getDummyUserOpSignature(): Promise<Hex> {
+    return DUMMY_ECDSA_SIG;
+  }
+
+  encodeEnable(sessionKeyEnableData: Hex): Hex {
+    return encodeFunctionData({
+      abi: ERC165SessionKeyValidatorAbi,
+      functionName: "enable",
+      args: [sessionKeyEnableData],
+    });
+  }
+
+  encodeDisable(sessionKey: Hex): Hex {
+    return encodeFunctionData({
+      abi: ERC165SessionKeyValidatorAbi,
+      functionName: "disable",
+      args: [sessionKey],
+    });
+  }
+
+  async signMessage(message: string | Uint8Array): Promise<Hex> {
+    return await this.sessionKey.signMessage(message);
+  }
+
+  async signUserOp(userOp: UserOperationRequest): Promise<Hex> {
+    if (!this.chain) {
+      throw new Error("Validator uninitialized");
+    }
+    const hash = getUserOperationHash(
+      {
+        ...userOp,
+        signature: "0x",
+      },
+      this.entryPointAddress,
+      BigInt(this.chain.id)
+    );
+    const formattedMessage = typeof hash === "string" ? toBytes(hash) : hash;
+    return await this.sessionKey.signMessage(formattedMessage);
+  }
+}

package/src/kernel-zerodev/validator/index.ts

@@ -0,0 +1,12 @@
+import { ECDSAValidator } from "./ecdsa-validator.js";
+import { ERC165SessionKeyValidator } from "./erc165-session-key-validator.js";
+import { KillSwitchValidator } from "./kill-switch-validator.js";
+import type { ValidatorMap } from "./types.js";
+
+export const Validators: ValidatorMap = {
+  ECDSA: ECDSAValidator,
+  KILL_SWITCH: KillSwitchValidator,
+  ERC165_SESSION_KEY: ERC165SessionKeyValidator,
+};
+
+export { ECDSAValidator, KillSwitchValidator, ERC165SessionKeyValidator };

package/src/kernel-zerodev/validator/kill-switch-validator.ts

@@ -0,0 +1,142 @@
+import {
+  getChain,
+  getUserOperationHash,
+  type Address,
+  type Hex,
+  type SmartAccountSigner,
+  type UserOperationRequest,
+} from "@alchemy/aa-core";
+import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
+import {
+  concat,
+  concatHex,
+  encodeFunctionData,
+  getContract,
+  keccak256,
+  pad,
+  toBytes,
+  toHex,
+} from "viem";
+import { KillSwitchValidatorAbi } from "../abis/KillSwitchValidatorAbi.js";
+import { getChainId } from "../api/index.js";
+import { DUMMY_ECDSA_SIG } from "../constants.js";
+import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+
+export interface KillSwitchValidatorParams extends KernelBaseValidatorParams {
+  guardian: SmartAccountSigner;
+  delaySeconds: number;
+}
+
+export class KillSwitchValidator extends KernelBaseValidator {
+  protected guardian: SmartAccountSigner;
+  protected delaySeconds: number;
+
+  constructor(params: KillSwitchValidatorParams) {
+    super(params);
+    this.guardian = params.guardian;
+    this.delaySeconds = params.delaySeconds;
+  }
+
+  public static async init(
+    params: KillSwitchValidatorParams
+  ): Promise<KillSwitchValidator> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const instance = new KillSwitchValidator({ ...params, chain });
+    return instance;
+  }
+
+  async signer(): Promise<SmartAccountSigner> {
+    return await Promise.resolve(this.guardian);
+  }
+
+  async getEnableData(): Promise<Hex> {
+    return await (await this.signer()).getAddress();
+  }
+
+  getPausedUntil(): number {
+    return Math.floor(Date.now() / 1000) + this.delaySeconds;
+  }
+
+  encodeEnable(newGuardian: Hex): Hex {
+    return encodeFunctionData({
+      abi: KillSwitchValidatorAbi,
+      functionName: "enable",
+      args: [newGuardian],
+    });
+  }
+
+  encodeDisable(disableData: Hex = "0x"): Hex {
+    return encodeFunctionData({
+      abi: KillSwitchValidatorAbi,
+      functionName: "disable",
+      args: [disableData],
+    });
+  }
+
+  async isPluginEnabled(
+    kernelAccountAddress: Address,
+    selector: Hex
+  ): Promise<boolean> {
+    if (!this.publicClient) {
+      throw new Error("Validator uninitialized: PublicClient missing");
+    }
+    const kernel = getContract({
+      abi: KernelAccountAbi,
+      address: kernelAccountAddress,
+      publicClient: this.publicClient,
+    });
+    const execDetail = await kernel.read.getExecution([selector]);
+    const enableData = await this.publicClient.readContract({
+      abi: KillSwitchValidatorAbi,
+      address: this.validatorAddress,
+      functionName: "killSwitchValidatorStorage",
+      args: [kernelAccountAddress],
+    });
+    const pausedUntil = Math.floor(Date.now() / 1000) + this.delaySeconds;
+    return (
+      execDetail.validator.toLowerCase() ===
+        this.validatorAddress.toLowerCase() &&
+      enableData[0] === (await this.getEnableData()) &&
+      enableData[3] === (await kernel.read.getDisabledMode()) &&
+      enableData[2] === pausedUntil &&
+      enableData[1].toLowerCase() ===
+        (await kernel.read.getDefaultValidator()).toLowerCase()
+    );
+  }
+
+  async getDummyUserOpSignature(): Promise<Hex> {
+    return concatHex([pad("0xffffffffffff", { size: 6 }), DUMMY_ECDSA_SIG]);
+  }
+
+  async signMessage(message: string | Uint8Array): Promise<Hex> {
+    return await this.guardian.signMessage(message);
+  }
+
+  async signUserOp(userOp: UserOperationRequest): Promise<Hex> {
+    const pausedUntil = this.getPausedUntil();
+    if (!this.chain) {
+      throw new Error("Validator uninitialized");
+    }
+    const hash = getUserOperationHash(
+      {
+        ...userOp,
+        signature: "0x",
+      },
+      this.entryPointAddress,
+      BigInt(this.chain.id)
+    ) as Hex;
+
+    const extendedHash = keccak256(
+      concat([pad(toHex(pausedUntil), { size: 6 }), hash])
+    );
+    const signature = concat([
+      pad(toHex(pausedUntil), { size: 6 }),
+      await this.guardian.signMessage(toBytes(extendedHash)),
+    ]);
+    return signature;
+  }
+}

package/src/kernel-zerodev/validator/types.ts

@@ -0,0 +1,36 @@
+import type {
+  ECDSAValidator,
+  ECDSAValidatorParams,
+} from "./ecdsa-validator.js";
+import type {
+  ERC165SessionKeyValidator,
+  ERC165SessionKeyValidatorParams,
+} from "./erc165-session-key-validator.js";
+
+import type {
+  KillSwitchValidator,
+  KillSwitchValidatorParams,
+} from "./kill-switch-validator.js";
+
+export type SupportedValidators =
+  | "ECDSA"
+  | "KILL_SWITCH"
+  | "ERC165_SESSION_KEY";
+
+export type ValidatorTypeMap = {
+  ECDSA: ECDSAValidator;
+  KILL_SWITCH: KillSwitchValidator;
+  ERC165_SESSION_KEY: ERC165SessionKeyValidator;
+};
+
+export type ValidatorParamsMap = {
+  ECDSA: ECDSAValidatorParams;
+  KILL_SWITCH: KillSwitchValidatorParams;
+  ERC165_SESSION_KEY: ERC165SessionKeyValidatorParams;
+};
+
+export type ValidatorMap = {
+  [V in SupportedValidators]: new (
+    params: ValidatorParamsMap[V]
+  ) => ValidatorTypeMap[V];
+};