@zerodev/sdk 4.0.2-alpha.23

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

@@ -0,0 +1,183 @@
+import type { ZeroDevProvider } from "../provider.js";
+import {
+  deepHexlify,
+  type Hex,
+  type UserOperationStruct,
+  resolveProperties,
+  type BigNumberish,
+  type UserOperationEstimateGasResponse,
+} from "@alchemy/aa-core";
+import { ENTRYPOINT_ADDRESS } from "../constants.js";
+import { calcPreVerificationGas } from "../utils/calc-pre-verification-gas.js";
+
+export const withZeroDevGasEstimator = (
+  provider: ZeroDevProvider
+): ZeroDevProvider => {
+  provider.withFeeDataGetter(async (struct) => {
+    let overrides = await resolveProperties({
+      maxFeePerGas: struct.maxFeePerGas ?? 0n,
+      maxPriorityFeePerGas: struct.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 (
+      maxFeePerGas < BigInt(overrides.maxFeePerGas) ||
+      maxPriorityFeePerGas < BigInt(overrides.maxPriorityFeePerGas)
+    ) {
+      return overrides;
+    }
+    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) * 12n) / 10n ?? request.preVerificationGas;
+    request.verificationGasLimit =
+      (BigInt(verificationGasLimit) * 12n) / 10n ??
+      request.verificationGasLimit;
+    request.callGasLimit =
+      (BigInt(callGasLimit) * 12n) / 10n ?? 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 eip1559GasPrice = async (provider: ZeroDevProvider) => {
+  const [fee, block] = await Promise.all([
+    provider.rpcClient.getMaxPriorityFeePerGas(),
+    provider.rpcClient.getBlock({ blockTag: "latest" }),
+  ]);
+
+  const tip = BigInt(fee);
+  const buffer = (tip / 100n) * 13n;
+  let maxPriorityFeePerGas = tip + buffer;
+  maxPriorityFeePerGas =
+    maxPriorityFeePerGas < provider.minPriorityFeePerBid
+      ? provider.minPriorityFeePerBid
+      : maxPriorityFeePerGas;
+  const maxFeePerGas = block.baseFeePerGas
+    ? BigInt(block.baseFeePerGas) * 2n + maxPriorityFeePerGas
+    : 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

@@ -0,0 +1,66 @@
+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";
+
+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 = "0x";
+      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
+      );
+      const paymasterResp = await paymaster.getPaymasterResponse(
+        {
+          ...struct,
+          preVerificationGas,
+          verificationGasLimit,
+          callGasLimit,
+        },
+        paymasterConfig.paymasterProvider
+      );
+      if (
+        paymasterConfig.onlySendSponsoredTransaction &&
+        (!paymasterResp || paymasterResp.paymasterAndData === "0x")
+      ) {
+        throw new Error("Transaction is not sponsored");
+      }
+      if (
+        paymasterResp === undefined ||
+        paymasterResp.paymasterAndData === "0x"
+      ) {
+        return struct;
+      }
+      return {
+        ...struct,
+        ...paymasterResp,
+      };
+    },
+  };
+};

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

