@zerodev/sdk 4.0.2-alpha.23

package/src/kernel-zerodev/utils.ts

@@ -0,0 +1,166 @@
+import {
+  encodePacked,
+  fromBytes,
+  toBytes,
+  type Hex,
+  type WalletClient,
+  toHex,
+} from "viem";
+import type {
+  SmartAccountSigner,
+  UserOperationCallData,
+} from "@alchemy/aa-core";
+import { Signer } from "@ethersproject/abstract-signer";
+import { Web3Provider, type ExternalProvider } from "@ethersproject/providers";
+import { API_URL, gasTokenChainAddresses } from "./constants.js";
+import type { SupportedGasToken } from "./paymaster/types.js";
+import axios from "axios";
+
+export type UserOperationCallDataWithDelegate = UserOperationCallData & {
+  delegateCall?: boolean;
+};
+
+export type BatchUserOperationCallDataWithDelegate =
+  UserOperationCallDataWithDelegate[];
+
+const encodeCall = (_tx: UserOperationCallDataWithDelegate): string => {
+  const data = toBytes(_tx.data);
+  const encoded = encodePacked(
+    ["uint8", "address", "uint256", "uint256", "bytes"],
+    [
+      _tx.delegateCall ? 1 : 0,
+      _tx.target,
+      _tx.value || BigInt(0),
+      BigInt(data.length),
+      fromBytes(data, "hex"),
+    ]
+  );
+  return encoded.slice(2);
+};
+export const encodeMultiSend = (
+  _txs: BatchUserOperationCallDataWithDelegate
+): Hex => {
+  return ("0x" + _txs.map((tx) => encodeCall(tx)).join("")) as Hex;
+};
+
+export function getGasTokenAddress(
+  gasToken: SupportedGasToken,
+  chainId: number
+): Hex | undefined {
+  if (gasToken === "TEST_ERC20") {
+    return "0x3870419Ba2BBf0127060bCB37f69A1b1C090992B";
+  }
+  return gasTokenChainAddresses[gasToken][chainId] || undefined;
+}
+
+export const convertWalletClientToAccountSigner = (
+  client: WalletClient
+): SmartAccountSigner => {
+  return {
+    getAddress: async () =>
+      Promise.resolve((await client.getAddresses())[0] as `0x${string}`),
+    signMessage: async (message: Uint8Array | string) =>
+      (await client.signMessage({
+        account: client.account!,
+        message:
+          typeof message === "string"
+            ? message
+            : {
+                raw: message,
+              },
+      })) as `0x${string}`,
+  };
+};
+
+export const convertEthersSignerToAccountSigner = (
+  signer: Signer
+): SmartAccountSigner => {
+  return {
+    getAddress: async () =>
+      Promise.resolve((await signer.getAddress()) as `0x${string}`),
+    signMessage: async (msg: Uint8Array | string) =>
+      (await signer.signMessage(msg)) as `0x${string}`,
+  };
+};
+
+export function getRPCProviderOwner(web3Provider: any): SmartAccountSigner {
+  const provider = new Web3Provider(web3Provider as ExternalProvider);
+  const signer = provider.getSigner();
+
+  return {
+    getAddress: async () =>
+      Promise.resolve((await signer.getAddress()) as `0x${string}`),
+    signMessage: async (msg: Uint8Array | string) =>
+      (await signer.signMessage(msg)) as `0x${string}`,
+  };
+}
+
+export async function getCustodialOwner(
+  identifier: string,
+  {
+    custodialFilePath,
+    privateKey,
+    publicKey,
+    keyId,
+    apiUrl = API_URL,
+  }: {
+    privateKey?: string;
+    publicKey?: string;
+    keyId?: string;
+    custodialFilePath?: string;
+    apiUrl?: string;
+  }
+): Promise<SmartAccountSigner | undefined> {
+  if (custodialFilePath) {
+    let fsModule;
+    try {
+      fsModule = require.resolve("fs") && require("fs");
+    } catch (error) {
+      console.log("FS module not available. Skipping FS operation...");
+      return;
+    }
+    const data = fsModule.readFileSync(custodialFilePath, "utf8");
+    const values = data.split("\n");
+    [privateKey, publicKey, keyId] = values;
+  }
+  let TurnkeySigner;
+  try {
+    TurnkeySigner =
+      require.resolve("@turnkey/ethers") &&
+      require("@turnkey/ethers").TurnkeySigner;
+  } catch (error) {
+    console.log(
+      "@turnkey/ethers module not available. Skipping FS operation..."
+    );
+    return;
+  }
+  if (!privateKey || !publicKey || !keyId) {
+    throw new Error(
+      "Must provide custodialFilePath or privateKey, publicKey, and keyId."
+    );
+  }
+
+  const response = await axios.post(`${apiUrl}/wallets/${identifier}`, {
+    keyId,
+  });
+
+  const turnkeySigner = new TurnkeySigner({
+    apiPublicKey: publicKey,
+    apiPrivateKey: privateKey,
+    baseUrl: "https://coordinator-beta.turnkey.io",
+    organizationId: keyId,
+    privateKeyId: response.data.walletId,
+  });
+  return {
+    getAddress: async () => (await turnkeySigner.getAddress()) as `0x${string}`,
+    signMessage: async (msg: Uint8Array | string) =>
+      (await turnkeySigner.signMessage(msg)) as `0x${string}`,
+  };
+}
+
+export const randomHexString = (length: number): Hex =>
+  toHex(
+    Array.from({ length }, () =>
+      Math.floor(Math.random() * 16).toString(16)
+    ).join("")
+  );

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

@@ -0,0 +1,273 @@
+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,
+  ECDSA_VALIDATOR_ADDRESS,
+  ENTRYPOINT_ADDRESS,
+} from "../constants.js";
+import type { PaymasterAndBundlerProviders } from "../paymaster/types.js";
+
+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;
+  protected publicClient?: PublicClient<Transport, Chain, true>;
+
+  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(this.rpcUrl, {
+        fetchOptions: {
+          headers:
+            this.rpcUrl === BUNDLER_URL
+              ? {
+                  projectId: this.projectId,
+                  bundlerProvider: this.bundlerProvider,
+                }
+              : {},
+        },
+      }),
+      chain: this.chain,
+    });
+  }
+
+  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 };