@zerodev/sdk 4.7.4 → 5.0.0-alpha-0

package/src/kernel-zerodev/utils/calc-pre-verification-gas.ts

@@ -1,88 +0,0 @@
-import type { UserOperationStruct } from "@alchemy/aa-core";
-import { toBytes, toHex } from "viem";
-import { packUserOp } from "./ERC4337-utils.js";
-
-export interface GasOverheads {
-  /**
-   * fixed overhead for entire handleOp bundle.
-   */
-  fixed: number;
-
-  /**
-   * per userOp overhead, added on top of the above fixed per-bundle.
-   */
-  perUserOp: number;
-
-  /**
-   * overhead for userOp word (32 bytes) block
-   */
-  perUserOpWord: number;
-
-  // perCallDataWord: number
-
-  /**
-   * zero byte cost, for calldata gas cost calculations
-   */
-  zeroByte: number;
-
-  /**
-   * non-zero byte cost, for calldata gas cost calculations
-   */
-  nonZeroByte: number;
-
-  /**
-   * expected bundle size, to split per-bundle overhead between all ops.
-   */
-  bundleSize: number;
-
-  /**
-   * expected length of the userOp signature.
-   */
-  sigSize: number;
-}
-
-export const DefaultGasOverheads: GasOverheads = {
-  fixed: 21000,
-  perUserOp: 18300,
-  perUserOpWord: 4,
-  zeroByte: 4,
-  nonZeroByte: 16,
-  bundleSize: 1,
-  sigSize: 65,
-};
-
-export type NotPromise<T> = {
-  [P in keyof T]: Exclude<T[P], Promise<any>>;
-};
-
-/**
- * calculate the preVerificationGas of the given UserOperation
- * preVerificationGas (by definition) is the cost overhead that can't be calculated on-chain.
- * it is based on parameters that are defined by the Ethereum protocol for external transactions.
- * @param userOp filled userOp to calculate. The only possible missing fields can be the signature and preVerificationGas itself
- * @param overheads gas overheads to use, to override the default values
- */
-export function calcPreVerificationGas(
-  userOp: Partial<NotPromise<UserOperationStruct>>,
-  overheads?: Partial<GasOverheads>
-): number {
-  const ov = { ...DefaultGasOverheads, ...(overheads ?? {}) };
-  const p: NotPromise<UserOperationStruct> = {
-    // dummy values, in case the UserOp is incomplete.
-    preVerificationGas: 21000, // dummy value, just for calldata cost
-    signature: toHex(Buffer.alloc(ov.sigSize, 1)), // dummy signature
-    ...userOp,
-  } as any;
-
-  const packed = toBytes(packUserOp(p, false));
-  const callDataCost = packed
-    .map((x) => (x === 0 ? ov.zeroByte : ov.nonZeroByte))
-    .reduce((sum, x) => sum + x);
-  const ret = Math.round(
-    callDataCost +
-      ov.fixed / ov.bundleSize +
-      ov.perUserOp +
-      ov.perUserOpWord * packed.length
-  );
-  return ret;
-}

package/src/kernel-zerodev/utils/custom-chains.ts

@@ -1,83 +0,0 @@
-import { defineChain } from "viem";
-
-export const gelatoOPTestnet = defineChain({
-  id: 42069,
-  name: "Gelato OPTestnet",
-  network: "gelatoOPTestnet",
-  nativeCurrency: {
-    decimals: 18,
-    name: "Ether",
-    symbol: "ETH",
-  },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.op-testnet.gelato.digital"],
-      webSocket: [],
-    },
-    public: {
-      http: ["https://rpc.op-testnet.gelato.digital"],
-      webSocket: [],
-    },
-  },
-  blockExplorers: {
-    default: {
-      name: "Explorer",
-      url: "https://blockscout.op-testnet.gelato.digital",
-    },
-  },
-});
-
-export const astarZKatana = defineChain({
-  id: 1261120,
-  name: "Astar zKatana",
-  network: "astarZKatana",
-  nativeCurrency: {
-    decimals: 18,
-    name: "Ether",
-    symbol: "ETH",
-  },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.zkatana.gelato.digital"],
-      webSocket: ["https://ws.zkatana.gelato.digital"],
-    },
-    public: {
-      http: ["https://rpc.zkatana.gelato.digital"],
-      webSocket: ["https://ws.zkatana.gelato.digital"],
-    },
-  },
-  blockExplorers: {
-    default: {
-      name: "Explorer",
-      url: "https://zkatana.blockscout.com",
-    },
-  },
-});
-
-export const astarZkEVM = defineChain({
-  id: 3_776,
-  name: 'Astar zkEVM',
-  network: 'AstarZkEVM',
-  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ['https://rpc.startale.com/astar-zkevm'],
-    },
-    public: {
-        http: ['https://rpc.startale.com/astar-zkevm'],
-    },
-  },
-  blockExplorers: {
-    default: {
-      name: 'Astar zkEVM Explorer',
-      url: 'https://astar-zkevm.explorer.startale.com',
-    },
-  },
-  contracts: {
-    multicall3: {
-      address: '0x36eabf148272BA81A5225C6a3637972F0EE17771',
-      blockCreated: 93528,
-    },
-  },
-  testnet: false,
-})