@@ -0,0 +1,76 @@
+import {
+  deepHexlify,
+  type BytesLike,
+  type PromiseOrValue,
+  type UserOperationStruct,
+  resolveProperties,
+} from "@alchemy/aa-core";
+import axios from "axios";
+import { ENTRYPOINT_ADDRESS, PAYMASTER_URL } from "../constants.js";
+import type { ZeroDevProvider } from "../provider.js";
+import { hexifyUserOp } from "../utils/ERC4337-utils.js";
+import type { PaymasterAndBundlerProviders } from "./types.js";
+import { getChainId } from "../api/index.js";
+
+export abstract class Paymaster {
+  constructor(protected provider: ZeroDevProvider) {}
+  abstract getPaymasterResponse(
+    struct: UserOperationStruct,
+    paymasterProvider?: PaymasterAndBundlerProviders
+  ): Promise<UserOperationStruct>;
+  protected async signUserOp({
+    userOp,
+    callData,
+    gasTokenAddress,
+    erc20UserOp,
+    erc20CallData,
+    paymasterProvider,
+  }: {
+    userOp: UserOperationStruct;
+    callData?: PromiseOrValue<BytesLike>;
+    gasTokenAddress?: string;
+    erc20UserOp?: Partial<UserOperationStruct>;
+    erc20CallData?: PromiseOrValue<BytesLike>;
+    paymasterProvider?: PaymasterAndBundlerProviders;
+  }): Promise<any> {
+    try {
+      const hexifiedUserOp = deepHexlify(await resolveProperties(userOp));
+      let resolvedERC20UserOp;
+      let hexifiedERC20UserOp: any;
+      if (erc20UserOp) {
+        resolvedERC20UserOp = await resolveProperties(erc20UserOp);
+
+        hexifiedERC20UserOp = hexifyUserOp(resolvedERC20UserOp);
+      }
+      const chainId = await getChainId(this.provider.getProjectId());
+      if (!chainId) throw new Error("ChainId not found");
+      let requestBodyParams = Object.fromEntries(
+        Object.entries({
+          projectId: this.provider.getProjectId(),
+          chainId,
+          userOp: hexifiedUserOp,
+          entryPointAddress: ENTRYPOINT_ADDRESS,
+          callData: callData instanceof Promise ? await callData : callData,
+          tokenAddress: gasTokenAddress,
+          erc20UserOp: hexifiedERC20UserOp,
+          erc20CallData:
+            erc20CallData instanceof Promise
+              ? await erc20CallData
+              : erc20CallData,
+          paymasterProvider,
+        }).filter(([_, value]) => value !== undefined)
+      );
+      const { data: paymasterResp } = await axios.post(
+        `${PAYMASTER_URL}/sign`,
+        {
+          ...requestBodyParams,
+        },
+        { headers: { "Content-Type": "application/json" } }
+      );
+      return paymasterResp;
+    } catch (error) {
+      console.log(error);
+      return undefined;
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+import { TokenPaymaster } from "./token-paymaster.js";
+import type { PaymasterMap } from "./types.js";
+import { VerifyingPaymaster } from "./verifying-paymaster.js";
+import type { ZeroDevProvider } from "../provider.js";
+
+export const Paymasters: PaymasterMap<ZeroDevProvider> = {
+  VERIFYING_PAYMASTER: VerifyingPaymaster,
+  TOKEN_PAYMASTER: TokenPaymaster,
+};

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

@@ -0,0 +1,209 @@
+import {
+  type PromiseOrValue,
+  type BytesLike,
+  type UserOperationCallData,
+  type UserOperationStruct,
+} from "@alchemy/aa-core";
+import axios from "axios";
+import { type Hex, toHex, decodeFunctionData, encodeFunctionData } from "viem";
+import { ERC20Abi } from "../abis/ERC20Abi.js";
+import { KernelAccountAbi } from "../abis/KernelAccountAbi.js";
+import { MultiSendAbi } from "../abis/MultiSendAbi.js";
+import {
+  PAYMASTER_URL,
+  ENTRYPOINT_ADDRESS,
+  MULTISEND_ADDR,
+  ERC20_APPROVAL_AMOUNT,
+} from "../constants.js";
+import {
+  AccountNotConnected,
+  IncorrectCallDataForTokenPaymaster,
+} from "../errors.js";
+import type { ZeroDevProvider } from "../provider.js";
+import {
+  getGasTokenAddress,
+  type UserOperationCallDataWithDelegate,
+} from "../utils.js";
+import { Paymaster } from "./base.js";
+import {
+  type PaymasterAndBundlerProviders,
+  type PaymasterConfig,
+} from "./types.js";
+import { getChainId } from "../api/index.js";
+
+export class TokenPaymaster extends Paymaster {
+  constructor(
+    provider: ZeroDevProvider,
+    protected paymasterConfig: PaymasterConfig<"TOKEN_PAYMASTER">
+  ) {
+    super(provider);
+  }
+  async getPaymasterAddress(): Promise<Hex | undefined> {
+    const chainId = await getChainId(this.provider.getProjectId());
+
+    try {
+      const { data: paymasterResp } = await axios.post(
+        `${PAYMASTER_URL}/getPaymasterAddress`,
+        {
+          chainId,
+          entryPointAddress: ENTRYPOINT_ADDRESS,
+        },
+        { headers: { "Content-Type": "application/json" } }
+      );
+      return paymasterResp as Hex;
+    } catch (e) {
+      console.log(e);
+      return undefined;
+    }
+  }
+  async decodeMainCallFromCallData(
+    kernelAddress: PromiseOrValue<string>,
+    callData: PromiseOrValue<BytesLike>
+  ): Promise<UserOperationCallDataWithDelegate | undefined> {
+    let data: Hex = "0x";
+    if (callData instanceof Promise) {
+      const _data = await callData;
+      if (_data instanceof Uint8Array) {
+        data = toHex(_data);
+      } else {
+        data = _data as Hex;
+      }
+    } else if (callData instanceof Uint8Array) {
+      data = toHex(callData);
+    } else {
+      data = callData as Hex;
+    }
+
+    try {
+      const { functionName, args } = decodeFunctionData({
+        abi: KernelAccountAbi,
+        data: data,
+      });
+      if (functionName === "execute") {
+        const [target, value, data] = args;
+        let msFuntionName;
+        try {
+          ({ functionName: msFuntionName } = decodeFunctionData({
+            abi: MultiSendAbi,
+            data,
+          }));
+        } catch (error) {}
+        let mainCall:
+          | UserOperationCallData
+          | UserOperationCallDataWithDelegate = {
+          target,
+          value: value ?? 0n,
+          data,
+        };
+        if (msFuntionName === "multiSend") {
+          mainCall = {
+            ...mainCall,
+            target: MULTISEND_ADDR,
+            delegateCall: true,
+            data,
+          };
+        }
+        return mainCall;
+      }
+    } catch (error) {
+      return {
+        target: (kernelAddress instanceof Promise
+          ? await kernelAddress
+          : kernelAddress) as Hex,
+        data,
+        value: 0n,
+        delegateCall: true,
+      };
+    }
+    return;
+  }
+
+  async getERC20UserOp(
+    struct: UserOperationStruct,
+    mainCall: UserOperationCallDataWithDelegate,
+    gasTokenAddress: Hex,
+    paymasterAddress: Hex
+  ): Promise<UserOperationStruct | undefined> {
+    try {
+      const approveData: UserOperationCallData = {
+        target: gasTokenAddress,
+        value: BigInt(0),
+        data: encodeFunctionData({
+          abi: ERC20Abi,
+          functionName: "approve",
+          args: [paymasterAddress, ERC20_APPROVAL_AMOUNT[gasTokenAddress]],
+        }),
+      };
+      if (!this.provider.account) {
+        throw AccountNotConnected;
+      }
+      const erc20CallData = await this.provider.account.encodeBatchExecute([
+        approveData,
+        mainCall,
+      ]);
+      return {
+        ...struct,
+        callData: erc20CallData,
+        callGasLimit: await this.provider.rpcClient.estimateGas({
+          account: ENTRYPOINT_ADDRESS,
+          to: await this.provider.getAddress(),
+          data: erc20CallData,
+        }),
+      };
+    } catch (error) {
+      return;
+    }
+  }
+
+  async getPaymasterResponse(
+    struct: UserOperationStruct,
+    paymasterProvider?: PaymasterAndBundlerProviders
+  ): Promise<UserOperationStruct> {
+    try {
+      const mainCall = await this.decodeMainCallFromCallData(
+        struct.sender,
+        struct.callData
+      );
+      if (!mainCall) {
+        throw IncorrectCallDataForTokenPaymaster;
+      }
+      const chainId = await getChainId(this.provider.getProjectId());
+      if (!chainId) {
+        throw new Error("ChainId not found");
+      }
+      const gasTokenAddress = getGasTokenAddress(
+        this.paymasterConfig.gasToken,
+        chainId
+      );
+      let paymasterAddress = await this.getPaymasterAddress();
+      if (gasTokenAddress !== undefined && paymasterAddress !== undefined) {
+        const erc20UserOp = await this.getERC20UserOp(
+          struct,
+          mainCall,
+          gasTokenAddress,
+          paymasterAddress
+        );
+        if (!erc20UserOp) {
+          return struct;
+        }
+        const paymasterResp = await this.signUserOp({
+          userOp: struct,
+          callData: struct.callData,
+          gasTokenAddress,
+          erc20UserOp,
+          erc20CallData: erc20UserOp.callData,
+          paymasterProvider,
+        });
+        if (paymasterResp) {
+          return {
+            ...struct,
+            ...paymasterResp,
+          };
+        }
+      }
+    } catch (error) {
+      return struct;
+    }
+    return struct;
+  }
+}

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

@@ -0,0 +1,36 @@
+import type { Hex } from "viem";
+import type { Paymaster } from "./base.js";
+import type { ZeroDevProvider } from "../provider.js";
+
+export type PaymasterAndBundlerProviders = "ALCHEMY" | "STACKUP" | "PIMLICO";
+
+export type SupportedGasToken = "USDC" | "PEPE" | "TEST_ERC20";
+
+export type PaymasterPolicy = "VERIFYING_PAYMASTER" | "TOKEN_PAYMASTER";
+
+interface PaymasterConfigOptions {
+  VERIFYING_PAYMASTER: {};
+  TOKEN_PAYMASTER: { gasToken: SupportedGasToken };
+}
+
+export type PaymasterConfig<T extends PaymasterPolicy> = {
+  policy: T;
+  paymasterProvider?: PaymasterAndBundlerProviders;
+  onlySendSponsoredTransaction?: boolean;
+} & PaymasterConfigOptions[T];
+export interface IGasTokenAddresses {
+  [key: string]: {
+    [chainId: number]: Hex;
+  };
+}
+
+export interface IPaymaster<
+  Provider extends ZeroDevProvider,
+  P extends PaymasterPolicy
+> {
+  new (provider: Provider, paymasterConfig: PaymasterConfig<P>): Paymaster;
+}
+
+export type PaymasterMap<Provider extends ZeroDevProvider> = {
+  [P in PaymasterPolicy]: IPaymaster<Provider, P>;
+};

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

@@ -0,0 +1,38 @@
+import {
+  type UserOperationStruct,
+  deepHexlify,
+  resolveProperties,
+} from "@alchemy/aa-core";
+import { Paymaster } from "./base.js";
+import type { ZeroDevProvider } from "../provider.js";
+import type { PaymasterAndBundlerProviders, PaymasterConfig } from "./types.js";
+
+export class VerifyingPaymaster extends Paymaster {
+  constructor(
+    provider: ZeroDevProvider,
+    _: PaymasterConfig<"VERIFYING_PAYMASTER">
+  ) {
+    super(provider);
+  }
+  async getPaymasterResponse(
+    struct: UserOperationStruct,
+    paymasterProvider?: PaymasterAndBundlerProviders
+  ): Promise<UserOperationStruct> {
+    try {
+      const hexifiedUserOp = deepHexlify(await resolveProperties(struct));
+      const paymasterResp = await this.signUserOp({
+        userOp: hexifiedUserOp,
+        paymasterProvider,
+      });
+      if (paymasterResp) {
+        return {
+          ...struct,
+          ...paymasterResp,
+        };
+      }
+    } catch (error) {
+      return struct;
+    }
+    return struct;
+  }
+}