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

package/src/client/internal/smartAccountClientFromRpc.ts

@@ -17,7 +17,7 @@ import type {
 } from "../smartAccountClient.js";
 import type { ClientWithAlchemyMethods } from "../types.js";
 
-export type CreateAlchemySmartAccountClientFromRpcClient<
+export type CreateAlchemySmartAccountClientFromRpcClientParams<
   TAccount extends SmartContractAccount | undefined =
     | SmartContractAccount
     | undefined,
@@ -51,7 +51,7 @@ export function createAlchemySmartAccountClientFromRpcClient<
     | UserOperationContext
     | undefined
 >(
-  args: CreateAlchemySmartAccountClientFromRpcClient<TAccount, TContext>
+  args: CreateAlchemySmartAccountClientFromRpcClientParams<TAccount, TContext>
 ): AlchemySmartAccountClient<
   CustomTransport,
   TChain,
@@ -60,17 +60,37 @@ export function createAlchemySmartAccountClientFromRpcClient<
   TContext
 >;
 
-export function createAlchemySmartAccountClientFromRpcClient({
-  opts,
-  account,
-  useSimulation,
-  gasManagerConfig,
-  feeEstimator,
-  gasEstimator,
-  customMiddleware,
-  signUserOperation,
-  client,
-}: CreateAlchemySmartAccountClientFromRpcClient): AlchemySmartAccountClient {
+/**
+ * Creates an AlchemySmartAccountClient using the provided RPC client configuration, including options, account, simulation settings, gas management, fee estimation, middleware and user operation signing.
+ *
+ * @example
+ * ```ts
+ * import { createAlchemySmartAccountClientFromRpcClient, createAlchemyPublicRpcClient } from "@account-kit/infra";
+ *
+ * const client = createAlchemyPublicRpcClient(...);
+ * const scaClient = createAlchemySmartAccountClientFromRpcClient({
+ *  client,
+ *  ...
+ * });
+ * ```
+ *
+ * @param {CreateAlchemySmartAccountClientFromRpcClientParams} args The configuration object containing all required parameters
+ * @returns {AlchemySmartAccountClient} An instance of AlchemySmartAccountClient
+ */
+export function createAlchemySmartAccountClientFromRpcClient(
+  args: CreateAlchemySmartAccountClientFromRpcClientParams
+): AlchemySmartAccountClient {
+  const {
+    opts,
+    account,
+    useSimulation,
+    gasManagerConfig,
+    feeEstimator,
+    gasEstimator,
+    customMiddleware,
+    signUserOperation,
+    client,
+  } = args;
   const feeOptions =
     opts?.feeOptions ?? getDefaultUserOperationFeeOptions(client.chain);
 

package/src/client/isAlchemySmartAccountClient.ts

@@ -2,6 +2,21 @@ import { isSmartAccountClient, type SmartContractAccount } from "@aa-sdk/core";
 import type { Chain, Client, Transport } from "viem";
 import type { AlchemySmartAccountClient } from "./smartAccountClient";
 
+/**
+ * Checks if a given client is an Alchemy Smart Account Client. The goal of this check is to ensure that the client supports certain RPC methods.
+ *
+ * @example
+ * ```ts
+ * import { isAlchemySmartAccountClient } from "@account-kit/infra";
+ *
+ * if (isAlchemySmartAccountClient(client)) {
+ *  // do things with the client as an Alchemy Smart Account Client
+ * }
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance to be checked
+ * @returns {boolean} `true` if the client is an Alchemy Smart Account Client, otherwise `false`
+ */
 export const isAlchemySmartAccountClient = <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/client/rpcClient.ts

@@ -8,6 +8,28 @@ import { AlchemyChainSchema } from "../schema.js";
 import { VERSION } from "../version.js";
 import type { ClientWithAlchemyMethods } from "./types.js";
 
+/**
+ * Creates an Alchemy public RPC client with the provided chain, connection configuration, and optional fetch options. The client has alchemy methods and can dynamically update HTTP headers.
+ *
+ * @example
+ * ```ts
+ * import { createAlchemyPublicRpcClient } from "@account-kit/infra";
+ * import { sepolia } from "@account-kit/infra";
+ *
+ * const client = createAlchemyPublicRpcClient({
+ *  chain: sepolia,
+ *  connectionConfig: {
+ *    apiKey: "your-api-key",
+ *  }
+ * });
+ * ```
+ *
+ * @param {{connectionConfig: ConnectionConfig,chain: Chain,fetchOptions?: NoUndefined<HttpTransportConfig["fetchOptions"]>}} params The parameters for creating the Alchemy public RPC client
+ * @param {ConnectionConfig} params.connectionConfig The connection configuration containing the RPC URL and API key
+ * @param {Chain} params.chain The blockchain chain configuration
+ * @param {NoUndefined<HttpTransportConfig["fetchOptions"]>} [params.fetchOptions] Optional fetch configuration for HTTP transport
+ * @returns {ClientWithAlchemyMethods} A client object tailored with Alchemy methods and capabilities to interact with the blockchain
+ */
 export const createAlchemyPublicRpcClient = ({
   chain: chain_,
   connectionConfig,

package/src/client/smartAccountClient.ts

@@ -115,6 +115,23 @@ export function createAlchemySmartAccountClient<
   TContext
 >;
 
+/**
+ * Creates an Alchemy smart account client using the provided configuration options, including account details, gas manager configuration, and custom middleware.
+ *
+ * @example
+ * ```ts
+ * import { createAlchemySmartAccountClient } from "@account-kit/infra";
+ * import { sepolia } from "@account-kit/infra/chain";
+ *
+ * const client = createAlchemySmartAccountClient({
+ *  chain: sepolia,
+ *  apiKey: "your-api-key",
+ * });
+ * ```
+ *
+ * @param {AlchemySmartAccountClientConfig} config The configuration for creating the Alchemy smart account client
+ * @returns {AlchemySmartAccountClient} An instance of `AlchemySmartAccountClient` configured based on the provided options
+ */
 export function createAlchemySmartAccountClient({
   account,
   gasManagerConfig,

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,29 @@
 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,
+} 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

@@ -145,7 +145,7 @@ export interface AlchemyGasEstimationOptions {
 }
 
 /**
- * dummy paymaster and data middleware for the alchemy gas manager
+ * Dummy paymaster and data middleware for the alchemy gas manager
  *
  * @template {ClientWithAlchemyMethods} C
  * @param client client with alchemy methods

package/src/middleware/userOperationSimulator.ts

@@ -5,6 +5,25 @@ import {
 } 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 {

package/src/schema.ts

@@ -2,23 +2,15 @@ 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;
+  return chain_.rpcUrls.alchemy != null;
 }, "chain must include an alchemy rpc url. See `createAlchemyChain` or use the `AlchemyChainMap` exported from `@aa-sdk/core`");
 
 export const AlchemyProviderConfigSchema = ConnectionConfigSchema.and(

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.2";