@account-kit/infra 4.0.0-alpha.0 → 4.0.0-alpha.10

package/src/defaults.ts

@@ -1,3 +1,5 @@
+import { type UserOperationFeeOptions } from "@aa-sdk/core";
+import type { Chain } from "viem";
 import {
   arbitrum,
   arbitrumGoerli,
@@ -5,10 +7,22 @@ import {
   optimism,
   optimismGoerli,
   optimismSepolia,
-  type UserOperationFeeOptions,
-} from "@aa-sdk/core";
-import type { Chain } from "viem";
+} from "./chains.js";
 
+/**
+ * Retrieves the default user operation fee options for a given chain. Adjusts fees for specific chains like Arbitrum and Optimism.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultUserOperationFeeOptions } from "@account-kit/infra";
+ * import { arbitrum } from "@account-kit/infra";
+ *
+ * const feeOpts = getDefaultUserOperationFeeOptions(arbitrum);
+ * ```
+ *
+ * @param {Chain} chain The blockchain chain for which to get the fee options
+ * @returns {UserOperationFeeOptions} An object containing the default fee options for user operations on the specified chain
+ */
 export const getDefaultUserOperationFeeOptions = (
   chain: Chain
 ): UserOperationFeeOptions => {

package/src/gas-manager.ts

@@ -4,18 +4,18 @@ import {
   arbitrumSepolia,
   base,
   baseSepolia,
+  fraxtal,
+  fraxtalSepolia,
   mainnet,
-  sepolia,
   optimism,
   optimismSepolia,
   polygon,
   polygonAmoy,
   polygonMumbai,
-  fraxtal,
-  fraxtalSepolia,
+  sepolia,
   zora,
   zoraSepolia,
-} from "@aa-sdk/core";
+} from "./chains.js";
 
 export const AlchemyPaymasterAddressV3 =
   "0x4f84a207A80c39E9e8BaE717c1F25bA7AD1fB08F";
@@ -26,6 +26,19 @@ export const ArbSepoliaPaymasterAddress =
 export const AlchemyPaymasterAddressV1 =
   "0xc03aac639bb21233e0139381970328db8bceeb67";
 
