@account-kit/infra 4.13.1-alpha.0 → 4.15.0

package/src/client/types.ts

@@ -6,6 +6,8 @@ import {
 import type {
   SimulateUserOperationAssetChangesRequest,
   SimulateUserOperationAssetChangesResponse,
+  RequestGasAndPaymasterAndDataRequest,
+  RequestGasAndPaymasterAndDataResponse,
 } from "../actions/types";
 import type { AlchemyTransport } from "../alchemyTransport";
 
@@ -20,7 +22,12 @@ export type AlchemyRpcSchema = [
     Parameters: [];
     ReturnType: UserOperationRequest["maxPriorityFeePerGas"];
   },
-  ...Erc7677RpcSchema<{ policyId: string }>
+  ...Erc7677RpcSchema<{ policyId: string }>,
+  {
+    Method: "alchemy_requestGasAndPaymasterAndData";
+    Parameters: RequestGasAndPaymasterAndDataRequest;
+    ReturnType: RequestGasAndPaymasterAndDataResponse;
+  }
 ];
 
 export type ClientWithAlchemyMethods = BundlerClient<AlchemyTransport> & {
@@ -35,5 +42,10 @@ export type ClientWithAlchemyMethods = BundlerClient<AlchemyTransport> & {
         method: "rundler_maxPriorityFeePerGas";
         params: [];
       }): Promise<UserOperationRequest["maxPriorityFeePerGas"]>;
+
+      request(args: {
+        method: "alchemy_requestGasAndPaymasterAndData";
+        params: RequestGasAndPaymasterAndDataRequest;
+      }): Promise<RequestGasAndPaymasterAndDataResponse>;
     }["request"];
 };

package/src/gas-manager.ts

@@ -38,6 +38,8 @@ export const AlchemyPaymasterAddressV1 =
  *
  * @param {Chain} chain The chain for which the paymaster address is required
  * @returns {Address} The Alchemy paymaster address corresponding to the specified chain
