@account-kit/infra 4.0.0-alpha.0

package/src/client/decorators/smartAccount.ts

@@ -0,0 +1,37 @@
+import type {
+  SendUserOperationParameters,
+  SmartContractAccount,
+  UserOperationContext,
+} from "@aa-sdk/core";
+import type { Chain, Client, Transport } from "viem";
+import { simulateUserOperationChanges } from "../../actions/simulateUserOperationChanges.js";
+import type { SimulateUserOperationAssetChangesResponse } from "../../actions/types.js";
+
+export type AlchemySmartAccountClientActions<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = {
+  simulateUserOperation: (
+    args: SendUserOperationParameters<TAccount, TContext>
+  ) => Promise<SimulateUserOperationAssetChangesResponse>;
+};
+
+export const alchemyActions: <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+) => AlchemySmartAccountClientActions<TAccount, TContext> = (client) => ({
+  simulateUserOperation: async (args) =>
+    simulateUserOperationChanges(client, args),
+});

package/src/client/internal/smartAccountClientFromRpc.ts

@@ -0,0 +1,121 @@
+import {
+  createSmartAccountClientFromExisting,
+  getDefaultUserOperationFeeOptions,
+  isSmartAccountWithSigner,
+  type SmartContractAccount,
+  type SmartContractAccountWithSigner,
+  type UserOperationContext,
+} from "@aa-sdk/core";
+import type { Chain, CustomTransport, Transport } from "viem";
+import { alchemyFeeEstimator } from "../../middleware/feeEstimator.js";
+import { alchemyGasManagerMiddleware } from "../../middleware/gasManager.js";
+import { alchemyUserOperationSimulator } from "../../middleware/userOperationSimulator.js";
+import { alchemyActions } from "../decorators/smartAccount.js";
+import type {
+  AlchemySmartAccountClient,
+  AlchemySmartAccountClientConfig,
+} from "../smartAccountClient.js";
+import type { ClientWithAlchemyMethods } from "../types.js";
+
+export type CreateAlchemySmartAccountClientFromRpcClient<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Omit<
+  AlchemySmartAccountClientConfig<Transport, Chain, TAccount, TContext>,
+  "rpcUrl" | "chain" | "apiKey" | "jwt"
+> & { client: ClientWithAlchemyMethods };
+
+export function getSignerTypeHeader<
+  TAccount extends SmartContractAccountWithSigner
+>(account: TAccount) {
+  return { "Alchemy-Aa-Sdk-Signer": account.getSigner().signerType };
+}
+
+/**
+ * Helper method meant to be used internally to create an alchemy smart account client
+ * from an existing Alchemy Rpc Client
+ *
+ * @param args configuration for the client
+ * @returns a smart account client configured to use Alchemy's RPC
+ */
+export function createAlchemySmartAccountClientFromRpcClient<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>(
+  args: CreateAlchemySmartAccountClientFromRpcClient<TAccount, TContext>
+): AlchemySmartAccountClient<
+  CustomTransport,
+  TChain,
+  TAccount,
+  Record<string, never>,
+  TContext
+>;
+
+export function createAlchemySmartAccountClientFromRpcClient({
+  opts,
+  account,
+  useSimulation,
+  gasManagerConfig,
+  feeEstimator,
+  gasEstimator,
+  customMiddleware,
+  signUserOperation,
+  client,
+}: CreateAlchemySmartAccountClientFromRpcClient): AlchemySmartAccountClient {
+  const feeOptions =
+    opts?.feeOptions ?? getDefaultUserOperationFeeOptions(client.chain);
+
+  const scaClient = createSmartAccountClientFromExisting({
+    account,
+    client,
+    type: "AlchemySmartAccountClient",
+    opts: {
+      ...opts,
+      feeOptions,
+    },
+    customMiddleware: async (struct, args) => {
+      if (isSmartAccountWithSigner(args.account)) {
+        client.updateHeaders(getSignerTypeHeader(args.account));
+      }
+
+      return customMiddleware ? customMiddleware(struct, args) : struct;
+    },
+    feeEstimator: feeEstimator ?? alchemyFeeEstimator(client),
+    userOperationSimulator: useSimulation
+      ? alchemyUserOperationSimulator(client)
+      : undefined,
+    gasEstimator,
+    ...(gasManagerConfig &&
+      alchemyGasManagerMiddleware(client, {
+        ...gasManagerConfig,
+        gasEstimationOptions: {
+          ...gasManagerConfig.gasEstimationOptions,
+          disableGasEstimation:
+            gasManagerConfig.gasEstimationOptions?.disableGasEstimation ??
+            false,
+          fallbackFeeDataGetter:
+            gasManagerConfig.gasEstimationOptions?.fallbackFeeDataGetter ??
+            feeEstimator,
+          fallbackGasEstimator:
+            gasManagerConfig.gasEstimationOptions?.fallbackGasEstimator ??
+            gasEstimator,
+        },
+      })),
+    signUserOperation,
+  }).extend(alchemyActions);
+
+  if (account && isSmartAccountWithSigner(account)) {
+    client.updateHeaders(getSignerTypeHeader(account));
+  }
+
+  return scaClient;
+}