package/src/kernel-zerodev/utils.ts

@@ -1,159 +0,0 @@
-import {
-  encodePacked,
-  fromBytes,
-  toBytes,
-  type Hex,
-  type WalletClient,
-  toHex,
-  isHex,
-  hexToSignature,
-  signatureToHex,
-} from "viem";
-import * as chains from "viem/chains";
-import * as customChains from "./utils/custom-chains.js";
-import type {
-  SignTypedDataParams,
-  SmartAccountSigner,
-  UserOperationCallData,
-} from "@alchemy/aa-core";
-import { Signer, type TypedDataField } from "@ethersproject/abstract-signer";
-import { Wallet } from "@ethersproject/wallet";
-import type { SupportedGasToken } from "./paymaster/types.js";
-import { gasTokenChainAddresses } from "./constants.js";
-
-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 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
-): 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}`,
-    signTypedData: async (params: SignTypedDataParams) =>
-      fixSignedData(
-        await client.signTypedData({ ...params, account: client.account! })
-      ),
-  };
-};
-
-export const isWallet = (signer: any): signer is Wallet =>
-  signer && signer._signTypedData !== undefined;
-
-export const convertEthersSignerToAccountSigner = (
-  signer: Signer | Wallet
-): SmartAccountSigner => {
-  return {
-    getAddress: async () =>
-      Promise.resolve((await signer.getAddress()) as `0x${string}`),
-    signMessage: async (msg: Uint8Array | string) =>
-      (await signer.signMessage(msg)) as `0x${string}`,
-    signTypedData: async (params: SignTypedDataParams) => {
-      if (!isWallet(signer)) {
-        throw Error("signTypedData method not implemented in signer");
-      }
-      return fixSignedData(
-        (await signer._signTypedData(
-          params.domain!,
-          params.types as unknown as Record<string, TypedDataField[]>,
-          params.message
-        )) as Hex
-      );
-    },
-  };
-};
-
-export const randomHexString = (length: number): Hex =>
-  toHex(
-    Array.from({ length }, () =>
-      Math.floor(Math.random() * 16).toString(16)
-    ).join("")
-  );
-
-export const fixSignedData = (sig: Hex): Hex => {
-  let signature = sig;
-  if (!isHex(signature)) {
-    signature = `0x${signature}`;
-    if (!isHex(signature)) {
-      throw new Error("Invalid signed data " + sig);
-    }
-  }
-
-  let { r, s, v } = hexToSignature(signature);
-  if (v === 0n || v === 1n) v += 27n;
-  const joined = signatureToHex({ r, s, v });
-  return joined;
-};
-
-// Modified from @alchemy/aa-core
-/**
- * Utility method for converting a chainId to a {@link chains.Chain} object
- *
- * @param chainId
- * @returns a {@link chains.Chain} object for the given chainId
- * @throws if the chainId is not found
- */
-export const getChain = (chainId: number): chains.Chain => {
-  for (const chain of Object.values(chains).concat(
-    Object.values(customChains)
-  )) {
-    if (chain.id === chainId) {
-      return chain;
-    }
-  }
-  throw new Error("could not find chain");
-};

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

@@ -1,321 +0,0 @@
-import {
-  type SignTypedDataParams,
-  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,
-  zeroAddress,
-} from "viem";
-import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
-import {
-  CHAIN_ID_TO_NODE,
-  ECDSA_VALIDATOR_ADDRESS,
-  ENTRYPOINT_ADDRESS,
-  KERNEL_IMPL_ADDRESS,
-} from "../constants.js";
-import { polygonMumbai } from "viem/chains";
-
-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?: Hex;
-  rpcUrl?: string;
-}
-
-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 {
-  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?: Hex;
-  protected rpcUrl?: string;
-  publicClient?: PublicClient<Transport, Chain>;
-
-  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;
-    this.publicClient = createPublicClient({
-      transport: http(
-        params.rpcUrl ?? CHAIN_ID_TO_NODE[this.chain?.id ?? polygonMumbai.id]
-      ),
-      chain: this.chain ?? polygonMumbai,
-    });
-  }
-
-  abstract encodeEnable(enableData: Hex): Hex;
-
-  abstract encodeDisable(enableData: Hex): Hex;
-
-  abstract getEnableData(kernelAccountAddress?: Address): Promise<Hex>;
-
-  abstract signMessage(message: Uint8Array | string | Hex): Promise<Hex>;
-
-  abstract signTypedData(params: SignTypedDataParams): Promise<Hex>;
-
-  abstract signUserOp(userOp: UserOperationRequest): Promise<Hex>;
-
-  abstract signer(): Promise<SmartAccountSigner>;
-
-  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,
-    };
-  }
-
-  getNonceKey(): bigint {
-    return 0n;
-  }
-
-  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(kernelAccountAddress);
-      const enableDataLength = enableData.length / 2 - 1;
-      const enableSigLength = 65;
-      const staticDummySig = concatHex([
-        "0x000000000000000000000000",
-        this.getAddress(),
-        this.executor!,
-      ]);
-
-      return concatHex([
-        ValidatorMode.enable,
-        staticDummySig,
-        pad(toHex(enableDataLength), { size: 32 }),
-        enableData,
-        pad(toHex(enableSigLength), { size: 32 }),
-        dummyECDSASig,
-        await this.getDummyUserOpSignature(calldata),
-      ]);
-    }
-    return concatHex([
-      validatorMode,
-      await this.getDummyUserOpSignature(calldata),
-    ]);
-  }
-
-  setEnableSignature(enableSignature: Hex) {
-    this.enableSignature = enableSignature;
-  }
-
-  getEnableSignature(): Hex | undefined {
-    return this.enableSignature;
-  }
-
-  getAddress(): Hex {
-    return this.validatorAddress;
-  }
-
-  getPublicClient(): PublicClient<Transport, Chain> {
-    if (!this.publicClient) {
-      throw new Error("Validator uninitialized: PublicClient missing");
-    }
-    return this.publicClient;
-  }
-
-  async approveExecutor(
-    kernel: Address,
-    selector: Hex,
-    executor: Address,
-    validUntil: number,
-    validAfter: number,
-    validator: KernelBaseValidator
-  ): Promise<Hex> {
-    if (!this.chain) {
-      throw new Error("Validator uninitialized");
-    }
-    let kernelImplAddr;
-    try {
-      const strgAddr = await this.getPublicClient().getStorageAt({
-        address: kernel,
-        slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
-      });
-      kernelImplAddr = strgAddr
-        ? (("0x" + strgAddr.slice(26)) as Hex)
-        : strgAddr;
-    } catch (error) {}
-    const sender = kernel;
-    const signer = await this.signer();
-    const ownerSig = await signer.signTypedData({
-      domain: {
-        name: "Kernel",
-        version:
-          kernelImplAddr?.toLowerCase() === KERNEL_IMPL_ADDRESS.toLowerCase() ||
-          kernelImplAddr?.toLowerCase() ===
-            "0x8dD4DBB54d8A8Cf0DE6F9CCC4609470A30EfF18C".toLowerCase() ||
-          kernelImplAddr === undefined ||
-          kernelImplAddr === zeroAddress
-            ? "0.2.2"
-            : "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(kernel),
-      },
-      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(userOp.sender);
-      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
-      ]);
-    }
-  }
-}