@zerodev/sdk 4.0.9 → 4.0.11

package/src/kernel-zerodev/account.ts

@@ -8,17 +8,14 @@ import {
   type Hex,
   toBytes,
   type Transport,
-  pad,
-  toHex,
 } from "viem";
 import { parseAbiParameters } from "abitype";
-import { KernelBaseValidator, ValidatorMode } from "./validator/base.js";
+import { KernelBaseValidator } from "./validator/base.js";
 import { KernelAccountAbi } from "./abis/KernelAccountAbi.js";
 import { KernelFactoryAbi } from "./abis/KernelFactoryAbi.js";
 import {
   type BaseSmartAccountParams,
   BaseSmartContractAccount,
-  type SmartAccountSigner,
   type BatchUserOperationCallData,
   type UserOperationRequest,
   defineReadOnly,
@@ -38,17 +35,22 @@ import { polygonMumbai } from "viem/chains";
 import { getChainId } from "./api/index.js";
 import { createZeroDevPublicErc4337Client } from "./client/create-client.js";
 import type { PaymasterAndBundlerProviders } from "./paymaster/types.js";
-import type { KillSwitchValidator } from "./validator/kill-switch-validator.js";
 
+export enum DeploymentState {
+  UNDEFINED = "0x0",
+  NOT_DEPLOYED = "0x1",
+  DEPLOYED = "0x2",
+}
 export interface KernelSmartAccountParams<
   TTransport extends Transport | FallbackTransport = Transport
 > extends Partial<BaseSmartAccountParams<TTransport>> {
   projectId: string;
-  owner: SmartAccountSigner;
   factoryAddress?: Address;
   index?: bigint;
   validator?: KernelBaseValidator;
   bundlerProvider?: PaymasterAndBundlerProviders;
+  defaultValidator?: KernelBaseValidator;
+  initCode?: Hex;
 }
 
 export function isKernelAccount(
@@ -60,10 +62,11 @@ export function isKernelAccount(
 export class KernelSmartContractAccount<
   TTransport extends Transport | FallbackTransport = Transport
 > extends BaseSmartContractAccount<TTransport> {
-  private owner: SmartAccountSigner;
   private readonly factoryAddress: Address;
   private readonly index: bigint;
+  private initCode?: Hex;
   validator?: KernelBaseValidator;
+  defaultValidator?: KernelBaseValidator;
 
   constructor(params: KernelSmartAccountParams) {
     super({
@@ -73,9 +76,10 @@ export class KernelSmartContractAccount<
       rpcClient: params.rpcClient ?? BUNDLER_URL,
     });
     this.index = params.index ?? 0n;
-    this.owner = params.owner;
     this.factoryAddress = params.factoryAddress ?? KERNEL_FACTORY_ADDRESS;
     this.validator = params.validator;
+    this.defaultValidator = params.defaultValidator;
+    this.initCode = params.initCode;
   }
 
   public static async init(
@@ -119,52 +123,55 @@ export class KernelSmartContractAccount<
     return "0x00000000870fe151d548a1c527c3804866fab30abf28ed17b79d5fc5149f19ca0819fefc3c57f3da4fdf9b10fab3f2f3dca536467ae44943b9dbb8433efe7760ddd72aaa1c";
   }
 
-  async getDynamicDummySignature(
-    kernelAccountAddress: Address,
-    calldata: Hex
-  ): Promise<Hex> {
-    if (!this.validator) {
-      throw new Error("Validator not connected");
+  async getInitCode(): Promise<Hex> {
+    if (this.deploymentState === DeploymentState.DEPLOYED) {
+      return "0x";
     }
-
-    const dummyECDSASig =
-      "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-    const validatorMode = await this.validator.resolveValidatorMode(
-      kernelAccountAddress,
-      calldata
+    const contractCode = await this.rpcProvider.getContractCode(
+      await this.getAddress()
     );
-    if (validatorMode === ValidatorMode.enable) {
-      const enableData = await this.validator.getEnableData();
-      const enableDataLength = enableData.length / 2 - 1;
-      const enableSigLength = 65;
-      const staticDummySig = concatHex([
-        "0x000000000000000000000000",
-        this.validator.getAddress(),
-        "0x53dd285022D1512635823952d109dB39467a457E",
-      ]);
-      const pausedUntil = await (
-        this.validator as KillSwitchValidator
-      ).getPausedUntil();
 
-      return concatHex([
-        ValidatorMode.enable,
-        staticDummySig,
-        pad(toHex(enableDataLength), { size: 32 }),
-        enableData,
-        pad(toHex(enableSigLength), { size: 32 }),
-        dummyECDSASig,
-        pad(toHex(pausedUntil), { size: 6 }),
-        dummyECDSASig,
-      ]);
+    if ((contractCode?.length ?? 0) > 2) {
+      this.deploymentState = DeploymentState.DEPLOYED;
+      return "0x";
+    } else {
+      this.deploymentState = DeploymentState.NOT_DEPLOYED;
+    }
+
+    return this.initCode ?? this.getAccountInitCode();
+  }
+
+  getIndex(): bigint {
+    return this.index;
+  }
+
+  async approvePlugin() {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+    if (this.defaultValidator && !this.validator.getEnableSignature()) {
+      const { executor, selector, validAfter, validUntil } =
+        this.validator.getPluginValidatorData();
+      const enableSig = await this.defaultValidator.approveExecutor(
+        await this.getAddress(),
+        selector,
+        executor,
+        validUntil,
+        validAfter,
+        this.validator
+      );
+      this.validator.setEnableSignature(enableSig);
     }
-    return concatHex([validatorMode, dummyECDSASig]);
   }
 
   async encodeExecute(target: Hex, value: bigint, data: Hex): Promise<Hex> {
     if (!this.validator) {
       throw new Error("Validator not connected");
     }
-    if (target.toLowerCase() === this.accountAddress?.toLowerCase()) {
+    if (
+      target.toLowerCase() === (await this.getAddress()).toLowerCase() &&
+      this.validator.shouldDelegateViaFallback()
+    ) {
       return data;
     } else {
       return this.encodeExecuteAction(target, value, data, 0);
@@ -196,8 +203,11 @@ export class KernelSmartContractAccount<
 
   async signWithEip6492(msg: string | Uint8Array): Promise<Hex> {
     try {
+      if (!this.validator) {
+        throw new Error("Validator not connected");
+      }
       const formattedMessage = typeof msg === "string" ? toBytes(msg) : msg;
-      let sig = await this.owner.signMessage(
+      let sig = await this.validator.signMessage(
         toBytes(hashMessage({ raw: formattedMessage }))
       );
       // If the account is undeployed, use ERC-6492
@@ -255,7 +265,8 @@ export class KernelSmartContractAccount<
   }
 
   protected async getFactoryInitCode(): Promise<Hex> {
-    if (!this.validator) {
+    const validator = this.defaultValidator ?? this.validator;
+    if (!validator) {
       throw new Error("Validator not connected");
     }
     try {
@@ -267,10 +278,7 @@ export class KernelSmartContractAccount<
           encodeFunctionData({
             abi: KernelAccountAbi,
             functionName: "initialize",
-            args: [
-              this.validator.getAddress(),
-              await this.validator.getEnableData(),
-            ],
+            args: [validator.getAddress(), await validator.getEnableData()],
           }),
           this.index,
         ],

package/src/kernel-zerodev/constants.ts

@@ -3,7 +3,7 @@ import type { IGasTokenAddresses } from "./paymaster/types.js";
 import { polygon } from "viem/chains";
 
 export const DEFAULT_SEND_TX_MAX_RETRIES = 3;
-export const DEFAULT_SEND_TX_RETRY_INTERVAL_MS = 1_80_000; // 3 minutes
+export const DEFAULT_SEND_TX_RETRY_INTERVAL_MS = 60000; // 1 minutes
 export const BUNDLER_URL = "https://v0-6-meta-bundler.onrender.com";
 export const PAYMASTER_URL = "https://v0-6-paymaster.onrender.com";
 export const ENTRYPOINT_ADDRESS: Hex =
@@ -24,6 +24,9 @@ export const DUMMY_ECDSA_SIG =
 export const ERC165_SESSION_KEY_VALIDATOR_ADDRESS =
   "0xe149290800De29D4b0BF9dB82c508255D81902E6";
 export const TOKEN_ACTION = "0x2087C7FfD0d0DAE80a00EE74325aBF3449e0eaf1";
+export const SESSION_KEY_VALIDATOR_ADDRESS =
+  "0x1C1D5b70aD6e0c04366aab100261A6Bcc251EA3f";
+export const oneAddress = "0x0000000000000000000000000000000000000001";
 
 export const gasTokenChainAddresses: IGasTokenAddresses = {
   USDC: {

package/src/kernel-zerodev/ethers-provider/account-signer.ts

@@ -1,5 +1,4 @@
 import {
-  BaseSmartContractAccount,
   resolveProperties,
   type AccountMiddlewareFn,
   type FeeDataMiddleware,
@@ -23,6 +22,7 @@ import {
 } from "@ethersproject/providers";
 import { ZeroDevEthersProvider } from "./ethers-provider.js";
 import type { SupportedValidators } from "../validator/types.js";
+import type { KernelSmartContractAccount } from "../account.js";
 
 const hexlifyOptional = (value: any): `0x${string}` | undefined => {
   if (value == null) {
@@ -36,14 +36,14 @@ export class ZeroDevAccountSigner<V extends SupportedValidators>
   extends Signer
   implements TypedDataSigner
 {
-  private account?: BaseSmartContractAccount;
+  private account?: KernelSmartContractAccount;
 
   sendUserOperation;
   waitForUserOperationTransaction;
 
   constructor(readonly provider: ZeroDevEthersProvider<V>) {
     super();
-    this.account = this.provider.accountProvider.account;
+    this.account = this.provider.accountProvider.getAccount();
 
     this.sendUserOperation =
       this.provider.accountProvider.sendUserOperation.bind(

package/src/kernel-zerodev/ethers-provider/ethers-provider.ts

@@ -1,8 +1,6 @@
 import { getChainId } from "../api/index.js";
 import {
-  SmartAccountProvider,
   getChain,
-  type HttpTransport,
   BaseSmartContractAccount,
   defineReadOnly,
   type AccountMiddlewareFn,
@@ -14,22 +12,34 @@ import {
 import { ZeroDevAccountSigner } from "./account-signer.js";
 import { JsonRpcProvider } from "@ethersproject/providers";
 import type { SupportedValidators } from "../validator/types.js";
-import type { ValidatorProviderParamsMap } from "../validator-provider/types.js";
+import type {
+  ValidatorProviderParamsMap,
+  ValidatorProviderTypeMap,
+} from "../validator-provider/types.js";
 import { ValidatorProviders } from "../validator-provider/index.js";
 import { withZeroDevPaymasterAndData } from "../middleware/paymaster.js";
 
 export class ZeroDevEthersProvider<
   V extends SupportedValidators
 > extends JsonRpcProvider {
-  readonly accountProvider: SmartAccountProvider<HttpTransport>;
+  readonly accountProvider: ValidatorProviderTypeMap[V];
   constructor(validatorType: V, params: ValidatorProviderParamsMap[V]) {
     super();
     let accountProvider = new ValidatorProviders[validatorType](params);
     if (params.usePaymaster === undefined || params.usePaymaster) {
+      let paymasterConfig = params.opts?.paymasterConfig ?? {
+        policy: "VERIFYING_PAYMASTER",
+      };
+      paymasterConfig = {
+        ...paymasterConfig,
+        paymasterProvider:
+          params.opts?.paymasterConfig?.paymasterProvider ??
+          params.bundlerProvider,
+      };
       accountProvider = withZeroDevPaymasterAndData(
         accountProvider,
-        params.opts?.paymasterConfig ?? { policy: "VERIFYING_PAYMASTER" }
-      ) as typeof accountProvider;
+        paymasterConfig
+      ) as ValidatorProviderTypeMap[V];
     }
     this.accountProvider = accountProvider;
   }
@@ -57,6 +67,10 @@ export class ZeroDevEthersProvider<
     return instance;
   }
 
+  getAccountProvider(): ValidatorProviderTypeMap[V] {
+    return this.accountProvider;
+  }
+
   /**
    * Rewrites the send method to use the account provider's EIP-1193
    * compliant request method
@@ -78,7 +92,11 @@ export class ZeroDevEthersProvider<
   connectToAccount(
     fn: (rpcClient: PublicErc4337Client) => BaseSmartContractAccount
   ): ZeroDevAccountSigner<V> {
-    defineReadOnly(this, "accountProvider", this.accountProvider.connect(fn));
+    defineReadOnly(
+      this,
+      "accountProvider",
+      this.accountProvider.connect(fn) as ValidatorProviderTypeMap[V]
+    );
     return this.getAccountSigner();
   }
 

package/src/kernel-zerodev/middleware/paymaster.ts

@@ -25,7 +25,8 @@ export const zeroDevPaymasterAndDataMiddleware = <
 >["0"] => {
   return {
     dummyPaymasterDataMiddleware: async (struct) => {
-      struct.paymasterAndData = "0x";
+      struct.paymasterAndData =
+        "0xe93eca6595fe94091dc1af46aac2a8b5d79907700000000000000000000000000000000000000000000000000000000064ee5cd9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
       return struct;
     },
     paymasterDataMiddleware: async (struct) => {

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

@@ -16,7 +16,8 @@ export abstract class Paymaster {
   constructor(protected provider: ZeroDevProvider) {}
   abstract getPaymasterResponse(
     struct: UserOperationStruct,
-    paymasterProvider?: PaymasterAndBundlerProviders
+    paymasterProvider?: PaymasterAndBundlerProviders,
+    shouldOverrideFee?: boolean
   ): Promise<UserOperationStruct>;
   protected async signUserOp({
     userOp,
@@ -25,6 +26,7 @@ export abstract class Paymaster {
     erc20UserOp,
     erc20CallData,
     paymasterProvider,
+    shouldOverrideFee = false,
   }: {
     userOp: UserOperationStruct;
     callData?: PromiseOrValue<BytesLike>;
@@ -32,6 +34,7 @@ export abstract class Paymaster {
     erc20UserOp?: Partial<UserOperationStruct>;
     erc20CallData?: PromiseOrValue<BytesLike>;
     paymasterProvider?: PaymasterAndBundlerProviders;
+    shouldOverrideFee?: boolean;
   }): Promise<any> {
     try {
       const hexifiedUserOp = deepHexlify(await resolveProperties(userOp));
@@ -58,6 +61,7 @@ export abstract class Paymaster {
               ? await erc20CallData
               : erc20CallData,
           paymasterProvider,
+          shouldOverrideFee,
         }).filter(([_, value]) => value !== undefined)
       );
       const { data: paymasterResp } = await axios.post(

package/src/kernel-zerodev/paymaster/token-paymaster.ts

@@ -157,7 +157,8 @@ export class TokenPaymaster extends Paymaster {
 
   async getPaymasterResponse(
     struct: UserOperationStruct,
-    paymasterProvider?: PaymasterAndBundlerProviders
+    paymasterProvider?: PaymasterAndBundlerProviders,
+    shouldOverrideFee?: boolean
   ): Promise<UserOperationStruct> {
     try {
       const mainCall = await this.decodeMainCallFromCallData(
@@ -193,6 +194,7 @@ export class TokenPaymaster extends Paymaster {
           erc20UserOp,
           erc20CallData: erc20UserOp.callData,
           paymasterProvider,
+          shouldOverrideFee,
         });
         if (paymasterResp) {
           return {

package/src/kernel-zerodev/paymaster/verifying-paymaster.ts

@@ -16,13 +16,15 @@ export class VerifyingPaymaster extends Paymaster {
   }
   async getPaymasterResponse(
     struct: UserOperationStruct,
-    paymasterProvider?: PaymasterAndBundlerProviders
+    paymasterProvider?: PaymasterAndBundlerProviders,
+    shouldOverrideFee?: boolean
   ): Promise<UserOperationStruct> {
     try {
       const hexifiedUserOp = deepHexlify(await resolveProperties(struct));
       const paymasterResp = await this.signUserOp({
         userOp: hexifiedUserOp,
         paymasterProvider,
+        shouldOverrideFee,
       });
       if (paymasterResp) {
         return {

package/src/kernel-zerodev/provider.ts

@@ -56,8 +56,8 @@ export type ZeroDevProviderConfig = {
 };
 
 export enum Operation {
-  Call,
-  DelegateCall,
+  Call = 0,
+  DelegateCall = 1,
 }
 
 type UserOpDataOperationTypes<T> = T extends UserOperationCallData
@@ -183,24 +183,28 @@ export class ZeroDevProvider extends SmartAccountProvider<HttpTransport> {
     let hash: string = "";
     let i = 0;
     const nonce = await this.account.getNonce();
-    const uoStruct = await asyncPipe(
-      this.dummyPaymasterDataMiddleware,
-      this.feeDataGetter,
-      this.paymasterDataMiddleware,
-      this.gasEstimator,
-      this.customMiddleware ?? noOpMiddleware,
-      async (struct) => ({ ...struct, ...overrides })
-    )({
-      initCode,
-      sender: this.getAddress(),
-      nonce,
-      callData,
-      signature: await this.account
-        .getValidator()
-        .getDynamicDummySignature(await this.getAddress(), callData as Hex),
-    } as UserOperationStruct);
+    let uoStruct: UserOperationStruct;
     let request: UserOperationStruct;
+    let maxFeePerGas, maxPriorityFeePerGas;
     do {
+      uoStruct = await asyncPipe(
+        this.dummyPaymasterDataMiddleware,
+        this.feeDataGetter,
+        this.paymasterDataMiddleware,
+        this.gasEstimator,
+        this.customMiddleware ?? noOpMiddleware,
+        async (struct) => ({ ...struct, ...overrides })
+      )({
+        initCode,
+        sender: this.getAddress(),
+        nonce,
+        callData,
+        signature: await this.account
+          .getValidator()
+          .getDynamicDummySignature(await this.getAddress(), callData as Hex),
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+      } as UserOperationStruct);
       request = deepHexlify(await resolveProperties(uoStruct));
 
       if (!isValidRequest(request)) {
@@ -214,6 +218,8 @@ export class ZeroDevProvider extends SmartAccountProvider<HttpTransport> {
         );
       }
 
+      this.account.approvePlugin();
+
       request.signature = await this.account.validator.getSignature(request);
       try {
         hash = await this.rpcClient.sendUserOperation(
@@ -222,16 +228,14 @@ export class ZeroDevProvider extends SmartAccountProvider<HttpTransport> {
         );
       } catch (error: any) {
         if (this.isReplacementOpError(error) && i++ < this.sendTxMaxRetries) {
-          uoStruct.maxFeePerGas = (BigInt(request.maxFeePerGas) * 113n) / 100n;
-          uoStruct.maxPriorityFeePerGas =
+          maxFeePerGas = (BigInt(request.maxFeePerGas) * 113n) / 100n;
+          maxPriorityFeePerGas =
             (BigInt(request.maxPriorityFeePerGas) * 113n) / 100n;
 
           console.log(
             `After ${
               this.sendTxRetryIntervalMs / 60000
-            } minutes, resending tx with Increased Gas fees: maxFeePerGas: ${
-              uoStruct.maxFeePerGas
-            }, maxPriorityFeePerGas: ${uoStruct.maxPriorityFeePerGas}`
+            } minutes, resending tx with Increased Gas fees: maxFeePerGas: ${maxFeePerGas}, maxPriorityFeePerGas: ${maxPriorityFeePerGas}`
           );
           await new Promise((resolve) =>
             setTimeout(resolve, this.sendTxRetryIntervalMs)

package/src/kernel-zerodev/signer/empty-account.ts

@@ -0,0 +1,27 @@
+import type { SignTypedDataParams, SmartAccountSigner } from "@alchemy/aa-core";
+import { type Hex } from "viem";
+
+export class EmptyAccountSigner implements SmartAccountSigner {
+  private owner: Hex;
+  constructor(owner: Hex) {
+    this.owner = owner;
+  }
+
+  readonly signMessage: (msg: string | Uint8Array) => Promise<`0x${string}`> = (
+    _msg
+  ) => {
+    throw Error("EmptyAccountSigner: method not implemented");
+  };
+
+  readonly signTypedData = (_params: SignTypedDataParams) => {
+    throw Error("EmptyAccountSigner: method not implemented");
+  };
+
+  readonly getAddress: () => Promise<`0x${string}`> = async () => {
+    return this.owner;
+  };
+
+  static addressToAccountSigner(ownerAddress: Hex): EmptyAccountSigner {
+    return new EmptyAccountSigner(ownerAddress);
+  }
+}

package/src/kernel-zerodev/utils.ts

@@ -46,6 +46,16 @@ export const encodeMultiSend = (
   return ("0x" + _txs.map((tx) => encodeCall(tx)).join("")) as Hex;
 };
 
+export function base64ToBytes(base64: string) {
+  const binString = atob(base64);
+  return Uint8Array.from(binString, (m) => m.codePointAt(0) as number);
+}
+
+export function bytesToBase64(bytes: Uint8Array) {
+  const binString = Array.from(bytes, (x) => String.fromCodePoint(x)).join("");
+  return btoa(binString);
+}
+
 export function getGasTokenAddress(
   gasToken: SupportedGasToken,
   chainId: number

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

@@ -43,11 +43,18 @@ export interface KernelBaseValidatorParams {
   validUntil?: number;
   validAfter?: number;
   executor?: Address;
-  selector?: string;
+  selector?: Hex;
   rpcUrl?: string;
   bundlerProvider?: PaymasterAndBundlerProviders;
 }
 
+export type ValidatorPluginData = Required<
+  Pick<
+    KernelBaseValidatorParams,
+    "executor" | "selector" | "validAfter" | "validUntil"
+  >
+>;
+
 //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 {
@@ -60,7 +67,7 @@ export abstract class KernelBaseValidator {
   protected validUntil: number;
   protected validAfter: number;
   protected executor?: Address;
-  protected selector?: string;
+  protected selector?: Hex;
   protected rpcUrl?: string;
   protected bundlerProvider?: PaymasterAndBundlerProviders;
   publicClient?: PublicClient<Transport, Chain>;
@@ -98,13 +105,29 @@ export abstract class KernelBaseValidator {
 
   abstract signer(): Promise<SmartAccountSigner>;
 
-  abstract getDummyUserOpSignature(): Promise<Hex>;
+  abstract getDummyUserOpSignature(callData?: Hex): Promise<Hex>;
 
   abstract isPluginEnabled(
     kernelAccountAddress: Address,
     selector: Hex
   ): Promise<boolean>;
 
+  shouldDelegateViaFallback(): boolean {
+    return true;
+  }
+
+  getPluginValidatorData(): ValidatorPluginData {
+    if (!this.selector || !this.executor) {
+      throw Error("Plugin Validator data params uninitialised");
+    }
+    return {
+      selector: this.selector,
+      executor: this.executor,
+      validAfter: this.validAfter,
+      validUntil: this.validUntil,
+    };
+  }
+
   async getDynamicDummySignature(
     kernelAccountAddress: Address,
     calldata: Hex
@@ -122,7 +145,7 @@ export abstract class KernelBaseValidator {
       const staticDummySig = concatHex([
         "0x000000000000000000000000",
         this.getAddress(),
-        "0x53dd285022D1512635823952d109dB39467a457E",
+        this.executor!,
       ]);
 
       return concatHex([
@@ -132,10 +155,13 @@ export abstract class KernelBaseValidator {
         enableData,
         pad(toHex(enableSigLength), { size: 32 }),
         dummyECDSASig,
-        await this.getDummyUserOpSignature(),
+        await this.getDummyUserOpSignature(calldata),
       ]);
     }
-    return concatHex([validatorMode, await this.getDummyUserOpSignature()]);
+    return concatHex([
+      validatorMode,
+      await this.getDummyUserOpSignature(calldata),
+    ]);
   }
 
   setEnableSignature(enableSignature: Hex) {

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

@@ -4,13 +4,19 @@ import {
   type Hex,
   type SmartAccountSigner,
   type UserOperationRequest,
+  getChain,
   type SignTypedDataParams,
 } from "@alchemy/aa-core";
-import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
+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 } from "../utils.js";
 
 export interface ERC165SessionKeyValidatorParams
@@ -35,6 +41,19 @@ export class ERC165SessionKeyValidator extends KernelBaseValidator {
     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> {

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

@@ -1,12 +1,19 @@
 import { ECDSAValidator } from "./ecdsa-validator.js";
 import { ERC165SessionKeyValidator } from "./erc165-session-key-validator.js";
 import { KillSwitchValidator } from "./kill-switch-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,
 };
 
-export { ECDSAValidator, KillSwitchValidator, ERC165SessionKeyValidator };
+export {
+  ECDSAValidator,
+  KillSwitchValidator,
+  ERC165SessionKeyValidator,
+  SessionKeyValidator,
+};