@zerodev/sdk 4.5.5 → 5.0.0-beta.0

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

@@ -1,122 +0,0 @@
-import {
-  getUserOperationHash,
-  type Address,
-  type Hex,
-  type SmartAccountSigner,
-  type UserOperationRequest,
-  type SignTypedDataParams,
-} 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";
-import { fixSignedData, getChain } from "../utils.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 signTypedData(params: SignTypedDataParams): Promise<Hex> {
-    return fixSignedData(await this.owner.signTypedData(params));
-  }
-
-  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

@@ -1,151 +0,0 @@
-import {
-  getUserOperationHash,
-  type Address,
-  type Hex,
-  type SmartAccountSigner,
-  type UserOperationRequest,
-  type SignTypedDataParams,
-} from "@alchemy/aa-core";
-import {
-  KernelBaseValidator,
-  ValidatorMode,
-  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";
-import { getChainId } from "../api/index.js";
-import { fixSignedData, getChain } from "../utils.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;
-    this.mode = params.mode ?? ValidatorMode.plugin;
-  }
-
-  public static async init(
-    params: ERC165SessionKeyValidatorParams
-  ): Promise<ERC165SessionKeyValidator> {
-    const chainId = await getChainId(params.projectId);
-    if (!chainId) {
-      throw new Error("ChainId not found");
-    }
-    const chain = getChain(chainId);
-    const instance = new ERC165SessionKeyValidator({ ...params, chain });
-    return instance;
-  }
-
-  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 signTypedData(params: SignTypedDataParams): Promise<Hex> {
-    return fixSignedData(await this.sessionKey.signTypedData(params));
-  }
-
-  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

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

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

@@ -1,160 +0,0 @@
-import {
-  getUserOperationHash,
-  type Address,
-  type Hex,
-  type SmartAccountSigner,
-  type UserOperationRequest,
-  type SignTypedDataParams,
-} from "@alchemy/aa-core";
-import {
-  KernelBaseValidator,
-  ValidatorMode,
-  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";
-import { fixSignedData, getChain } from "../utils.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;
-    this.mode = params.mode ?? ValidatorMode.plugin;
-  }
-
-  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> {
-    if (this.mode === ValidatorMode.sudo) {
-      return DUMMY_ECDSA_SIG;
-    }
-    return concatHex([pad("0xffffffffffff", { size: 6 }), DUMMY_ECDSA_SIG]);
-  }
-
-  async signMessage(message: string | Uint8Array): Promise<Hex> {
-    return await this.guardian.signMessage(message);
-  }
-
-  async signTypedData(params: SignTypedDataParams): Promise<Hex> {
-    return fixSignedData(await this.guardian.signTypedData(params));
-  }
-
-  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;
-
-    if (this.mode === ValidatorMode.sudo) {
-      const formattedMessage = typeof hash === "string" ? toBytes(hash) : hash;
-      return await this.guardian.signMessage(formattedMessage);
-    }
-
-    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;
-  }
-}