@zerodev/sdk 4.0.2-alpha.23

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];
+};

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

@@ -0,0 +1,140 @@
+import {
+  type Hex,
+  type SendUserOperationResult,
+  type SmartAccountSigner,
+} from "@alchemy/aa-core";
+import { ZeroDevProvider, type ZeroDevProviderConfig } from "../provider.js";
+import type {
+  KernelBaseValidator,
+  KernelBaseValidatorParams,
+} from "../validator/base.js";
+import type {
+  PaymasterAndBundlerProviders,
+  PaymasterConfig,
+  PaymasterPolicy,
+} from "../paymaster/types.js";
+import {
+  KernelSmartContractAccount,
+  type KernelSmartAccountParams,
+  isKernelAccount,
+} from "../account.js";
+import { polygonMumbai } from "viem/chains";
+import { withZeroDevPaymasterAndData } from "../middleware/paymaster.js";
+import type { RequiredProps } from "../types.js";
+
+export type ValidatorProviderParamsOpts<P extends KernelBaseValidatorParams> = {
+  paymasterConfig?: PaymasterConfig<PaymasterPolicy>;
+  providerConfig?: Partial<ZeroDevProviderConfig>;
+  accountConfig?: Omit<
+    KernelSmartAccountParams,
+    keyof ExtendedValidatorProviderParams<P>
+  >;
+  validatorConfig?: Omit<P, keyof ExtendedValidatorProviderParams<P>>;
+};
+
+export interface ValidatorProviderParams<P extends KernelBaseValidatorParams> {
+  projectId: string;
+  owner: SmartAccountSigner;
+  bundlerProvider?: PaymasterAndBundlerProviders;
+  opts?: ValidatorProviderParamsOpts<P>;
+  usePaymaster?: boolean;
+}
+
+export type ExtendedValidatorProviderParams<
+  P extends KernelBaseValidatorParams
+> = ValidatorProviderParams<P> & RequiredProps<P>;
+
+// A simple facade abstraction for validator related provider operations
+// Needs to be implemented for each validator plugin
+export abstract class ValidatorProvider<
+  P extends KernelBaseValidatorParams
+> extends ZeroDevProvider {
+  constructor(
+    params: ExtendedValidatorProviderParams<P>,
+    validator: KernelBaseValidator
+  ) {
+    super({
+      ...params.opts?.providerConfig,
+      chain: params.opts?.providerConfig?.chain ?? polygonMumbai,
+      rpcUrl: params.opts?.providerConfig?.rpcUrl,
+      projectId: params.projectId,
+      bundlerProvider: params.bundlerProvider,
+    });
+    this.connect(
+      () =>
+        new KernelSmartContractAccount({
+          projectId: params.projectId,
+          owner: params.owner,
+          validator,
+          rpcClient: this.rpcClient,
+          bundlerProvider: params.bundlerProvider,
+          ...params.opts?.accountConfig,
+        })
+    );
+    if (params.usePaymaster === undefined || params.usePaymaster) {
+      withZeroDevPaymasterAndData(
+        this,
+        params.opts?.paymasterConfig ?? { policy: "VERIFYING_PAYMASTER" }
+      );
+    }
+  }
+
+  getValidator = (): KernelBaseValidator => {
+    if (!isKernelAccount(this.account) || !this.account.validator) {
+      throw new Error(
+        "ValidatorProvider: account with validator is not set, did you call all connects first?"
+      );
+    }
+    return this.account.getValidator();
+  };
+
+  getEncodedEnableData = async (enableData: Hex): Promise<Hex> => {
+    if (!isKernelAccount(this.account) || !this.account.validator) {
+      throw new Error(
+        "ValidatorProvider: account with validator is not set, did you call all connects first?"
+      );
+    }
+    return await this.account.validator.encodeEnable(enableData);
+  };
+
+  getEncodedDisableData = async (disableData: Hex): Promise<Hex> => {
+    if (!isKernelAccount(this.account) || !this.account.validator) {
+      throw new Error(
+        "ValidatorProvider: account with validator is not set, did you call all connects first?"
+      );
+    }
+    return await this.account.validator.encodeDisable(disableData);
+  };
+
+  sendEnableUserOperation = async (
+    enableData: Hex
+  ): Promise<SendUserOperationResult> => {
+    const encodedEnableData = await this.getEncodedEnableData(enableData);
+    if (!isKernelAccount(this.account) || !this.account.validator) {
+      throw new Error(
+        "ValidatorProvider: account with validator is not set, did you call all connects first?"
+      );
+    }
+
+    return await this.sendUserOperation({
+      target: this.account.validator.validatorAddress,
+      data: encodedEnableData,
+    });
+  };
+
+  sendDisableUserOperation = async (
+    disableData: Hex
+  ): Promise<SendUserOperationResult> => {
+    const encodedDisableData = await this.getEncodedDisableData(disableData);
+    if (!isKernelAccount(this.account) || !this.account.validator) {
+      throw new Error(
+        "ValidatorProvider: account with validator is not set, did you call all connects first?"
+      );
+    }
+
+    return await this.sendUserOperation({
+      target: this.account.validator.validatorAddress,
+      data: encodedDisableData,
+    });
+  };
+}

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