package/src/client/isAlchemySmartAccountClient.ts

@@ -0,0 +1,19 @@
+import { isSmartAccountClient, type SmartContractAccount } from "@aa-sdk/core";
+import type { Chain, Client, Transport } from "viem";
+import type { AlchemySmartAccountClient } from "./smartAccountClient";
+
+export const isAlchemySmartAccountClient = <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+>(
+  client: Client<TTransport, TChain, TAccount>
+): client is AlchemySmartAccountClient<TTransport, TChain, TAccount> => {
+  // TODO: the goal of this check is to make sure that the client supports certain RPC methods
+  // we should probably do this by checking the client's transport and configured URL, since alchemy
+  // clients have to be RPC clients. this is difficult to do though because the transport might
+  // point to a proxy url :/
+  return isSmartAccountClient(client);
+};

package/src/client/rpcClient.ts

@@ -0,0 +1,50 @@
+import {
+  createBundlerClient,
+  type ConnectionConfig,
+  type NoUndefined,
+} from "@aa-sdk/core";
+import { http, type Chain, type HttpTransportConfig } from "viem";
+import { AlchemyChainSchema } from "../schema.js";
+import { VERSION } from "../version.js";
+import type { ClientWithAlchemyMethods } from "./types.js";
+
+export const createAlchemyPublicRpcClient = ({
+  chain: chain_,
+  connectionConfig,
+  fetchOptions = {},
+}: {
+  connectionConfig: ConnectionConfig;
+  chain: Chain;
+  fetchOptions?: NoUndefined<HttpTransportConfig["fetchOptions"]>;
+}): ClientWithAlchemyMethods => {
+  const chain = AlchemyChainSchema.parse(chain_);
+
+  const rpcUrl =
+    connectionConfig.rpcUrl == null
+      ? `${chain.rpcUrls.alchemy.http[0]}/${connectionConfig.apiKey ?? ""}`
+      : connectionConfig.rpcUrl;
+
+  fetchOptions.headers = {
+    ...fetchOptions.headers,
+    "Alchemy-AA-Sdk-Version": VERSION,
+  };
+
+  if (connectionConfig.jwt != null) {
+    fetchOptions.headers = {
+      ...fetchOptions.headers,
+      Authorization: `Bearer ${connectionConfig.jwt}`,
+    };
+  }
+
+  return createBundlerClient({
+    chain: chain,
+    transport: http(rpcUrl, { fetchOptions }),
+  }).extend(() => ({
+    updateHeaders(newHeaders: HeadersInit) {
+      fetchOptions.headers = {
+        ...fetchOptions.headers,
+        ...newHeaders,
+      };
+    },
+  }));
+};

package/src/client/smartAccountClient.ts

