@zerodev/sdk 4.0.2-alpha.23

package/src/kernel-zerodev/account.ts

@@ -0,0 +1,308 @@
+import type { Address } from "abitype";
+import {
+  concatHex,
+  encodeAbiParameters,
+  encodeFunctionData,
+  type FallbackTransport,
+  hashMessage,
+  type Hex,
+  toBytes,
+  type Transport,
+  pad,
+  toHex,
+  getContract,
+  type PublicClient,
+} from "viem";
+import { parseAbiParameters } from "abitype";
+import { KernelBaseValidator, ValidatorMode } 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,
+  getChain,
+} from "@alchemy/aa-core";
+import {
+  BUNDLER_URL,
+  ENTRYPOINT_ADDRESS,
+  KERNEL_FACTORY_ADDRESS,
+  KERNEL_IMPL_ADDRESS,
+  MULTISEND_ADDR,
+} from "./constants.js";
+import { encodeMultiSend } from "./utils.js";
+import { MultiSendAbi } from "./abis/MultiSendAbi.js";
+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 interface KernelSmartAccountParams<
+  TTransport extends Transport | FallbackTransport = Transport
+> extends Partial<BaseSmartAccountParams<TTransport>> {
+  projectId: string;
+  owner: SmartAccountSigner;
+  factoryAddress?: Address;
+  index?: bigint;
+  validator?: KernelBaseValidator;
+  bundlerProvider?: PaymasterAndBundlerProviders;
+}
+
+export function isKernelAccount(
+  account: any
+): account is KernelSmartContractAccount {
+  return account && account.connectValidator !== undefined;
+}
+
+export class KernelSmartContractAccount<
+  TTransport extends Transport | FallbackTransport = Transport
+> extends BaseSmartContractAccount<TTransport> {
+  private owner: SmartAccountSigner;
+  private readonly factoryAddress: Address;
+  private readonly index: bigint;
+  validator?: KernelBaseValidator;
+
+  constructor(params: KernelSmartAccountParams) {
+    super({
+      ...params,
+      entryPointAddress: params.entryPointAddress ?? ENTRYPOINT_ADDRESS,
+      chain: params.chain ?? polygonMumbai,
+      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;
+  }
+
+  public static async init(
+    params: KernelSmartAccountParams
+  ): Promise<KernelSmartContractAccount> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const rpcClient =
+      typeof params.rpcClient === "string"
+        ? createZeroDevPublicErc4337Client({
+            chain,
+            rpcUrl: params.rpcClient ?? BUNDLER_URL,
+            projectId: params.projectId,
+            bundlerProvider: params.bundlerProvider,
+          })
+        : params.rpcClient;
+    const instance = new KernelSmartContractAccount({
+      ...params,
+      chain,
+      rpcClient,
+    });
+    return instance;
+  }
+
+  async getAddress(): Promise<Address> {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+    if (!this.accountAddress) {
+      try {
+        const initializeData = encodeFunctionData({
+          abi: KernelAccountAbi,
+          functionName: "initialize",
+          args: [
+            this.validator.getAddress(),
+            await this.validator.getEnableData(),
+          ],
+        });
+        const kernelFactory = getContract({
+          abi: KernelFactoryAbi,
+          address: KERNEL_FACTORY_ADDRESS,
+          publicClient: this.rpcProvider as PublicClient,
+        });
+        return await kernelFactory.read.getAccountAddress([
+          initializeData,
+          this.index,
+        ]);
+      } catch (error) {
+        throw new Error(`getCounterFactualAddress failed: ${error}`);
+      }
+    }
+
+    return this.accountAddress;
+  }
+
+  connectValidator(validator: KernelBaseValidator): this {
+    defineReadOnly(this, "validator", validator);
+    return this;
+  }
+
+  getValidator(): KernelBaseValidator {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+    return this.validator;
+  }
+
+  getDummySignature(): Hex {
+    return "0x00000000870fe151d548a1c527c3804866fab30abf28ed17b79d5fc5149f19ca0819fefc3c57f3da4fdf9b10fab3f2f3dca536467ae44943b9dbb8433efe7760ddd72aaa1c";
+  }
+
+  async getDynamicDummySignature(
+    kernelAccountAddress: Address,
+    calldata: Hex
+  ): Promise<Hex> {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+
+    const dummyECDSASig =
+      "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+    const validatorMode = await this.validator.resolveValidatorMode(
+      kernelAccountAddress,
+      calldata
+    );
+    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,
+      ]);
+    }
+    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()) {
+      return data;
+    } else {
+      return this.encodeExecuteAction(target, value, data, 0);
+    }
+  }
+
+  async encodeBatchExecute(
+    _txs: BatchUserOperationCallData
+  ): Promise<`0x${string}`> {
+    const multiSendCalldata = encodeFunctionData({
+      abi: MultiSendAbi,
+      functionName: "multiSend",
+      args: [encodeMultiSend(_txs)],
+    });
+    return await this.encodeExecuteDelegate(
+      MULTISEND_ADDR,
+      BigInt(0),
+      multiSendCalldata
+    );
+  }
+
+  async encodeExecuteDelegate(
+    target: Hex,
+    value: bigint,
+    data: Hex
+  ): Promise<Hex> {
+    return this.encodeExecuteAction(target, value, data, 1);
+  }
+
+  async signWithEip6492(msg: string | Uint8Array): Promise<Hex> {
+    try {
+      const formattedMessage = typeof msg === "string" ? toBytes(msg) : msg;
+      let sig = await this.owner.signMessage(
+        toBytes(hashMessage({ raw: formattedMessage }))
+      );
+      // If the account is undeployed, use ERC-6492
+      if (!(await this.isAccountDeployed())) {
+        sig = (encodeAbiParameters(
+          parseAbiParameters("address, bytes, bytes"),
+          [this.factoryAddress, await this.getFactoryInitCode(), sig]
+        ) +
+          "6492649264926492649264926492649264926492649264926492649264926492") as Hex; // magic suffix
+      }
+
+      return sig;
+    } catch (err: any) {
+      console.error("Got Error - ", err.message);
+      throw new Error("Message Signing with EIP6492 failed");
+    }
+  }
+
+  async signMessage(msg: Uint8Array | string): Promise<Hex> {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+    const formattedMessage = typeof msg === "string" ? toBytes(msg) : msg;
+    return await this.validator.signMessage(formattedMessage);
+  }
+
+  signUserOp(userOp: UserOperationRequest): Promise<Hex> {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+    return this.validator.signUserOp(userOp);
+  }
+
+  protected encodeExecuteAction(
+    target: Hex,
+    value: bigint,
+    data: Hex,
+    code: number
+  ): Hex {
+    return encodeFunctionData({
+      abi: KernelAccountAbi,
+      functionName: "execute",
+      args: [target, value, data, code],
+    });
+  }
+  protected async getAccountInitCode(): Promise<Hex> {
+    return concatHex([this.factoryAddress, await this.getFactoryInitCode()]);
+  }
+
+  protected async getFactoryInitCode(): Promise<Hex> {
+    if (!this.validator) {
+      throw new Error("Validator not connected");
+    }
+    try {
+      return encodeFunctionData({
+        abi: KernelFactoryAbi,
+        functionName: "createAccount",
+        args: [
+          KERNEL_IMPL_ADDRESS,
+          encodeFunctionData({
+            abi: KernelAccountAbi,
+            functionName: "initialize",
+            args: [
+              this.validator.getAddress(),
+              await this.validator.getEnableData(),
+            ],
+          }),
+          this.index,
+        ],
+      });
+    } catch (err: any) {
+      console.error("err occurred:", err.message);
+      throw new Error("Factory Code generation failed");
+    }
+  }
+}

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