+ *
+ * @deprecated This chain list in this function is no longer maintained since the ERC-7677 middleware is typically used to resolve the paymaster address
  */
 export const getAlchemyPaymasterAddress = (chain: Chain): Address => {
   switch (chain.id) {

package/src/index.ts

@@ -40,6 +40,7 @@ export {
   inkMainnet,
   inkSepolia,
   mekong,
+  monadTestnet,
 } from "./chains.js";
 export type * from "./client/decorators/alchemyEnhancedApis.js";
 export { alchemyEnhancedApiActions } from "./client/decorators/alchemyEnhancedApis.js";
@@ -55,6 +56,9 @@ export { getDefaultUserOperationFeeOptions } from "./defaults.js";
 export { getAlchemyPaymasterAddress } from "./gas-manager.js";
 export { alchemyFeeEstimator } from "./middleware/feeEstimator.js";
 export type * from "./middleware/gasManager.js";
-export { alchemyGasManagerMiddleware } from "./middleware/gasManager.js";
+export {
+  alchemyGasManagerMiddleware,
+  alchemyGasAndPaymasterAndDataMiddleware,
+} from "./middleware/gasManager.js";
 export { alchemyUserOperationSimulator } from "./middleware/userOperationSimulator.js";
 export type * from "./schema.js";

package/src/middleware/gasManager.ts

@@ -1,8 +1,32 @@
-import type { ClientMiddlewareConfig } from "@aa-sdk/core";
-import { erc7677Middleware } from "@aa-sdk/core";
+import type {
+  ClientMiddlewareConfig,
+  ClientMiddlewareFn,
+  EntryPointVersion,
+  Multiplier,
+  UserOperationFeeOptions,
+  UserOperationOverrides,
+  UserOperationRequest,
+} from "@aa-sdk/core";
+import {
+  bypassPaymasterAndData,
+  ChainNotFoundError,
+  deepHexlify,
+  defaultGasEstimator,
+  erc7677Middleware,
+  filterUndefined,
+  isBigNumberish,
+  isMultiplier,
+  noopMiddleware,
+  resolveProperties,
+} from "@aa-sdk/core";
+import { fromHex, isHex, type Hex } from "viem";
+import type { AlchemySmartAccountClient } from "../client/smartAccountClient.js";
+import type { AlchemyTransport } from "../alchemyTransport.js";
+import { alchemyFeeEstimator } from "./feeEstimator.js";
 
 /**
- * Paymaster middleware factory that uses Alchemy's Gas Manager for sponsoring transactions.
+ * Paymaster middleware factory that uses Alchemy's Gas Manager for sponsoring
+ * transactions. Adheres to the ERC-7677 standardized communication protocol.
  *
  * @example
  *  ```ts
@@ -16,13 +40,217 @@ import { erc7677Middleware } from "@aa-sdk/core";
  * });
  * ```
  *
- * @param {string} policyId the policyId for Alchemy's gas manager
+ * @param {string | string[]} policyId the policyId (or list of policyIds) for Alchemy's gas manager
  * @returns {Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData">} partial client middleware configuration containing `dummyPaymasterAndData` and `paymasterAndData`
  */
 export function alchemyGasManagerMiddleware(
-  policyId: string
+  policyId: string | string[]
 ): Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData"> {
-  return erc7677Middleware<{ policyId: string }>({
+  return erc7677Middleware<{ policyId: string | string[] }>({
     context: { policyId: policyId },
   });
 }
+
+interface AlchemyGasAndPaymasterAndDataMiddlewareParams {
+  policyId: string | string[];
+  transport: AlchemyTransport;
+  gasEstimatorOverride?: ClientMiddlewareFn;
+  feeEstimatorOverride?: ClientMiddlewareFn;
+}
+
+/**
+ * Paymaster middleware factory that uses Alchemy's Gas Manager for sponsoring
+ * transactions. Uses Alchemy's custom `alchemy_requestGasAndPaymasterAndData`
+ * method instead of conforming to the standard ERC-7677 interface. Note that
+ * if you use `createAlchemySmartAccountClient`, this middleware is already
+ * used by default and you do not need to manually include it.
+ *
+ * @example
+ *  ```ts twoslash
+ * import { sepolia, alchemy, alchemyGasAndPaymasterAndDataMiddleware } from "@account-kit/infra";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const client = createSmartAccountClient({
+ *  transport: alchemy({ apiKey: "your-api-key" }),
+ *  chain: sepolia,
+ *  ...alchemyGasAndPaymasterAndDataMiddleware({
+ *    policyId: "policyId",
+ *    transport: alchemy({ apiKey: "your-api-key" }),
+ *  })
+ * });
+ * ```
+ *
+ * @param {AlchemyGasAndPaymasterAndDataMiddlewareParams} params configuration params
+ * @param {AlchemyGasAndPaymasterAndDataMiddlewareParams.policyId} params.policyId the policyId for Alchemy's gas manager
+ * @param {AlchemyGasAndPaymasterAndDataMiddlewareParams.transport} params.transport fallback transport to use for fee estimation when not using the paymaster
+ * @param {AlchemyGasAndPaymasterAndDataMiddlewareParams.gasEstimatorOverride} params.gasEstimatorOverride custom gas estimator middleware
+ * @param {AlchemyGasAndPaymasterAndDataMiddlewareParams.feeEstimatorOverride} params.feeEstimatorOverride custom fee estimator middleware
+ * @returns {Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData">} partial client middleware configuration containing `dummyPaymasterAndData` and `paymasterAndData`
+ */
+export function alchemyGasAndPaymasterAndDataMiddleware(
+  params: AlchemyGasAndPaymasterAndDataMiddlewareParams
+): Pick<
+  ClientMiddlewareConfig,
+  "dummyPaymasterAndData" | "feeEstimator" | "gasEstimator" | "paymasterAndData"
+> {
+  const { policyId, transport, gasEstimatorOverride, feeEstimatorOverride } =
+    params;
+  return {
+    dummyPaymasterAndData: async (uo, args) => {
+      if (
+        // No reason to generate dummy data if we are bypassing the paymaster.
+        bypassPaymasterAndData(args.overrides) ||
+        // When using alchemy_requestGasAndPaymasterAndData, there is generally no reason to generate dummy
+        // data. However, if the gas/feeEstimator is overriden, then this option should be enabled.
+        !(gasEstimatorOverride || feeEstimatorOverride)
+      ) {
+        return noopMiddleware(uo, args);
+      }
+
+      // Fall back to the default 7677 dummyPaymasterAndData middleware.
+      return alchemyGasManagerMiddleware(policyId).dummyPaymasterAndData!(
+        uo,
+        args
+      );
+    },
+    feeEstimator: (uo, args) => {
+      return feeEstimatorOverride
+        ? feeEstimatorOverride(uo, args)
+        : bypassPaymasterAndData(args.overrides)
+        ? alchemyFeeEstimator(transport)(uo, args)
+        : noopMiddleware(uo, args);
+    },
+    gasEstimator: (uo, args) => {
+      return gasEstimatorOverride
+        ? gasEstimatorOverride(uo, args)
+        : bypassPaymasterAndData(args.overrides)
+        ? defaultGasEstimator(args.client)(uo, args)
+        : noopMiddleware(uo, args);
+    },
+    paymasterAndData: async (
+      uo,
+      { account, client, feeOptions, overrides: overrides_ }
+    ) => {
+      if (!client.chain) {
+        throw new ChainNotFoundError();
+      }
+
+      const userOp = deepHexlify(await resolveProperties(uo));
+
+      const overrides: UserOperationOverrides = filterUndefined({
+        maxFeePerGas: overrideField(
+          "maxFeePerGas",
+          overrides_ as UserOperationOverrides,
+          feeOptions,
+          userOp
+        ),
+        maxPriorityFeePerGas: overrideField(
+          "maxPriorityFeePerGas",
+          overrides_ as UserOperationOverrides,
+          feeOptions,
+          userOp
+        ),
+        callGasLimit: overrideField(
+          "callGasLimit",
+          overrides_ as UserOperationOverrides,
+          feeOptions,
+          userOp
+        ),
+        verificationGasLimit: overrideField(
+          "verificationGasLimit",
+          overrides_ as UserOperationOverrides,
+          feeOptions,
+          userOp
+        ),
+        preVerificationGas: overrideField(
+          "preVerificationGas",
+          overrides_ as UserOperationOverrides,
+          feeOptions,
+          userOp
+        ),
+        ...(account.getEntryPoint().version === "0.7.0"
+          ? {
+              paymasterVerificationGasLimit: overrideField<"0.7.0">(
+                "paymasterVerificationGasLimit",
+                overrides_ as UserOperationOverrides<"0.7.0">,
+                feeOptions,
+                userOp
+              ),
+              paymasterPostOpGasLimit: overrideField<"0.7.0">(
+                "paymasterPostOpGasLimit",
+                overrides_ as UserOperationOverrides<"0.7.0">,
+                feeOptions,
+                userOp
+              ),
+            }
+          : {}),
+      });
+
+      const result = await (client as AlchemySmartAccountClient).request({
+        method: "alchemy_requestGasAndPaymasterAndData",
+        params: [
+          {
+            policyId,
+            entryPoint: account.getEntryPoint().address,
+            userOperation: userOp,
+            dummySignature: await account.getDummySignature(),
+            overrides,
+          },
+        ],
+      });
+
+      return {
+        ...uo,
+        ...result,
+      };
+    },
+  };
+}
+
+/**
+ * Utility function to override a field in the user operation request with the overrides or fee options
+ *
+ * @template {EntryPointVersion} TEntryPointVersion
+ * @param {keyof UserOperationFeeOptions<TEntryPointVersion>} field the field to override
+ * @param {UserOperationOverrides<TEntryPointVersion> | undefined} overrides the overrides object
+ * @param {UserOperationFeeOptions<TEntryPointVersion> | undefined} feeOptions the fee options object from the client
+ * @param {UserOperationRequest<TEntryPointVersion>} userOperation the user operation request
+ * @returns {Hex | Multiplier | undefined} 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;
+};

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.13.1-alpha.0";
+export const VERSION = "4.15.0";