@@ -0,0 +1,153 @@
+import {
+  type Prettify,
+  type SmartAccountClient,
+  type SmartAccountClientActions,
+  type SmartAccountClientConfig,
+  type SmartAccountClientRpcSchema,
+  type SmartContractAccount,
+  type UserOperationContext,
+} from "@aa-sdk/core";
+import { type Chain, type Transport } from "viem";
+import { getDefaultUserOperationFeeOptions } from "../defaults.js";
+import { type AlchemyGasManagerConfig } from "../middleware/gasManager.js";
+import { AlchemyProviderConfigSchema } from "../schema.js";
+import type { AlchemyProviderConfig } from "../type.js";
+import type { AlchemySmartAccountClientActions } from "./decorators/smartAccount.js";
+import { createAlchemySmartAccountClientFromRpcClient } from "./internal/smartAccountClientFromRpc.js";
+import { createAlchemyPublicRpcClient } from "./rpcClient.js";
+import type { AlchemyRpcSchema } from "./types.js";
+
+// #region AlchemySmartAccountClientConfig
+export type AlchemySmartAccountClientConfig<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = {
+  account?: account;
+  useSimulation?: boolean;
+  gasManagerConfig?: AlchemyGasManagerConfig;
+} & AlchemyProviderConfig &
+  Pick<
+    SmartAccountClientConfig<transport, chain, account, context>,
+    "customMiddleware" | "feeEstimator" | "gasEstimator" | "signUserOperation"
+  >;
+// #endregion AlchemySmartAccountClientConfig
+
+export type BaseAlchemyActions<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = SmartAccountClientActions<chain, account, context> &
+  AlchemySmartAccountClientActions<account, context>;
+
+export type AlchemySmartAccountClient_Base<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  actions extends Record<string, unknown> = Record<string, unknown>,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Prettify<
+  SmartAccountClient<
+    transport,
+    chain,
+    account,
+    actions & BaseAlchemyActions<chain, account, context>,
+    [...SmartAccountClientRpcSchema, ...AlchemyRpcSchema],
+    context
+  >
+>;
+
+export type AlchemySmartAccountClient<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  actions extends Record<string, unknown> = Record<string, unknown>,
+  context extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = Prettify<
+  AlchemySmartAccountClient_Base<transport, chain, account, actions, context>
+>;
+
+export function createAlchemySmartAccountClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+>({
+  account,
+  gasManagerConfig,
+  useSimulation,
+  feeEstimator,
+  customMiddleware,
+  gasEstimator,
+  signUserOperation,
+  ...config_
+}: AlchemySmartAccountClientConfig<
+  TTransport,
+  TChain,
+  TAccount,
+  TContext
+>): AlchemySmartAccountClient<
+  TTransport,
+  TChain,
+  TAccount,
+  Record<string, never>,
+  TContext
+>;
+
+export function createAlchemySmartAccountClient({
+  account,
+  gasManagerConfig,
+  useSimulation,
+  feeEstimator,
+  customMiddleware,
+  gasEstimator,
+  signUserOperation,
+  ...config_
+}: AlchemySmartAccountClientConfig): AlchemySmartAccountClient {
+  const config = AlchemyProviderConfigSchema.parse(config_);
+  const { chain, opts, ...connectionConfig } = config;
+
+  const client = createAlchemyPublicRpcClient({
+    chain,
+    connectionConfig,
+  });
+
+  const feeOptions =
+    opts?.feeOptions ?? getDefaultUserOperationFeeOptions(chain);
+
+  return createAlchemySmartAccountClientFromRpcClient({
+    client,
+    account,
+    opts: {
+      ...opts,
+      feeOptions,
+    },
+    gasManagerConfig,
+    useSimulation,
+    feeEstimator,
+    customMiddleware,
+    gasEstimator,
+    signUserOperation,
+  });
+}

package/src/client/types.ts