@@ -0,0 +1,61 @@
+import {
+  ValidatorProvider,
+  type ExtendedValidatorProviderParams,
+} from "./base.js";
+import {
+  ECDSAValidator,
+  type ECDSAValidatorParams,
+} from "../validator/ecdsa-validator.js";
+import { getChain } from "@alchemy/aa-core";
+import { getChainId } from "../api/index.js";
+import { polygonMumbai } from "viem/chains";
+
+export class ECDSAProvider extends ValidatorProvider<ECDSAValidatorParams> {
+  constructor(params: ExtendedValidatorProviderParams<ECDSAValidatorParams>) {
+    const chain =
+      typeof params.opts?.providerConfig?.chain === "number"
+        ? getChain(params.opts.providerConfig.chain)
+        : params.opts?.providerConfig?.chain ?? polygonMumbai;
+    const validator = new ECDSAValidator({
+      projectId: params.projectId,
+      owner: params.owner,
+      chain,
+      ...params.opts?.validatorConfig,
+    });
+    super(
+      {
+        ...params,
+        opts: {
+          ...params.opts,
+          providerConfig: { ...params.opts?.providerConfig, chain },
+        },
+      },
+      validator
+    );
+  }
+
+  public static async init(
+    params: ExtendedValidatorProviderParams<ECDSAValidatorParams>
+  ): Promise<ECDSAProvider> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const instance = new ECDSAProvider({
+      ...params,
+      opts: {
+        ...params.opts,
+        providerConfig: {
+          chain,
+          ...params.opts?.providerConfig,
+        },
+      },
+    });
+    return instance;
+  }
+
+  changeOwner = this.sendEnableUserOperation;
+
+  deleteOwner = this.sendDisableUserOperation;
+}

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

@@ -0,0 +1,68 @@
+import {
+  ValidatorProvider,
+  type ExtendedValidatorProviderParams,
+} from "./base.js";
+import {
+  ERC165SessionKeyValidator,
+  type ERC165SessionKeyValidatorParams,
+} from "../validator/erc165-session-key-validator.js";
+import { getChain } from "@alchemy/aa-core";
+import { getChainId } from "../api/index.js";
+import { polygonMumbai } from "viem/chains";
+import { ERC165_SESSION_KEY_VALIDATOR_ADDRESS } from "../constants.js";
+
+export class ERC165SessionKeyProvider extends ValidatorProvider<ERC165SessionKeyValidatorParams> {
+  constructor(
+    params: ExtendedValidatorProviderParams<ERC165SessionKeyValidatorParams>
+  ) {
+    const chain =
+      typeof params.opts?.providerConfig?.chain === "number"
+        ? getChain(params.opts.providerConfig.chain)
+        : params.opts?.providerConfig?.chain ?? polygonMumbai;
+    const validator = new ERC165SessionKeyValidator({
+      projectId: params.projectId,
+      sessionKey: params.sessionKey,
+      sessionKeyData: params.sessionKeyData,
+      chain,
+      validatorAddress:
+        params.opts?.validatorConfig?.validatorAddress ??
+        ERC165_SESSION_KEY_VALIDATOR_ADDRESS,
+      ...params.opts?.validatorConfig,
+    });
+    super(
+      {
+        ...params,
+        opts: {
+          ...params.opts,
+          providerConfig: { ...params.opts?.providerConfig, chain },
+        },
+      },
+      validator
+    );
+  }
+
+  public static async init(
+    params: ExtendedValidatorProviderParams<ERC165SessionKeyValidatorParams>
+  ): Promise<ERC165SessionKeyProvider> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const instance = new ERC165SessionKeyProvider({
+      ...params,
+      opts: {
+        ...params.opts,
+        providerConfig: {
+          chain,
+          ...params.opts?.providerConfig,
+        },
+      },
+    });
+    return instance;
+  }
+
+  changeGuardian = this.sendEnableUserOperation;
+
+  deleteERC165SessionKeyData = this.sendDisableUserOperation;
+}

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