@@ -0,0 +1,25 @@
+import axios from "axios";
+import { BACKEND_URL } from "../constants.js";
+
+export const getChainId = async (
+  projectId: string,
+  backendUrl?: string
+): Promise<number | undefined> => {
+  try {
+    const {
+      data: { chainId },
+    } = await axios.post(
+      `${backendUrl ?? BACKEND_URL}/v1/projects/get-chain-id`,
+      {
+        projectId,
+      },
+      {
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+    return chainId;
+  } catch (error) {
+    console.log(error);
+    return undefined;
+  }
+};

package/src/kernel-zerodev/client/create-client.ts

@@ -0,0 +1,37 @@
+import {
+  createPublicErc4337FromClient,
+  type HttpTransport,
+  type PublicErc4337Client,
+} from "@alchemy/aa-core";
+import { http, createPublicClient, type Chain } from "viem";
+import { BUNDLER_URL } from "../constants.js";
+import type { PaymasterAndBundlerProviders } from "../paymaster/types.js";
+
+interface ZeroDevClientConfig {
+  chain: Chain;
+  projectId: string;
+  rpcUrl?: string;
+  bundlerProvider?: PaymasterAndBundlerProviders;
+}
+
+export const createZeroDevPublicErc4337Client = ({
+  chain,
+  rpcUrl,
+  projectId,
+  bundlerProvider,
+}: ZeroDevClientConfig): PublicErc4337Client<HttpTransport> => {
+  let client = createPublicErc4337FromClient(
+    createPublicClient({
+      chain,
+      transport: http(rpcUrl, {
+        fetchOptions: {
+          headers: rpcUrl === BUNDLER_URL ? { projectId, bundlerProvider } : {},
+        },
+        name: "Connected bundler network",
+        key: "connected-bundler-network",
+      }),
+    })
+  );
+
+  return client;
+};

package/src/kernel-zerodev/constants.ts

@@ -0,0 +1,71 @@
+import { parseUnits, type Hex } from "viem";
+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 BUNDLER_URL = "https://v0-6-meta-bundler.onrender.com";
+export const PAYMASTER_URL = "https://v0-6-paymaster.onrender.com";
+export const ENTRYPOINT_ADDRESS: Hex =
+  "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
+export const MULTISEND_ADDR: Hex = "0x8ae01fcf7c655655ff2c6ef907b8b4718ab4e17c";
+export const BACKEND_URL = "https://backend-vikp.onrender.com";
+export const API_URL = "https://prod-api.zerodev.app";
+export const ECDSA_VALIDATOR_ADDRESS =
+  "0xd9AB5096a832b9ce79914329DAEE236f8Eea0390";
+export const KERNEL_FACTORY_ADDRESS =
+  "0x85DF6Dc686FBDcAc7da61651D116fc71B2246B50";
+export const KERNEL_IMPL_ADDRESS = "0xD2063bE7C610eb55492C05385743edDbf5b6B951";
+export const KILL_SWITCH_VALIDATOR_ADDRESS =
+  "0x2db0DbfDf90Dbe2859158Aa71db1FcDCb3E579c8";
+export const KILL_SWITCH_ACTION = "0xf5aa34DD2cba311947e143183ED325A4A8C674Af";
+export const DUMMY_ECDSA_SIG =
+  "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+export const ERC165_SESSION_KEY_VALIDATOR_ADDRESS =
+  "0xe149290800De29D4b0BF9dB82c508255D81902E6";
+export const TOKEN_ACTION = "0x2087C7FfD0d0DAE80a00EE74325aBF3449e0eaf1";
+
+export const gasTokenChainAddresses: IGasTokenAddresses = {
+  USDC: {
+    1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    // 5: "0x2f3A40A3db8a7e3D09B0adfEfbCe4f6F81927557",
+    137: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    // 80001: "",
+    // 420: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
+    42161: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+    // 421613: "",
+    43114: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    // 43113: "",
+    // 56: "",
+    // 97: ""
+  },
+  PEPE: {
+    1: "0x6982508145454Ce325dDbE47a25d4ec3d2311933",
+  },
+};
+
+export const ERC20_APPROVAL_AMOUNT: { [key: string]: bigint } = {
+  // ETH
+  [gasTokenChainAddresses["USDC"][1]]: parseUnits("100", 6),
+
+  // Goerli
+  [gasTokenChainAddresses["USDC"][5]]: parseUnits("100", 6),
+
+  // Polygon
+  [gasTokenChainAddresses["USDC"][137]]: parseUnits("10", 6),
+
+  // Arbitrum
+  [gasTokenChainAddresses["USDC"][42161]]: parseUnits("10", 6),
+
+  // Avalanche
+  [gasTokenChainAddresses["USDC"][43114]]: parseUnits("10", 6),
+
+  // ETH
+  [gasTokenChainAddresses["PEPE"][1]]: parseUnits("50000000", 18),
+
+  "0x3870419Ba2BBf0127060bCB37f69A1b1C090992B": parseUnits("100", 18),
+};
+
+export const minPriorityFeePerBidDefaults = new Map<number, bigint>([
+  [polygon.id, 30_000_000_000n],
+]);

package/src/kernel-zerodev/errors.ts

@@ -0,0 +1,13 @@
+const ErrTransactionFailedGasChecks = Error("Transaction failed gas checks");
+const InvalidOperation = Error("Invalid operation");
+const IncorrectCallDataForTokenPaymaster = Error(
+  "Incorrect callData for token paymaster"
+);
+const AccountNotConnected = Error("Account not connected");
+
+export {
+  ErrTransactionFailedGasChecks,
+  InvalidOperation,
+  IncorrectCallDataForTokenPaymaster,
+  AccountNotConnected,
+};

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

@@ -0,0 +1,118 @@
+import { getChainId } from "../api/index.js";
+import {
+  SmartAccountProvider,
+  getChain,
+  type HttpTransport,
+  BaseSmartContractAccount,
+  defineReadOnly,
+  type AccountMiddlewareFn,
+  type FeeDataMiddleware,
+  type GasEstimatorMiddleware,
+  type PaymasterAndDataMiddleware,
+  type PublicErc4337Client,
+} from "@alchemy/aa-core";
+import { AccountSigner } from "@alchemy/aa-ethers";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import type { SupportedValidators } from "../validator/types.js";
+import type { ValidatorProviderParamsMap } 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>;
+  constructor(validatorType: V, params: ValidatorProviderParamsMap[V]) {
+    super();
+    let accountProvider = new ValidatorProviders[validatorType](params);
+    if (params.usePaymaster === undefined || params.usePaymaster) {
+      accountProvider = withZeroDevPaymasterAndData(
+        accountProvider,
+        params.opts?.paymasterConfig ?? { policy: "VERIFYING_PAYMASTER" }
+      ) as typeof accountProvider;
+    }
+    this.accountProvider = accountProvider;
+  }
+
+  public static async init<V extends SupportedValidators>(
+    validatorType: V,
+    params: ValidatorProviderParamsMap[V]
+  ): Promise<ZeroDevEthersProvider<V>> {
+    const chainId = await getChainId(params.projectId);
+    if (!chainId) {
+      throw new Error("ChainId not found");
+    }
+    const chain = getChain(chainId);
+    const instance = new ZeroDevEthersProvider(validatorType, {
+      ...params,
+      opts: {
+        ...params.opts,
+        providerConfig: {
+          chain,
+          ...params.opts?.providerConfig,
+        },
+      },
+    });
+
+    return instance;
+  }
+
+  /**
+   * Rewrites the send method to use the account provider's EIP-1193
+   * compliant request method
+   *
+   * @param method - the RPC method to call
+   * @param params - the params required by the RPC method
+   * @returns the result of the RPC call
+   */
+  send(method: string, params: any[]): Promise<any> {
+    return this.accountProvider.request({ method, params });
+  }
+
+  /**
+   * Connects the Provider to an Account and returns a Signer
+   *
+   * @param fn - a function that takes the account provider's rpcClient and returns a BaseSmartContractAccount
+   * @returns an {@link AccountSigner} that can be used to sign and send user operations
+   */
+  connectToAccount(
+    fn: (rpcClient: PublicErc4337Client) => BaseSmartContractAccount
+  ): AccountSigner {
+    defineReadOnly(this, "accountProvider", this.accountProvider.connect(fn));
+    return this.getAccountSigner();
+  }
+
+  /**
+   * @returns an {@link AccountSigner} using this as the underlying provider
+   */
+  getAccountSigner(): AccountSigner {
+    return new AccountSigner(this);
+  }
+
+  withPaymasterMiddleware = (overrides: {
+    dummyPaymasterDataMiddleware?: PaymasterAndDataMiddleware;
+    paymasterDataMiddleware?: PaymasterAndDataMiddleware;
+  }): this => {
+    this.accountProvider.withPaymasterMiddleware(overrides);
+    return this;
+  };
+
+  withGasEstimator = (override: GasEstimatorMiddleware): this => {
+    this.accountProvider.withGasEstimator(override);
+    return this;
+  };
+
+  withFeeDataGetter = (override: FeeDataMiddleware): this => {
+    this.accountProvider.withFeeDataGetter(override);
+    return this;
+  };
+
+  withCustomMiddleware = (override: AccountMiddlewareFn): this => {
+    this.accountProvider.withCustomMiddleware(override);
+    return this;
+  };
+
+  getPublicErc4337Client(): PublicErc4337Client {
+    return this.accountProvider.rpcClient;
+  }
+}