@@ -0,0 +1,89 @@
+import { type BundlerClient, type UserOperationRequest } from "@aa-sdk/core";
+import type { Address, Hex, HttpTransport } from "viem";
+import type {
+  SimulateUserOperationAssetChangesRequest,
+  SimulateUserOperationAssetChangesResponse,
+} from "../actions/types";
+import type {
+  RequestGasAndPaymasterAndDataOverrides,
+  RequestGasAndPaymasterAndDataResponse,
+  RequestPaymasterAndDataResponse,
+} from "../middleware/gasManager";
+
+export type AlchemyRpcSchema = [
+  {
+    Method: "alchemy_requestPaymasterAndData";
+    Parameters: [
+      {
+        policyId: string;
+        entryPoint: Address;
+        userOperation: UserOperationRequest;
+      }
+    ];
+    ReturnType: RequestPaymasterAndDataResponse;
+  },
+  {
+    Method: "alchemy_requestGasAndPaymasterAndData";
+    Parameters: [
+      {
+        policyId: string;
+        entryPoint: Address;
+        userOperation: UserOperationRequest;
+        dummySignature: Hex;
+        overrides?: RequestGasAndPaymasterAndDataOverrides;
+      }
+    ];
+    ReturnType: RequestGasAndPaymasterAndDataResponse;
+  },
+  {
+    Method: "alchemy_simulateUserOperationAssetChanges";
+    Parameters: SimulateUserOperationAssetChangesRequest;
+    ReturnType: SimulateUserOperationAssetChangesResponse;
+  },
+  {
+    Method: "rundler_maxPriorityFeePerGas";
+    Parameters: [];
+    ReturnType: UserOperationRequest["maxPriorityFeePerGas"];
+  }
+];
+
+export type ClientWithAlchemyMethods = BundlerClient<HttpTransport> & {
+  request: BundlerClient<HttpTransport>["request"] &
+    {
+      request(args: {
+        method: "alchemy_requestPaymasterAndData";
+        params: [
+          {
+            policyId: string;
+            entryPoint: Address;
+            userOperation: UserOperationRequest;
+          }
+        ];
+      }): Promise<RequestPaymasterAndDataResponse>;
+
+      request(args: {
+        method: "alchemy_requestGasAndPaymasterAndData";
+        params: [
+          {
+            policyId: string;
+            entryPoint: Address;
+            userOperation: UserOperationRequest;
+            dummySignature: Hex;
+            overrides?: RequestGasAndPaymasterAndDataOverrides;
+          }
+        ];
+      }): Promise<RequestGasAndPaymasterAndDataResponse>;
+
+      request(args: {
+        method: "alchemy_simulateUserOperationAssetChanges";
+        params: SimulateUserOperationAssetChangesRequest;
+      }): Promise<SimulateUserOperationAssetChangesResponse>;
+
+      request(args: {
+        method: "rundler_maxPriorityFeePerGas";
+        params: [];
+      }): Promise<UserOperationRequest["maxPriorityFeePerGas"]>;
+    }["request"];
+} & {
+  updateHeaders: (headers: HeadersInit) => void;
+};

package/src/defaults.ts

@@ -0,0 +1,34 @@
+import {
+  arbitrum,
+  arbitrumGoerli,
+  arbitrumSepolia,
+  optimism,
+  optimismGoerli,
+  optimismSepolia,
+  type UserOperationFeeOptions,
+} from "@aa-sdk/core";
+import type { Chain } from "viem";
+
+export const getDefaultUserOperationFeeOptions = (
+  chain: Chain
+): UserOperationFeeOptions => {
+  const feeOptions: UserOperationFeeOptions = {
+    maxFeePerGas: { multiplier: 1.5 },
+    maxPriorityFeePerGas: { multiplier: 1.05 },
+  };
+
+  if (
+    new Set<number>([
+      arbitrum.id,
+      arbitrumGoerli.id,
+      arbitrumSepolia.id,
+      optimism.id,
+      optimismGoerli.id,
+      optimismSepolia.id,
+    ]).has(chain.id)
+  ) {
+    feeOptions.preVerificationGas = { multiplier: 1.05 };
+  }
+
+  return feeOptions;
+};

package/src/errors/base.ts

@@ -0,0 +1,7 @@
+import { BaseError as CoreBaseError } from "@aa-sdk/core";
+import { VERSION } from "../version.js";
+
+export abstract class BaseError extends CoreBaseError {
+  // This version could be different from the aa-core version so we overwrite this here.
+  override version = VERSION;
+}

package/src/errors/rpcUrl.ts

@@ -0,0 +1,20 @@
+import { type ConnectionConfig } from "@aa-sdk/core";
+import { type Chain } from "viem";
+import { BaseError } from "./base.js";
+
+export class InvalidRpcUrlError extends BaseError {
+  override name = "InvalidRpcUrlError";
+
+  constructor(context: { chain: Chain; connectionConfig: ConnectionConfig }) {
+    super(["RPC Url not provided"].join("\n"), {
+      details: [
+        "If you are passing in a chain object and only an API key, make sure to use the chain object exported from @aa-sdk/core",
+        "Otherwise, pass in an RPC URL directly",
+      ].join("\n"),
+      metaMessages: [
+        `Chain: ${JSON.stringify(context.chain, null, 2)}`,
+        `ConnectionConfig: ${JSON.stringify(context.connectionConfig)}`,
+      ],
+    });
+  }
+}

package/src/gas-manager.ts

