@zerodev/sdk 4.0.8 → 4.0.10

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

@@ -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/owner/passkey/createPasskeyOwner.ts

@@ -5,7 +5,6 @@ import {
   base64UrlEncode,
   es256,
   generateRandomBuffer,
-  getCredentials,
   publicKey,
   signMessage,
   signTypedData,
@@ -26,6 +25,7 @@ export async function createPasskeyOwner({
   //@ts-expect-error
   if (typeof window !== "undefined") {
     const challenge = generateRandomBuffer();
+    const authenticatorUserId = generateRandomBuffer();
     try {
       const attestation = await getWebAuthnAttestation({
         publicKey: {
@@ -39,7 +39,7 @@ export async function createPasskeyOwner({
             residentKey: "required", // or 'preferred', 'discouraged'
             userVerification: "required",
           },
-          excludeCredentials: await getCredentials(projectId),
+          // excludeCredentials: await getCredentials(projectId),
           extensions: { credProps: true },
           challenge,
           pubKeyCredParams: [
@@ -49,7 +49,7 @@ export async function createPasskeyOwner({
             },
           ],
           user: {
-            id: Uint8Array.from(name, (c) => c.charCodeAt(0)),
+            id: authenticatorUserId,
             name,
             displayName: name,
           },

package/src/kernel-zerodev/owner/passkey/getPasskeyOwner.ts

@@ -4,7 +4,6 @@ import type { SignTypedDataParams, SmartAccountSigner } from "@alchemy/aa-core";
 import {
   base64UrlEncode,
   generateRandomBuffer,
-  getCredentials,
   signMessage,
   signTypedData,
 } from "./utils.js";
@@ -27,7 +26,7 @@ export async function getPasskeyOwner({
             //@ts-expect-error
             rpId: window.location.hostname,
             userVerification: "required",
-            allowCredentials: await getCredentials(projectId),
+            // allowCredentials: await getCredentials(projectId),
           },
         })
       );

package/src/kernel-zerodev/owner/passkey/utils.ts

@@ -119,15 +119,6 @@ export const signTypedData = async (
   );
 };
 
-export const getCredentials = async (projectId: string, apiUrl = API_URL) => {
-  const response = await axios.get(`${apiUrl}/projects/${projectId}/wallets`);
-  const credentials = response.data;
-  return credentials.map((credential: string) => ({
-    id: base64URLStringToBuffer(credential),
-    type: "public-key",
-  }));
-};
-
 // https://github.com/MasterKale/SimpleWebAuthn/blob/master/packages/browser/src/helpers/base64URLStringToBuffer.ts#L8
 export function base64URLStringToBuffer(base64URLString: string): ArrayBuffer {
   // Convert from Base64URL to Base64

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
@@ -214,6 +214,8 @@ export class ZeroDevProvider extends SmartAccountProvider<HttpTransport> {
         );
       }
 
+      this.account.approvePlugin();
+
       request.signature = await this.account.validator.getSignature(request);
       try {
         hash = await this.rpcClient.sendUserOperation(

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

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

@@ -7,7 +7,11 @@ import {
   type UserOperationRequest,
   type SignTypedDataParams,
 } from "@alchemy/aa-core";
-import { KernelBaseValidator, type KernelBaseValidatorParams } from "./base.js";
+import {
+  KernelBaseValidator,
+  ValidatorMode,
+  type KernelBaseValidatorParams,
+} from "./base.js";
 import {
   concat,
   concatHex,
@@ -37,6 +41,7 @@ export class KillSwitchValidator extends KernelBaseValidator {
     super(params);
     this.guardian = params.guardian;
     this.delaySeconds = params.delaySeconds;
+    this.mode = params.mode ?? ValidatorMode.plugin;
   }
 
   public static async init(