@zerodev/sdk 4.7.4 → 5.0.0-alpha-0

package/src/kernel-zerodev/errors.ts

@@ -1,13 +0,0 @@
-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/account-signer.ts

@@ -1,185 +0,0 @@
-import {
-  resolveProperties,
-  type AccountMiddlewareFn,
-  type FeeDataMiddleware,
-  type GasEstimatorMiddleware,
-  type PaymasterAndDataMiddleware,
-  type PublicErc4337Client,
-  type SignTypedDataParams,
-} from "@alchemy/aa-core";
-import {
-  Signer,
-  type TypedDataSigner,
-  type TypedDataDomain,
-  type TypedDataField,
-} from "@ethersproject/abstract-signer";
-import { hexlify } from "@ethersproject/bytes";
-import { _TypedDataEncoder } from "@ethersproject/hash";
-import type { Deferrable } from "@ethersproject/properties";
-import {
-  type TransactionRequest,
-  type TransactionResponse,
-} from "@ethersproject/providers";
-import { ZeroDevEthersProvider } from "./ethers-provider.js";
-import type { SupportedValidators } from "../validator/types.js";
-import type { KernelSmartContractAccount } from "../account.js";
-import type { Hex } from "viem";
-
-const hexlifyOptional = (value: any): `0x${string}` | undefined => {
-  if (value == null) {
-    return undefined;
-  }
-
-  return hexlify(value) as `0x${string}`;
-};
-
-export class ZeroDevAccountSigner<V extends SupportedValidators>
-  extends Signer
-  implements TypedDataSigner
-{
-  private account?: KernelSmartContractAccount;
-
-  sendUserOperation;
-  waitForUserOperationTransaction;
-
-  constructor(readonly provider: ZeroDevEthersProvider<V>) {
-    super();
-    this.account = this.provider.accountProvider.getAccount();
-
-    this.sendUserOperation =
-      this.provider.accountProvider.sendUserOperation.bind(
-        this.provider.accountProvider
-      );
-    this.waitForUserOperationTransaction =
-      this.provider.accountProvider.waitForUserOperationTransaction.bind(
-        this.provider.accountProvider
-      );
-  }
-
-  getAddress(): Promise<Hex> {
-    if (!this.account) {
-      throw new Error(
-        "connect the signer to a provider that has a connected account"
-      );
-    }
-
-    return this.account.getAddress();
-  }
-
-  signMessage(message: string | Uint8Array): Promise<string> {
-    if (!this.account) {
-      throw new Error(
-        "connect the signer to a provider that has a connected account"
-      );
-    }
-
-    return this.account.signMessage(message);
-  }
-
-  signTypedData(params: SignTypedDataParams): Promise<string> {
-    if (!this.account) {
-      throw new Error(
-        "connect the signer to a provider that has a connected account"
-      );
-    }
-    if (params.types) {
-      delete params.types["EIP712Domain"];
-    }
-
-    return this.account.signTypedData(params);
-  }
-
-  _signTypedData(
-    domain: TypedDataDomain,
-    types: Record<string, Array<TypedDataField>>,
-    value: Record<string, any>
-  ): Promise<string> {
-    if (!this.account) {
-      throw new Error(
-        "connect the signer to a provider that has a connected account"
-      );
-    }
-    const params = _TypedDataEncoder.getPayload(
-      domain,
-      types,
-      value
-    ) as SignTypedDataParams;
-    if (params.types) {
-      delete params.types["EIP712Domain"];
-    }
-
-    return this.signTypedData(params);
-  }
-
-  async signMessageWith6492(_msg: string | Uint8Array): Promise<Hex> {
-    if (!this.account) {
-      throw new Error(
-        "connect the signer to a provider that has a connected account"
-      );
-    }
-    return this.account.signMessageWith6492(_msg);
-  }
-
-  async signTypedDataWith6492(params: SignTypedDataParams): Promise<Hex> {
-    if (!this.account) {
-      throw new Error(
-        "connect the signer to a provider that has a connected account"
-      );
-    }
-    return this.account.signTypedDataWith6492(params);
-  }
-
-  withPaymasterMiddleware = (overrides: {
-    dummyPaymasterDataMiddleware?: PaymasterAndDataMiddleware;
-    paymasterDataMiddleware?: PaymasterAndDataMiddleware;
-  }): this => {
-    this.provider.withPaymasterMiddleware(overrides);
-    return this;
-  };
-
-  withGasEstimator = (override: GasEstimatorMiddleware): this => {
-    this.provider.withGasEstimator(override);
-    return this;
-  };
-
-  withFeeDataGetter = (override: FeeDataMiddleware): this => {
-    this.provider.withFeeDataGetter(override);
-    return this;
-  };
-
-  withCustomMiddleware = (override: AccountMiddlewareFn): this => {
-    this.provider.withCustomMiddleware(override);
-    return this;
-  };
-
-  async sendTransaction(
-    transaction: Deferrable<TransactionRequest>
-  ): Promise<TransactionResponse> {
-    const resolved = await resolveProperties(transaction);
-    const txHash = await this.provider.accountProvider.sendTransaction({
-      // TODO: need to support gas fields as well
-      from: (await this.getAddress()) as `0x${string}`,
-      to: resolved.to as `0x${string}` | undefined,
-      data: hexlifyOptional(resolved.data),
-      value: hexlifyOptional(resolved.value),
-    });
-
-    return this.provider.getTransaction(txHash);
-  }
-
-  signTransaction(
-    _transaction: Deferrable<TransactionRequest>
-  ): Promise<string> {
-    throw new Error(
-      "Transaction signing is not supported, use sendUserOperation instead"
-    );
-  }
-
-  getPublicErc4337Client(): PublicErc4337Client {
-    return this.provider.getPublicErc4337Client();
-  }
-
-  connect(provider: ZeroDevEthersProvider<V>): ZeroDevAccountSigner<V> {
-    return new ZeroDevAccountSigner(provider);
-  }
-}

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