@@ -0,0 +1,53 @@
+import type { Address, Chain } from "viem";
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  mainnet,
+  sepolia,
+  optimism,
+  optimismSepolia,
+  polygon,
+  polygonAmoy,
+  polygonMumbai,
+  fraxtal,
+  fraxtalSepolia,
+  zora,
+  zoraSepolia,
+} from "@aa-sdk/core";
+
+export const AlchemyPaymasterAddressV3 =
+  "0x4f84a207A80c39E9e8BaE717c1F25bA7AD1fB08F";
+export const AlchemyPaymasterAddressV2 =
+  "0x4Fd9098af9ddcB41DA48A1d78F91F1398965addc";
+export const ArbSepoliaPaymasterAddress =
+  "0x0804Afe6EEFb73ce7F93CD0d5e7079a5a8068592";
+export const AlchemyPaymasterAddressV1 =
+  "0xc03aac639bb21233e0139381970328db8bceeb67";
+
+export const getAlchemyPaymasterAddress = (chain: Chain): Address => {
+  switch (chain.id) {
+    case polygonAmoy.id:
+    case optimismSepolia.id:
+    case baseSepolia.id:
+    case zora.id:
+    case zoraSepolia.id:
+    case fraxtal.id:
+    case fraxtalSepolia.id:
+      return AlchemyPaymasterAddressV3;
+    case mainnet.id:
+    case arbitrum.id:
+    case optimism.id:
+    case polygon.id:
+    case base.id:
+      return AlchemyPaymasterAddressV2;
+    case arbitrumSepolia.id:
+      return ArbSepoliaPaymasterAddress;
+    case sepolia.id:
+    case polygonMumbai.id:
+      return AlchemyPaymasterAddressV1;
+    default:
+      throw new Error(`Unsupported chain: ${chain}`);
+  }
+};

package/src/index.ts

@@ -0,0 +1,24 @@
+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 "./client/decorators/alchemyEnhancedApis.js";
+export { alchemyEnhancedApiActions } from "./client/decorators/alchemyEnhancedApis.js";
+export type * from "./client/decorators/smartAccount.js";
+export { alchemyActions } from "./client/decorators/smartAccount.js";
+export { createAlchemySmartAccountClientFromRpcClient as createAlchemySmartAccountClientFromExisting } from "./client/internal/smartAccountClientFromRpc.js";
+export { isAlchemySmartAccountClient } from "./client/isAlchemySmartAccountClient.js";
+export type * from "./client/rpcClient.js";
+export { createAlchemyPublicRpcClient } from "./client/rpcClient.js";
+export type * from "./client/smartAccountClient.js";
+export { createAlchemySmartAccountClient } from "./client/smartAccountClient.js";
+export type * from "./client/types.js";
+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 { alchemyUserOperationSimulator } from "./middleware/userOperationSimulator.js";
+export type * from "./schema.js";
+export { AlchemyProviderConfigSchema } from "./schema.js";
+export type { AlchemyProviderConfig } from "./type.js";

package/src/middleware/feeEstimator.ts

@@ -0,0 +1,40 @@
+import type { ClientMiddlewareFn } from "@aa-sdk/core";
+import { applyUserOpOverrideOrFeeOption } from "@aa-sdk/core";
+import type { ClientWithAlchemyMethods } from "../client/types";
+
+export const alchemyFeeEstimator: <C extends ClientWithAlchemyMethods>(
+  client: C
+) => ClientMiddlewareFn =
+  (client) =>
+  async (struct, { overrides, feeOptions }) => {
+    let [block, maxPriorityFeePerGasEstimate] = await Promise.all([
+      client.getBlock({ blockTag: "latest" }),
+      // it is a fair assumption that if someone is using this Alchemy Middleware, then they are using Alchemy RPC
+      client.request({
+        method: "rundler_maxPriorityFeePerGas",
+        params: [],
+      }),
+    ]);
+
+    const baseFeePerGas = block.baseFeePerGas;
+    if (baseFeePerGas == null) {
+      throw new Error("baseFeePerGas is null");
+    }
+
+    const maxPriorityFeePerGas = applyUserOpOverrideOrFeeOption(
+      maxPriorityFeePerGasEstimate,
+      overrides?.maxPriorityFeePerGas,
+      feeOptions?.maxPriorityFeePerGas
+    );
+    const maxFeePerGas = applyUserOpOverrideOrFeeOption(
+      baseFeePerGas + BigInt(maxPriorityFeePerGas),
+      overrides?.maxFeePerGas,
+      feeOptions?.maxFeePerGas
+    );
+
+    return {
+      ...struct,
+      maxPriorityFeePerGas,
+      maxFeePerGas,
+    };
+  };