@@ -0,0 +1,12 @@
+import { ECDSAProvider } from "./ecdsa-provider.js";
+import { ERC165SessionKeyProvider } from "./erc165-session-key-provider.js";
+import { KillSwitchProvider } from "./kill-switch-provider.js";
+import type { ValidatorProviderMap } from "./types.js";
+
+export const ValidatorProviders: ValidatorProviderMap = {
+  ECDSA: ECDSAProvider,
+  KILL_SWITCH: KillSwitchProvider,
+  ERC165_SESSION_KEY: ERC165SessionKeyProvider,
+};
+
+export { ECDSAProvider, KillSwitchProvider, ERC165SessionKeyProvider };

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

@@ -0,0 +1,68 @@
+import {
+  ValidatorProvider,
+  type ExtendedValidatorProviderParams,
+} from "./base.js";
+import {
+  KillSwitchValidator,
+  type KillSwitchValidatorParams,
+} from "../validator/kill-switch-validator.js";
+import { getChain } from "@alchemy/aa-core";
+import { getChainId } from "../api/index.js";
+import { polygonMumbai } from "viem/chains";
+import { KILL_SWITCH_VALIDATOR_ADDRESS } from "../constants.js";
+
+export class KillSwitchProvider extends ValidatorProvider<KillSwitchValidatorParams> {
+  constructor(
+    params: ExtendedValidatorProviderParams<KillSwitchValidatorParams>
+  ) {
+    const chain =
+      typeof params.opts?.providerConfig?.chain === "number"
+        ? getChain(params.opts.providerConfig.chain)
+        : params.opts?.providerConfig?.chain ?? polygonMumbai;
+    const validator = new KillSwitchValidator({
+      projectId: params.projectId,
+      guardian: params.guardian,
+      delaySeconds: params.delaySeconds,
+      chain,
+      validatorAddress:
+        params.opts?.validatorConfig?.validatorAddress ??
+        KILL_SWITCH_VALIDATOR_ADDRESS,
+      ...params.opts?.validatorConfig,
+    });
+    super(
+      {
+        ...params,
+        opts: {
+          ...params.opts,
+          providerConfig: { ...params.opts?.providerConfig, chain },
+        },
+      },
+      validator
+    );
+  }
+
+  public static async init(
+    params: ExtendedValidatorProviderParams<KillSwitchValidatorParams>
+  ): Promise<KillSwitchProvider> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const instance = new KillSwitchProvider({
+      ...params,
+      opts: {
+        ...params.opts,
+        providerConfig: {
+          chain,
+          ...params.opts?.providerConfig,
+        },
+      },
+    });
+    return instance;
+  }
+
+  changeGuardian = this.sendEnableUserOperation;
+
+  deleteKillSwitchData = this.sendDisableUserOperation;
+}

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

@@ -0,0 +1,26 @@
+import type { ECDSAValidatorParams } from "../validator/ecdsa-validator.js";
+import type { ERC165SessionKeyValidatorParams } from "../validator/erc165-session-key-validator.js";
+import type { KillSwitchValidatorParams } from "../validator/kill-switch-validator.js";
+import type { SupportedValidators } from "../validator/types.js";
+import type { ExtendedValidatorProviderParams } from "./base.js";
+import type { ECDSAProvider } from "./ecdsa-provider.js";
+import type { ERC165SessionKeyProvider } from "./erc165-session-key-provider.js";
+import type { KillSwitchProvider } from "./kill-switch-provider.js";
+
+export type ValidatorProviderTypeMap = {
+  ECDSA: ECDSAProvider;
+  KILL_SWITCH: KillSwitchProvider;
+  ERC165_SESSION_KEY: ERC165SessionKeyProvider;
+};
+
+export type ValidatorProviderParamsMap = {
+  ECDSA: ExtendedValidatorProviderParams<ECDSAValidatorParams>;
+  KILL_SWITCH: ExtendedValidatorProviderParams<KillSwitchValidatorParams>;
+  ERC165_SESSION_KEY: ExtendedValidatorProviderParams<ERC165SessionKeyValidatorParams>;
+};
+
+export type ValidatorProviderMap = {
+  [V in SupportedValidators]: new (
+    params: ValidatorProviderParamsMap[V]
+  ) => ValidatorProviderTypeMap[V];
+};