+/**
+ * Retrieves the Alchemy paymaster address for the given chain. Returns different addresses based on the chain ID.
+ *
+ * @example
+ * ```ts
+ * import { sepolia, getAlchemyPaymasterAddress } from "@account-kit/infra";
+ *
+ * const paymasterAddress = getAlchemyPaymasterAddress(sepolia);
+ * ```
+ *
+ * @param {Chain} chain The chain for which the paymaster address is required
+ * @returns {Address} The Alchemy paymaster address corresponding to the specified chain
+ */
 export const getAlchemyPaymasterAddress = (chain: Chain): Address => {
   switch (chain.id) {
     case polygonAmoy.id:

package/src/index.ts

@@ -1,7 +1,31 @@
 export type * from "./actions/simulateUserOperationChanges.js";
 export { simulateUserOperationChanges } from "./actions/simulateUserOperationChanges.js";
 export type * from "./actions/types.js";
-export { defineAlchemyChain } from "./chains.js";
+export type * from "./chains.js";
+export {
+  arbitrum,
+  arbitrumGoerli,
+  arbitrumSepolia,
+  base,
+  baseGoerli,
+  baseSepolia,
+  defineAlchemyChain,
+  fraxtal,
+  fraxtalSepolia,
+  goerli,
+  mainnet,
+  optimism,
+  optimismGoerli,
+  optimismSepolia,
+  polygon,
+  polygonAmoy,
+  polygonMumbai,
+  sepolia,
+  zora,
+  zoraSepolia,
+  worldChain,
+  worldChainSepolia,
+} from "./chains.js";
 export type * from "./client/decorators/alchemyEnhancedApis.js";
 export { alchemyEnhancedApiActions } from "./client/decorators/alchemyEnhancedApis.js";
 export type * from "./client/decorators/smartAccount.js";

package/src/middleware/feeEstimator.ts

@@ -2,6 +2,25 @@ import type { ClientMiddlewareFn } from "@aa-sdk/core";
 import { applyUserOpOverrideOrFeeOption } from "@aa-sdk/core";
 import type { ClientWithAlchemyMethods } from "../client/types";
 
+/**
+ * Function that estimates the transaction fees using Alchemy methods for a given client.
+ * It fetches the latest block and estimates the max priority fee per gas, applying any overrides or fee options provided.
+ *
+ * @example
+ * ```ts
+ * import { alchemyFeeEstimator, createAlchemyPublicRpcClient } from "@account-kit/infra";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const bundlerClient = createAlchemyPublicRpcClient(...);
+ * const client = createSmartAccountClient({
+ *  feeEstimator: alchemyFeeEstimator(bundlerClient),
+ *  ...otherParams
+ * });
+ * ```
+ *
+ * @param {ClientWithAlchemyMethods} client The client with Alchemy methods
+ * @returns {ClientMiddlewareFn} A middleware function that takes a transaction structure and fee options, and returns the augmented structure with estimated fees
+ */
 export const alchemyFeeEstimator: <C extends ClientWithAlchemyMethods>(
   client: C
 ) => ClientMiddlewareFn =

package/src/middleware/gasManager.ts

@@ -1,432 +1,29 @@
-import type {
-  Address,
-  ClientMiddlewareConfig,
-  ClientMiddlewareFn,
-  EntryPointVersion,
-  Multiplier,
-  UserOperationFeeOptions,
-  UserOperationOverrides,
-  UserOperationRequest,
-} from "@aa-sdk/core";
-import {
-  bypassPaymasterAndDataEmptyHex,
-  deepHexlify,
-  defaultGasEstimator,
-  filterUndefined,
-  isBigNumberish,
-  isMultiplier,
-  resolveProperties,
-} from "@aa-sdk/core";
-import { concat, fromHex, isHex, type Hex } from "viem";
-import type { ClientWithAlchemyMethods } from "../client/types";
-import { getAlchemyPaymasterAddress } from "../gas-manager.js";
-import { alchemyFeeEstimator } from "./feeEstimator.js";
+import type { ClientMiddlewareConfig } from "@aa-sdk/core";
+import { erc7677Middleware } from "@aa-sdk/core";
 
 /**
- * overrides value for [`alchemy_requestGasAndPaymasterData`](https://docs.alchemy.com/reference/alchemy-requestgasandpaymasteranddata)
+ * Paymaster middleware factory that uses Alchemy's Gas Manager for sponsoring transactions.
  *
- * @template {EntryPointVersion} TEntryPointVersion entry point version type
- */
-export type RequestGasAndPaymasterAndDataOverrides<
-  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
-> = Partial<
-  {
-    maxFeePerGas:
-      | UserOperationRequest<TEntryPointVersion>["maxFeePerGas"]
-      | Multiplier;
-    maxPriorityFeePerGas:
-      | UserOperationRequest<TEntryPointVersion>["maxPriorityFeePerGas"]
-      | Multiplier;
-    callGasLimit:
-      | UserOperationRequest<TEntryPointVersion>["callGasLimit"]
-      | Multiplier;
-    verificationGasLimit:
-      | UserOperationRequest<TEntryPointVersion>["verificationGasLimit"]
-      | Multiplier;
-    preVerificationGas:
-      | UserOperationRequest<TEntryPointVersion>["preVerificationGas"]
-      | Multiplier;
-  } & TEntryPointVersion extends "0.7.0"
-    ? {
-        paymasterVerificationGasLimit:
-          | UserOperationRequest<"0.7.0">["paymasterVerificationGasLimit"]
-          | Multiplier;
-        paymasterPostOpGasLimit:
-          | UserOperationRequest<"0.7.0">["paymasterPostOpGasLimit"]
-          | Multiplier;
-      }
-    : {}
->;
-
-/**
- * [`alchemy-requestpaymasteranddata`](https://docs.alchemy.com/reference/alchemy-requestpaymasteranddata)
- * response type
+ * @example
+ *  ```ts
  *
- * @template {EntryPointVersion} TEntryPointVersion entry point version type
- */
-export type RequestPaymasterAndDataResponse<
-  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
-> = TEntryPointVersion extends "0.6.0"
-  ? {
-      paymasterAndData: UserOperationRequest<"0.6.0">["paymasterAndData"];
-    }
-  : TEntryPointVersion extends "0.7.0"
-  ? Pick<UserOperationRequest<"0.7.0">, "paymaster" | "paymasterData">
-  : {};
-
-/**
- * [`alchemy_requestGasAndPaymasterData`](https://docs.alchemy.com/reference/alchemy-requestgasandpaymasteranddata)
- * response type
+ * import { sepolia } from "@account-kit/infra";
+ * import { http } from "viem";
  *
- * @template {EntryPointVersion} TEntryPointVersion entry point version type
- */
-export type RequestGasAndPaymasterAndDataResponse<
-  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
-> = Pick<
-  UserOperationRequest,
-  | "callGasLimit"
-  | "preVerificationGas"
-  | "verificationGasLimit"
-  | "maxFeePerGas"
-  | "maxPriorityFeePerGas"
-> &
-  RequestPaymasterAndDataResponse<TEntryPointVersion>;
-
-/**
- * Alchemy gas manager configuration with gas policy id and optional gas estimation options
- *
- * To create a Gas Manager Policy, go to the [gas manager](https://dashboard.alchemy.com/gas-manager?a=embedded-accounts-get-started)
- * page of the Alchemy dashboard and click the “Create new policy” button.
- */
-export interface AlchemyGasManagerConfig {
-  /**
-   * the policy id of the gas manager you want to use.
-   *
-   */
-  policyId: string;
-  /**
-   * optional option configurable for the gas estimation portion of the Alchemy gas manager
-   *
-   */
-  gasEstimationOptions?: AlchemyGasEstimationOptions;
-  /**
-   * paymaster address to use for the gas estimation.
-   * If not provided, the default paymaster address for the chain will be used.
-   *
-   */
-  paymasterAddress?: Address;
-  /**
-   * dummy paymaster data to use for the gas estimation.
-   *
-   */
-  dummyData?: Hex;
-}
-
-/**
- * Alchemy gas manager configuration option configurable for the gas estimation portion of the Alchemy gas manager
+ * const client = createSmartAccountClient({
+ *      http("rpc-url"),
+ *      sepolia,
+ *      alchemyErc7677Middleware("policyId")
+ *    );
+ * ```
  *
+ * @param {string} policyId the policyId for Alchemy's gas manager
+ * @returns {Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData">} partial client middleware configuration containing `dummyPaymasterAndData` and `paymasterAndData`
  */
-export interface AlchemyGasEstimationOptions {
-  /**
-   * disable gas estimation and fallback to the default gas estimation.
-   *
-   */
-  disableGasEstimation: boolean;
-  /**
-   * optional fallback gas estimator to use when gas estimation is disabled.
-   *
-   */
-  fallbackGasEstimator?: ClientMiddlewareFn;
-  /**
-   * optional fallback fee estimator to use when gas estimation is disabled.
-   *
-   */
-  fallbackFeeDataGetter?: ClientMiddlewareFn;
+export function alchemyGasManagerMiddleware(
+  policyId: string
+): Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData"> {
+  return erc7677Middleware<{ policyId: string }>({
+    context: { policyId: policyId },
+  });
 }
-
-/**
- * dummy paymaster and data middleware for the alchemy gas manager
- *
- * @template {ClientWithAlchemyMethods} C
- * @param client client with alchemy methods
- * @param config alchemy gas manager configuration
- * @returns the dummyPaymasterAndData middleware for Alchemy gas manager
- */
-const dummyPaymasterAndData =
-  <C extends ClientWithAlchemyMethods>(
-    client: C,
-    config: AlchemyGasManagerConfig
-  ) =>
-  () => {
-    const paymaster =
-      config.paymasterAddress ?? getAlchemyPaymasterAddress(client.chain);
-    const paymasterData =
-      config.dummyData ??
-      "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-
-    return concat([paymaster, paymasterData]); // or you can also return { paymaster, paymasterData }
-  };
-
-/**
- * Alchemy gas manager middleware used as the paymaster middleware overrides param to the client middleware config
- *
- * @template {ClientWithAlchemyMethods} C
- * @param client client with alchemy methods
- * @param config alchemy gas manager configuration
- * @returns the gas estimator, fee estimator, and paymasterAndData middleware for Alchemy gas manager
- */
-export function alchemyGasManagerMiddleware<C extends ClientWithAlchemyMethods>(
-  client: C,
-  config: AlchemyGasManagerConfig
-): Pick<
-  ClientMiddlewareConfig,
-  "paymasterAndData" | "feeEstimator" | "gasEstimator"
-> {
-  const gasEstimationOptions = config.gasEstimationOptions;
-  const disableGasEstimation =
-    gasEstimationOptions?.disableGasEstimation ?? false;
-  const fallbackFeeDataGetter =
-    gasEstimationOptions?.fallbackFeeDataGetter ?? alchemyFeeEstimator(client);
-  const fallbackGasEstimator =
-    gasEstimationOptions?.fallbackGasEstimator ??
-    defaultGasEstimator<C>(client);
-
-  return {
-    gasEstimator: disableGasEstimation
-      ? fallbackGasEstimator
-      : async (struct, { overrides, account, feeOptions }) => {
-          // if user is bypassing paymaster to fallback to having the account to pay the gas (one-off override),
-          // we cannot delegate gas estimation to the bundler because paymaster middleware will not be called
-          if (bypassPaymasterAndDataEmptyHex(overrides)) {
-            return {
-              ...struct,
-              ...(await fallbackGasEstimator(struct, {
-                overrides,
-                account,
-                feeOptions,
-                client,
-              })),
-            };
-          }
-
-          // essentially noop, because the gas estimation will happen in the backend
-          return struct;
-        },
-    feeEstimator: disableGasEstimation
-      ? fallbackFeeDataGetter
-      : async (struct, { overrides, account, feeOptions }) => {
-          let maxFeePerGas = await struct.maxFeePerGas;
-          let maxPriorityFeePerGas = await struct.maxPriorityFeePerGas;
-
-          // if user is bypassing paymaster to fallback to having the account to pay the gas (one-off override),
-          // we cannot delegate gas estimation to the bundler because paymaster middleware will not be called
-          if (bypassPaymasterAndDataEmptyHex(overrides)) {
-            const result = await fallbackFeeDataGetter(struct, {
-              overrides,
-              feeOptions,
-              account,
-              client,
-            });
-            maxFeePerGas = (await result.maxFeePerGas) ?? maxFeePerGas;
-            maxPriorityFeePerGas =
-              (await result.maxPriorityFeePerGas) ?? maxPriorityFeePerGas;
-          }
-
-          return {
-            ...struct,
-            maxFeePerGas,
-            maxPriorityFeePerGas,
-          };
-        },
-    paymasterAndData: disableGasEstimation
-      ? requestPaymasterAndData(client, config)
-      : requestGasAndPaymasterData(client, config),
-  };
-}
-
-/**
- * Utility function to override a field in the user operation request with the overrides or fee options
- *
- * @template {EntryPointVersion} TEntryPointVersion
- * @param field the field to override
- * @param overrides the overrides object
- * @param feeOptions the fee options object from the client
- * @param userOperation the user operation request
- * @returns the overridden field value
- */
-const overrideField = <
-  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
->(
-  field: keyof UserOperationFeeOptions<TEntryPointVersion>,
-  overrides: UserOperationOverrides<TEntryPointVersion> | undefined,
-  feeOptions: UserOperationFeeOptions<TEntryPointVersion> | undefined,
-  userOperation: UserOperationRequest<TEntryPointVersion>
-): Hex | Multiplier | undefined => {
-  let _field = field as keyof UserOperationOverrides<TEntryPointVersion>;
-
-  if (overrides?.[_field] != null) {
-    // one-off absolute override
-    if (isBigNumberish(overrides[_field])) {
-      return deepHexlify(overrides[_field]);
-    }
-    // one-off multiplier overrides
-    else {
-      return {
-        multiplier: Number((overrides[_field] as Multiplier).multiplier),
-      };
-    }
-  }
-
-  // provider level fee options with multiplier
-  if (isMultiplier(feeOptions?.[field])) {
-    return {
-      multiplier: Number((feeOptions![field] as Multiplier).multiplier),
-    };
-  }
-
-  const userOpField =
-    userOperation[field as keyof UserOperationRequest<TEntryPointVersion>];
-  if (isHex(userOpField) && fromHex(userOpField as Hex, "bigint") > 0n) {
-    return userOpField;
-  }
-  return undefined;
-};
-
-/**
- * Alchemy gas manager middleware function that returns the paymaster middleware for the client middleware config
- * that calls the [`alchemy_requestGasAndPaymasterAndData`](https://docs.alchemy.com/reference/alchemy-requestgasandpaymasteranddata)
- *
- * @template {ClientWithAlchemyMethods} C
- * @param client client with alchemy methods
- * @param config alchemy gas manager configuration
- * @returns the paymasterAndData middleware for Alchemy gas manager
- */
-function requestGasAndPaymasterData<C extends ClientWithAlchemyMethods>(
-  client: C,
-  config: AlchemyGasManagerConfig
-): ClientMiddlewareConfig["paymasterAndData"] {
-  return {
-    dummyPaymasterAndData: dummyPaymasterAndData(client, config),
-
-    paymasterAndData: async (
-      struct,
-      { overrides: overrides_, feeOptions, account }
-    ) => {
-      const userOperation: UserOperationRequest = deepHexlify(
-        await resolveProperties(struct)
-      );
-
-      const overrides: RequestGasAndPaymasterAndDataOverrides = filterUndefined(
-        {
-          maxFeePerGas: overrideField(
-            "maxFeePerGas",
-            overrides_ as UserOperationOverrides,
-            feeOptions,
-            userOperation
-          ),
-          maxPriorityFeePerGas: overrideField(
-            "maxPriorityFeePerGas",
-            overrides_ as UserOperationOverrides,
-            feeOptions,
-            userOperation
-          ),
-          callGasLimit: overrideField(
-            "callGasLimit",
-            overrides_ as UserOperationOverrides,
-            feeOptions,
-            userOperation
-          ),
-          verificationGasLimit: overrideField(
-            "verificationGasLimit",
-            overrides_ as UserOperationOverrides,
-            feeOptions,
-            userOperation
-          ),
-          preVerificationGas: overrideField(
-            "preVerificationGas",
-            overrides_ as UserOperationOverrides,
-            feeOptions,
-            userOperation
-          ),
-        }
-      );
-
-      if (account.getEntryPoint().version === "0.7.0") {
-        const paymasterVerificationGasLimit = overrideField<"0.7.0">(
-          "paymasterVerificationGasLimit",
-          overrides_ as UserOperationOverrides<"0.7.0">,
-          feeOptions,
-          userOperation
-        );
-        if (paymasterVerificationGasLimit != null) {
-          (
-            overrides as RequestGasAndPaymasterAndDataOverrides<"0.7.0">
-          ).paymasterVerificationGasLimit = paymasterVerificationGasLimit;
-        }
-
-        const paymasterPostOpGasLimit = overrideField<"0.7.0">(
-          "paymasterPostOpGasLimit",
-          overrides_ as UserOperationOverrides<"0.7.0">,
-          feeOptions,
-          userOperation
-        );
-        if (paymasterPostOpGasLimit != null) {
-          (
-            overrides as RequestGasAndPaymasterAndDataOverrides<"0.7.0">
-          ).paymasterPostOpGasLimit = paymasterPostOpGasLimit;
-        }
-      }
-
-      const result = await client.request({
-        method: "alchemy_requestGasAndPaymasterAndData",
-        params: [
-          {
-            policyId: config.policyId,
-            entryPoint: account.getEntryPoint().address,
-            userOperation,
-            dummySignature: userOperation.signature,
-            overrides,
-          },
-        ],
-      });
-
-      return {
-        ...struct,
-        ...result,
-      };
-    },
-  };
-}
-
-/**
- * Alchemy gas manager middleware function that returns the paymaster middleware for the client middleware config
- * that calls the [`alchemy_requestPaymasterAndData`](https://docs.alchemy.com/reference/alchemy-requestpaymasteranddata)
- * with gas estimation disabled.
- *
- * @param client client with alchemy methods
- * @param config alchemy gas manager configuration
- * @returns the paymasterAndData middleware for Alchemy gas manager with gas estimation disabled
- */
-const requestPaymasterAndData: <C extends ClientWithAlchemyMethods>(
-  client: C,
-  config: AlchemyGasManagerConfig
-) => ClientMiddlewareConfig["paymasterAndData"] = (client, config) => ({
-  dummyPaymasterAndData: dummyPaymasterAndData(client, config),
-  paymasterAndData: async (struct, { account }) => {
-    const result = await client.request({
-      method: "alchemy_requestPaymasterAndData",
-      params: [
-        {
-          policyId: config.policyId,
-          entryPoint: account.getEntryPoint().address,
-          userOperation: deepHexlify(await resolveProperties(struct)),
-        },
-      ],
-    });
-
-    return {
-      ...struct,
-      ...result,
-    };
-  },
-});

package/src/middleware/userOperationSimulator.ts

@@ -2,12 +2,35 @@ import {
   deepHexlify,
   resolveProperties,
   type ClientMiddlewareFn,
+  type UserOperationContext,
 } from "@aa-sdk/core";
 import type { ClientWithAlchemyMethods } from "../client/types";
 
+/**
+ * A middleware function to be used during simulation of user operations which leverages Alchemy's RPC uo simulation method.
+ *
+ * @example
+ * ```ts
+ * import { alchemyUserOperationSimulator, createAlchemyPublicRpcClient } from "@account-kit/infra";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const bundlerClient = createAlchemyPublicRpcClient(...);
+ * const client = createSmartAccountClient({
+ *  userOperationSimulator: alchemyUserOperationSimulator(bundlerClient),
+ *  ...otherParams
+ * });
+ * ```
+ *
+ * @template C The client object with Alchemy methods
+ * @param {C} client The client object with Alchemy methods
+ * @returns {ClientMiddlewareFn} A middleware function to simulate and process user operations
+ */
 export function alchemyUserOperationSimulator<
-  C extends ClientWithAlchemyMethods
->(client: C): ClientMiddlewareFn {
+  C extends ClientWithAlchemyMethods,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(client: C): ClientMiddlewareFn<TContext> {
   return async (struct, { account }) => {
     const uoSimResult = await client.request({
       method: "alchemy_simulateUserOperationAssetChanges",

package/src/schema.ts

@@ -2,24 +2,16 @@ import {
   ChainSchema,
   ConnectionConfigSchema,
   SmartAccountClientOptsSchema,
-  getChain,
 } from "@aa-sdk/core";
 import { Alchemy } from "alchemy-sdk";
 import type { Chain } from "viem";
 import z from "zod";
 
 export const AlchemyChainSchema = z.custom<Chain>((chain) => {
-  const _chain = ChainSchema.parse(chain);
+  const chain_ = ChainSchema.parse(chain);
 
-  let chainObject;
-  try {
-    chainObject = getChain(_chain.id);
-  } catch {
-    return false;
-  }
-
-  return chainObject.rpcUrls.alchemy != null;
-}, "chain must include an alchemy rpc url. See `createAlchemyChain` or use the `AlchemyChainMap` exported from `@aa-sdk/core`");
+  return chain_.rpcUrls.alchemy != null;
+}, "chain must include an alchemy rpc url. See `createAlchemyChain` or import a chain from `@account-kit/infra`.");
 
 export const AlchemyProviderConfigSchema = ConnectionConfigSchema.and(
   z.object({

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is autogenerated by inject-version.ts. Any changes will be
 // overwritten on commit!
-export const VERSION = "4.0.0-alpha.0";
+export const VERSION = "4.0.0-alpha.10";