@account-kit/infra 4.30.0 → 4.31.0

package/src/client/smartAccountClient.ts

@@ -12,7 +12,7 @@ import {
   type SmartContractAccountWithSigner,
   type UserOperationContext,
 } from "@aa-sdk/core";
-import { type Chain } from "viem";
+import { type Address, type Chain } from "viem";
 import {
   alchemy,
   convertHeadersToObject,
@@ -48,6 +48,13 @@ export type AlchemySmartAccountClientConfig<
   account?: account;
   useSimulation?: boolean;
   policyId?: string | string[];
+  policyToken?: {
+    address: Address;
+    approvalMode?: "NONE" | "PERMIT";
+    maxTokenAmount?: bigint;
+    erc20Name?: string;
+    version?: string;
+  };
 } & Pick<
   SmartAccountClientConfig<AlchemyTransport, chain, account, context>,
   | "customMiddleware"
@@ -163,6 +170,7 @@ export function createAlchemySmartAccountClient(
     ...(config.policyId
       ? alchemyGasAndPaymasterAndDataMiddleware({
           policyId: config.policyId,
+          policyToken: config.policyToken,
           transport: config.transport,
           gasEstimatorOverride: config.gasEstimator,
           feeEstimatorOverride: config.feeEstimator,

package/src/gas-manager.ts

@@ -1,4 +1,4 @@
-import type { Address, Chain } from "viem";
+import type { Address, Chain, Hex } from "viem";
 import {
   arbitrum,
   arbitrumSepolia,
@@ -66,3 +66,38 @@ export const getAlchemyPaymasterAddress = (chain: Chain): Address => {
       throw new Error(`Unsupported chain: ${chain}`);
   }
 };
+
+export const PermitTypes = {
+  EIP712Domain: [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+  ],
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+  ],
+} as const;
+
+export const EIP712NoncesAbi = [
+  "function nonces(address owner) external view returns (uint)",
+] as const;
+
+export type PermitMessage = {
+  owner: Hex;
+  spender: Hex;
+  value: bigint;
+  nonce: bigint;
+  deadline: bigint;
+};
+
+export type PermitDomain = {
+  name: string;
+  version: string;
+  chainId: bigint;
+  verifyingContract: Hex;
+};

package/src/index.ts

@@ -44,6 +44,8 @@ export {
   openlootSepolia,
   gensynTestnet,
   riseTestnet,
+  storyMainnet,
+  storyAeneid,
 } from "./chains.js";
 export type * from "./client/decorators/alchemyEnhancedApis.js";
 export { alchemyEnhancedApiActions } from "./client/decorators/alchemyEnhancedApis.js";

package/src/middleware/gasManager.ts

@@ -1,8 +1,11 @@
 import type {
+  Address,
   ClientMiddlewareConfig,
   ClientMiddlewareFn,
   EntryPointVersion,
+  Erc7677Client,
   Multiplier,
+  SmartContractAccount,
   UserOperationFeeOptions,
   UserOperationOverrides,
   UserOperationRequest,
@@ -20,11 +23,33 @@ import {
   noopMiddleware,
   resolveProperties,
 } from "@aa-sdk/core";
-import { fromHex, isHex, type Hex } from "viem";
+import {
+  fromHex,
+  isHex,
+  toHex,
+  type Hex,
+  encodeAbiParameters,
+  encodeFunctionData,
+  parseAbi,
+  maxUint256,
+  sliceHex,
+} from "viem";
 import type { AlchemySmartAccountClient } from "../client/smartAccountClient.js";
 import type { AlchemyTransport } from "../alchemyTransport.js";
 import { alchemyFeeEstimator } from "./feeEstimator.js";
+import type { RequestGasAndPaymasterAndDataRequest } from "../actions/types.js";
+import { PermitTypes, EIP712NoncesAbi } from "../gas-manager.js";
+import type { PermitMessage, PermitDomain } from "../gas-manager.js";
+import type { MiddlewareClient } from "../../../../aa-sdk/core/dist/types/middleware/actions.js";
 
+type Context = {
+  policyId: string | string[];
+  erc20Context?: {
+    tokenAddress: Address;
+    maxTokenAmount?: BigInt;
+    permit?: Hex;
+  };
+};
 /**
  * Paymaster middleware factory that uses Alchemy's Gas Manager for sponsoring
  * transactions. Adheres to the ERC-7677 standardized communication protocol.
@@ -41,24 +66,80 @@ import { alchemyFeeEstimator } from "./feeEstimator.js";
  * });
  * ```
  *
- * @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`
+ * @param {string | string[]} policyId - The policyId (or list of policyIds) for Alchemy's gas manager
+ * @param {PolicyToken | undefined} policyToken - The policy token configuration
+ * @returns {Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData">} Partial client middleware configuration containing `dummyPaymasterAndData` and `paymasterAndData`
  */
 export function alchemyGasManagerMiddleware(
-  policyId: string | string[]
-): Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData"> {
-  return erc7677Middleware<{ policyId: string | string[] }>({
-    context: { policyId: policyId },
-  });
+  policyId: string | string[],
+  policyToken?: PolicyToken
+): Required<
+  Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData">
+> {
+  const buildContext = async (
+    uo: Parameters<ClientMiddlewareFn>[0],
+    args: Parameters<ClientMiddlewareFn>[1]
+  ): Promise<Context> => {
+    const context: Context = { policyId };
+
+    const { account, client } = args;
+    if (!client.chain) {
+      throw new ChainNotFoundError();
+    }
+
+    if (policyToken !== undefined) {
+      const userOp = await deepHexlify(await resolveProperties(uo));
+      context.erc20Context = {
+        tokenAddress: policyToken.address,
+        ...(policyToken.maxTokenAmount
+          ? { maxTokenAmount: policyToken.maxTokenAmount }
+          : {}),
+      };
+
+      if (policyToken.approvalMode === "PERMIT") {
+        context.erc20Context.permit = await generateSignedPermit(
+          userOp,
+          client as AlchemySmartAccountClient,
+          account,
+          policyId,
+          policyToken
+        );
+      }
+    }
+
+    return context;
+  };
+  return {
+    dummyPaymasterAndData: async (uo, args) => {
+      const context = await buildContext(uo, args);
+      const baseMiddleware = erc7677Middleware({ context });
+      return baseMiddleware.dummyPaymasterAndData(uo, args);
+    },
+
+    paymasterAndData: async (uo, args) => {
+      const context = await buildContext(uo, args);
+      const baseMiddleware = erc7677Middleware({ context });
+      return baseMiddleware.paymasterAndData(uo, args);
+    },
+  };
 }
 
 interface AlchemyGasAndPaymasterAndDataMiddlewareParams {
   policyId: string | string[];
+  policyToken?: PolicyToken;
   transport: AlchemyTransport;
   gasEstimatorOverride?: ClientMiddlewareFn;
   feeEstimatorOverride?: ClientMiddlewareFn;
 }
 
+export type PolicyToken = {
+  address: Address;
+  maxTokenAmount?: bigint;
+  approvalMode?: "NONE" | "PERMIT";
+  erc20Name?: string;
+  version?: string;
+};
+
 /**
  * Paymaster middleware factory that uses Alchemy's Gas Manager for sponsoring
  * transactions. Uses Alchemy's custom `alchemy_requestGasAndPaymasterAndData`
@@ -86,7 +167,7 @@ interface AlchemyGasAndPaymasterAndDataMiddlewareParams {
  * @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`
+ * @returns {Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "feeEstimator" | "gasEstimator" | "paymasterAndData">} partial client middleware configuration containing `dummyPaymasterAndData`, `feeEstimator`, `gasEstimator`, and `paymasterAndData`
  */
 export function alchemyGasAndPaymasterAndDataMiddleware(
   params: AlchemyGasAndPaymasterAndDataMiddlewareParams
@@ -94,8 +175,13 @@ export function alchemyGasAndPaymasterAndDataMiddleware(
   ClientMiddlewareConfig,
   "dummyPaymasterAndData" | "feeEstimator" | "gasEstimator" | "paymasterAndData"
 > {
-  const { policyId, transport, gasEstimatorOverride, feeEstimatorOverride } =
-    params;
+  const {
+    policyId,
+    policyToken,
+    transport,
+    gasEstimatorOverride,
+    feeEstimatorOverride,
+  } = params;
   return {
     dummyPaymasterAndData: async (uo, args) => {
       if (
@@ -109,10 +195,10 @@ export function alchemyGasAndPaymasterAndDataMiddleware(
       }
 
       // Fall back to the default 7677 dummyPaymasterAndData middleware.
-      return alchemyGasManagerMiddleware(policyId).dummyPaymasterAndData!(
-        uo,
-        args
-      );
+      return alchemyGasManagerMiddleware(
+        policyId,
+        policyToken
+      ).dummyPaymasterAndData(uo, args);
     },
     feeEstimator: (uo, args) => {
       return feeEstimatorOverride
@@ -188,6 +274,26 @@ export function alchemyGasAndPaymasterAndDataMiddleware(
           : {}),
       });
 
+      let erc20Context: RequestGasAndPaymasterAndDataRequest[0]["erc20Context"] =
+        undefined;
+      if (policyToken !== undefined) {
+        erc20Context = {
+          tokenAddress: policyToken.address,
+          ...(policyToken.maxTokenAmount
+            ? { maxTokenAmount: policyToken.maxTokenAmount }
+            : {}),
+        };
+        if (policyToken.approvalMode === "PERMIT") {
+          erc20Context.permit = await generateSignedPermit(
+            userOp,
+            client,
+            account,
+            policyId,
+            policyToken
+          );
+        }
+      }
+
       const result = await (client as AlchemySmartAccountClient).request({
         method: "alchemy_requestGasAndPaymasterAndData",
         params: [
@@ -197,6 +303,11 @@ export function alchemyGasAndPaymasterAndDataMiddleware(
             userOperation: userOp,
             dummySignature: await account.getDummySignature(),
             overrides,
+            ...(erc20Context
+              ? {
+                  erc20Context,
+                }
+              : {}),
           },
         ],
       });
@@ -256,3 +367,101 @@ const overrideField = <
   }
   return undefined;
 };
+
+/**
+ * Utility function to generate a signed Permit for erc20 transaction
+ *
+ * @param {UserOperationRequest<TEntryPointVersion>} userOp - The user operation request
+ * @param {MiddlewareClient} client - The Alchemy smart account client
+ * @param {TAccount} account - The smart account instance
+ * @param {string | string[]} policyId - The policy ID or array of policy IDs
+ * @param {PolicyToken} policyToken - The policy token configuration
+ * @param {Address} policyToken.address - ERC20 contract addressya
+ * @param {bigint} [policyToken.maxTokenAmount] - Optional ERC20 token limit
+ * @param {"NONE" | "PERMIT"} [policyToken.approvalMode] - ERC20 approve mode
+ * @param {string} [policyToken.erc20Name] - EIP2612 specified ERC20 contract name
+ * @param {string} [policyToken.version] - EIP2612 specified ERC20 contract version
+ * @returns {Promise<Hex>} Returns a Promise containing the signed EIP2612 permit
+ */
+const generateSignedPermit = async <
+  TAccount extends SmartContractAccount,
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+>(
+  userOp: UserOperationRequest<TEntryPointVersion>,
+  client: MiddlewareClient,
+  account: TAccount,
+  policyId: string | string[],
+  policyToken: {
+    address: Address;
+    maxTokenAmount?: bigint;
+    approvalMode?: "NONE" | "PERMIT";
+    erc20Name?: string;
+    version?: string;
+  }
+): Promise<Hex> => {
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+  if (!policyToken.erc20Name || !policyToken.version) {
+    throw new Error("erc20Name or version is missing");
+  }
+  // get a paymaster address
+  const maxAmountToken = policyToken.maxTokenAmount || maxUint256;
+  const paymasterData = await (client as Erc7677Client).request({
+    method: "pm_getPaymasterStubData",
+    params: [
+      userOp,
+      account.getEntryPoint().address,
+      toHex(client.chain.id),
+      {
+        policyId: Array.isArray(policyId) ? policyId[0] : policyId,
+      },
+    ],
+  });
+
+  const paymasterAddress = paymasterData.paymaster
+    ? paymasterData.paymaster
+    : paymasterData.paymasterAndData
+    ? sliceHex(paymasterData.paymasterAndData, 0, 20)
+    : undefined;
+
+  if (paymasterAddress === undefined || paymasterAddress === "0x") {
+    throw new Error("no paymaster contract address available");
+  }
+  const deadline = maxUint256;
+  const { data } = await client.call({
+    to: policyToken.address,
+    data: encodeFunctionData({
+      abi: parseAbi(EIP712NoncesAbi),
+      functionName: "nonces",
+      args: [account.address],
+    }),
+  });
+  if (!data) {
+    throw new Error("No nonces returned from erc20 contract call");
+  }
+
+  const typedPermitData = {
+    types: PermitTypes,
+    primaryType: "Permit" as const,
+    domain: {
+      name: policyToken.erc20Name ?? "",
+      version: policyToken.version ?? "",
+      chainId: BigInt(client.chain.id),
+      verifyingContract: policyToken.address,
+    } satisfies PermitDomain,
+    message: {
+      owner: account.address,
+      spender: paymasterAddress,
+      value: maxAmountToken,
+      nonce: BigInt(data),
+      deadline,
+    } satisfies PermitMessage,
+  } as const;
+
+  const signedPermit = await account.signTypedData(typedPermitData);
+  return encodeAbiParameters(
+    [{ type: "uint256" }, { type: "uint256" }, { type: "bytes" }],
+    [maxAmountToken, deadline, signedPermit]
+  );
+};

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.30.0";
+export const VERSION = "4.31.0";