@@ -1,149 +0,0 @@
-import { getChainId } from "../api/index.js";
-import {
-  BaseSmartContractAccount,
-  defineReadOnly,
-  type AccountMiddlewareFn,
-  type FeeDataMiddleware,
-  type GasEstimatorMiddleware,
-  type PaymasterAndDataMiddleware,
-  type PublicErc4337Client,
-} from "@alchemy/aa-core";
-import { ZeroDevAccountSigner } from "./account-signer.js";
-import { JsonRpcProvider } from "@ethersproject/providers";
-import type { SupportedValidators } from "../validator/types.js";
-import type {
-  ValidatorProviderParamsMap,
-  ValidatorProviderTypeMap,
-} from "../validator-provider/types.js";
-import { ValidatorProviders } from "../validator-provider/index.js";
-import { withZeroDevPaymasterAndData } from "../middleware/paymaster.js";
-import { getChain } from "../utils.js";
-
-export class ZeroDevEthersProvider<
-  V extends SupportedValidators
-> extends JsonRpcProvider {
-  readonly accountProvider: ValidatorProviderTypeMap[V];
-  constructor(validatorType: V, params: ValidatorProviderParamsMap[V]) {
-    super();
-    let bundlerProvider = params.bundlerProvider;
-    const shouldUsePaymaster =
-      (params.usePaymaster === undefined || params.usePaymaster) &&
-      bundlerProvider !== "GELATO";
-    if (
-      params.opts?.paymasterConfig &&
-      params.opts?.paymasterConfig.policy === "TOKEN_PAYMASTER" &&
-      shouldUsePaymaster
-    ) {
-      bundlerProvider = "STACKUP";
-    }
-    let accountProvider = new ValidatorProviders[validatorType]({
-      ...params,
-      bundlerProvider,
-    });
-    if (shouldUsePaymaster) {
-      let paymasterConfig = params.opts?.paymasterConfig ?? {
-        policy: "VERIFYING_PAYMASTER",
-      };
-      paymasterConfig = {
-        ...paymasterConfig,
-        paymasterProvider:
-          params.opts?.paymasterConfig?.paymasterProvider ?? bundlerProvider,
-      };
-      accountProvider = withZeroDevPaymasterAndData(
-        accountProvider,
-        paymasterConfig
-      ) as ValidatorProviderTypeMap[V];
-    }
-    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;
-  }
-
-  getAccountProvider(): ValidatorProviderTypeMap[V] {
-    return this.accountProvider;
-  }
-
-  /**
-   * 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 ZeroDevAccountSigner} that can be used to sign and send user operations
-   */
-  connectToAccount(
-    fn: (rpcClient: PublicErc4337Client) => BaseSmartContractAccount
-  ): ZeroDevAccountSigner<V> {
-    defineReadOnly(
-      this,
-      "accountProvider",
-      this.accountProvider.connect(fn) as ValidatorProviderTypeMap[V]
-    );
-    return this.getAccountSigner();
-  }
-
-  /**
-   * @returns an {@link ZeroDevAccountSigner} using this as the underlying provider
-   */
-  getAccountSigner(): ZeroDevAccountSigner<V> {
-    return new ZeroDevAccountSigner(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;
-  }
-}

package/src/kernel-zerodev/middleware/gas-estimator.ts

@@ -1,219 +0,0 @@
-import type { ZeroDevProvider } from "../provider.js";
-import {
-  deepHexlify,
-  type Hex,
-  type UserOperationStruct,
-  resolveProperties,
-  type BigNumberish,
-  type UserOperationEstimateGasResponse,
-} from "@alchemy/aa-core";
-import { BaseError } from "viem";
-import { ENTRYPOINT_ADDRESS } from "../constants.js";
-import { calcPreVerificationGas } from "../utils/calc-pre-verification-gas.js";
-import { type PaymasterAndBundlerProviders } from "../paymaster/types.js";
-
-// @dev implement Eip1559FeesNotSupportedError message for compatibility with viem
-export class Eip1559FeesNotSupportedError extends BaseError {
-  override name = "Eip1559FeesNotSupportedError";
-  constructor() {
-    super("Chain does not support EIP-1559 fees.");
-  }
-}
-
-export const withZeroDevGasEstimator = (
-  provider: ZeroDevProvider
-): ZeroDevProvider => {
-  provider.withFeeDataGetter(async (struct) => {
-    let overrides = await resolveProperties({
-      maxFeePerGas: struct.maxFeePerGas,
-      maxPriorityFeePerGas: struct.maxPriorityFeePerGas,
-    });
-
-    if (provider.bundlerProvider === "GELATO") {
-      return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
-    }
-
-    let maxFeePerGas, maxPriorityFeePerGas;
-
-    try {
-      ({ maxFeePerGas, maxPriorityFeePerGas } = await eip1559GasPrice(
-        provider
-      ));
-    } catch (error: any) {
-      console.warn(
-        "getGas: eth_maxPriorityFeePerGas failed, falling back to legacy gas price."
-      );
-    }
-
-    if (maxFeePerGas === undefined || maxPriorityFeePerGas === undefined) {
-      const feeData = await getFeeData(provider);
-      maxFeePerGas = feeData?.maxFeePerGas ? BigInt(feeData?.maxFeePerGas) : 0n;
-      maxPriorityFeePerGas = feeData.maxPriorityFeePerGas
-        ? BigInt(feeData.maxPriorityFeePerGas)
-        : 0n;
-    }
-
-    if (overrides.maxFeePerGas || overrides.maxPriorityFeePerGas) {
-      return {
-        maxFeePerGas: overrides.maxFeePerGas ?? maxFeePerGas,
-        maxPriorityFeePerGas:
-          overrides.maxPriorityFeePerGas ?? maxPriorityFeePerGas,
-      };
-    }
-    return { maxFeePerGas, maxPriorityFeePerGas };
-  });
-
-  provider.withGasEstimator(async (struct) => {
-    if (
-      struct.callGasLimit !== undefined &&
-      struct.verificationGasLimit !== undefined &&
-      struct.preVerificationGas !== undefined
-    ) {
-      return struct;
-    }
-    const initCode = await provider.account?.getInitCode();
-    const initGas = await estimateCreationGas(provider, initCode);
-    const partialStruct: UserOperationStruct = {
-      ...struct,
-      callGasLimit:
-        initCode !== undefined && initCode.length > 2
-          ? BigInt("1000000")
-          : BigInt(55000),
-      verificationGasLimit: BigInt(110000) + initGas,
-      preVerificationGas: BigInt(100000),
-    };
-
-    partialStruct.preVerificationGas = await getPreVerificationGas(
-      partialStruct
-    );
-
-    const request = deepHexlify(await resolveProperties(partialStruct));
-    let userOpGasEstimates: UserOperationEstimateGasResponse | undefined;
-    userOpGasEstimates = await provider.rpcClient.estimateUserOperationGas(
-      request,
-      ENTRYPOINT_ADDRESS
-    );
-    const { preVerificationGas, verificationGasLimit, callGasLimit } =
-      userOpGasEstimates;
-    request.preVerificationGas =
-      BigInt(preVerificationGas) ?? request.preVerificationGas;
-    request.verificationGasLimit =
-      BigInt(verificationGasLimit) ?? request.verificationGasLimit;
-    request.callGasLimit = BigInt(callGasLimit) ?? request.callGasLimit;
-
-    return {
-      ...struct,
-      ...request,
-    };
-  });
-
-  return provider;
-};
-
-export const estimateCreationGas = async (
-  provider: ZeroDevProvider,
-  initCode?: string
-): Promise<bigint> => {
-  if (initCode == null || initCode === "0x") return BigInt(0);
-  const deployerAddress = initCode.substring(0, 42) as Hex;
-  const deployerCallData = ("0x" + initCode.substring(42)) as Hex;
-  return await provider.rpcClient.estimateGas({
-    account: ENTRYPOINT_ADDRESS,
-    to: deployerAddress,
-    data: deployerCallData,
-  });
-};
-
-/**
- * should cover cost of putting calldata on-chain, and some overhead.
- * actual overhead depends on the expected bundle size
- */
-export const getPreVerificationGas = async (
-  userOp: Partial<UserOperationStruct>
-): Promise<number> => {
-  const p = await resolveProperties(userOp);
-  return calcPreVerificationGas(p);
-};
-
-export const GAS_PRICE_RPC_METHODS_BY_BUNDLER: {
-  [K in PaymasterAndBundlerProviders]: string;
-} = {
-  STACKUP: "eth_maxPriorityFeePerGas",
-  ALCHEMY: "rundler_maxPriorityFeePerGas",
-  PIMLICO: "pimlico_getUserOperationGasPrice",
-  GELATO: "eth_maxPriorityFeePerGas",
-};
-
-export const eip1559GasPrice = async (provider: ZeroDevProvider) => {
-  let [fee, block] = await Promise.all([
-    provider.rpcClient.request({
-      method:
-        // @ts-expect-error
-        GAS_PRICE_RPC_METHODS_BY_BUNDLER[provider.bundlerProvider] ??
-        "eth_maxPriorityFeePerGas",
-      params: [],
-    }) as any,
-    provider.rpcClient.getBlock({ blockTag: "latest" }),
-  ]);
-
-  if (provider.bundlerProvider === "PIMLICO") {
-    fee = fee.standard.maxPriorityFeePerGas;
-  }
-
-  if (typeof block.baseFeePerGas !== "bigint")
-    throw new Eip1559FeesNotSupportedError();
-
-  // use default values of viem
-  const baseFeeMultiplier = 1.2;
-  const decimals = baseFeeMultiplier.toString().split(".")[1].length;
-  const denominator = 10 ** decimals;
-  const multiply = (base: bigint) =>
-    (base * BigInt(baseFeeMultiplier * denominator)) / BigInt(denominator);
-
-  const maxPriorityFeePerGas = BigInt(fee);
-
-  const baseFeePerGas = multiply(block.baseFeePerGas);
-  const maxFeePerGas = baseFeePerGas + maxPriorityFeePerGas;
-
-  return { maxFeePerGas, maxPriorityFeePerGas };
-};
-interface FeeData {
-  maxFeePerGas: BigNumberish | null;
-  maxPriorityFeePerGas: BigNumberish | null;
-}
-
-export const getFeeData = async (
-  provider: ZeroDevProvider
-): Promise<FeeData> => {
-  const { block, gasPrice } = await resolveProperties({
-    block: provider.rpcClient.getBlock({ blockTag: "latest" }),
-    gasPrice: provider.rpcClient.getGasPrice().catch((error) => {
-      console.warn("Legacy: Failed to get gas price", error);
-      return null;
-    }),
-  });
-
-  let maxFeePerGas = null;
-  let maxPriorityFeePerGas = null;
-
-  if (block && block.baseFeePerGas != null) {
-    // Set the tip to the min of the tip for the last block and 1.5 gwei
-    const minimumTip = BigInt("1500000000");
-    maxPriorityFeePerGas = gasPrice ? gasPrice - block.baseFeePerGas : null;
-    if (
-      maxPriorityFeePerGas == null ||
-      maxPriorityFeePerGas - BigInt(0) ||
-      maxPriorityFeePerGas > minimumTip
-    ) {
-      maxPriorityFeePerGas = minimumTip;
-    }
-    maxPriorityFeePerGas =
-      maxPriorityFeePerGas < provider.minPriorityFeePerBid
-        ? provider.minPriorityFeePerBid
-        : maxPriorityFeePerGas;
-    maxFeePerGas =
-      block.baseFeePerGas * BigInt(2) + (maxPriorityFeePerGas ?? 0);
-  }
-
-  return { maxFeePerGas, maxPriorityFeePerGas };
-};

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

@@ -1,86 +0,0 @@
-import { type ConnectedSmartAccountProvider } from "@alchemy/aa-core";
-import type { ZeroDevProvider } from "../provider.js";
-import { Paymasters } from "../paymaster/index.js";
-import type { PaymasterConfig, PaymasterPolicy } from "../paymaster/types.js";
-import { AxiosError } from "axios";
-
-export const withZeroDevPaymasterAndData = <Provider extends ZeroDevProvider>(
-  provider: Provider,
-  paymasterConfig: PaymasterConfig<PaymasterPolicy>
-): Provider => {
-  provider.withPaymasterMiddleware(
-    zeroDevPaymasterAndDataMiddleware(provider, paymasterConfig)
-  );
-
-  return provider;
-};
-
-export const zeroDevPaymasterAndDataMiddleware = <
-  Provider extends ZeroDevProvider,
-  P extends PaymasterPolicy
->(
-  provider: Provider,
-  paymasterConfig: PaymasterConfig<P>
-): Parameters<
-  ConnectedSmartAccountProvider["withPaymasterMiddleware"]
->["0"] => {
-  return {
-    dummyPaymasterDataMiddleware: async (struct) => {
-      struct.paymasterAndData =
-        "0xe93eca6595fe94091dc1af46aac2a8b5d79907700000000000000000000000000000000000000000000000000000000064ee5cd9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-      return struct;
-    },
-    paymasterDataMiddleware: async (struct) => {
-      const preVerificationGas = BigInt("100000");
-      const verificationGasLimit = BigInt("1000000");
-      const callGasLimit = BigInt("55000");
-      const paymaster = new Paymasters[paymasterConfig.policy](
-        provider,
-        paymasterConfig
-      );
-      let paymasterResp;
-      try {
-        paymasterResp = await paymaster.getPaymasterResponse(
-          {
-            ...struct,
-            preVerificationGas,
-            verificationGasLimit,
-            callGasLimit,
-          },
-          paymasterConfig.paymasterProvider,
-          false,
-          provider.shouldConsume()
-        );
-      } catch (error: any) {
-        console.error(error);
-        if (paymasterConfig.onlySendSponsoredTransaction) {
-          if (error instanceof AxiosError)
-            throw Error(error.response?.data.message);
-          else throw error;
-        }
-      }
-      if (
-        paymasterConfig.onlySendSponsoredTransaction &&
-        (!paymasterResp ||
-          !paymasterResp.paymasterAndData ||
-          paymasterResp.paymasterAndData === "0x")
-      ) {
-        throw new Error("Transaction is not sponsored");
-      }
-      if (
-        !paymasterResp ||
-        !paymasterResp.paymasterAndData ||
-        paymasterResp.paymasterAndData === "0x"
-      ) {
-        return {
-          ...struct,
-          paymasterAndData: "0x",
-        };
-      }
-      return {
-        ...struct,
-        ...paymasterResp,
-      };
-    },
-  };
-};