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

package/src/chains.ts

@@ -1,5 +1,51 @@
 import type { Chain } from "viem";
 
+import { defineChain } from "viem";
+import {
+  arbitrum as vab,
+  arbitrumGoerli as vabg,
+  arbitrumSepolia as vabs,
+  base as vbase,
+  baseGoerli as vbaseg,
+  baseSepolia as vbases,
+  fraxtal as vfrax,
+  goerli as vgo,
+  mainnet as vmain,
+  optimism as vop,
+  optimismGoerli as vopg,
+  optimismSepolia as vops,
+  polygon as vpg,
+  polygonAmoy as vpga,
+  polygonMumbai as vpgm,
+  sepolia as vsep,
+  zora as vzora,
+  zoraSepolia as vzoras,
+} from "viem/chains";
+
+export type AlchemyChainConfig = {
+  chain: Chain;
+  rpcBaseUrl: string;
+};
+
+/**
+ * Defines an Alchemy chain configuration by adding an Alchemy-specific RPC base URL to the chain's RPC URLs.
+ *
+ * @example
+ * ```ts
+ * import { defineAlchemyChain } from "@account-kit/infra";
+ * import { sepolia } from "viem/chains";
+ *
+ * const chain = defineAlchemyChain({
+ *  chain: sepolia,
+ *  rpcBaseUrl: "https://eth-sepolia.g.alchemy.com/v2"
+ * });
+ * ```
+ *
+ * @param {AlchemyChainConfig} params The parameters for defining the Alchemy chain
+ * @param {Chain} params.chain The original chain configuration
+ * @param {string} params.rpcBaseUrl The Alchemy-specific RPC base URL
+ * @returns {Chain} The updated chain configuration with the Alchemy RPC URL added
+ */
 export const defineAlchemyChain = ({
   chain,
   rpcBaseUrl,
@@ -17,3 +63,212 @@ export const defineAlchemyChain = ({
     },
   };
 };
+
+export const arbitrum: Chain = {
+  ...vab,
+  rpcUrls: {
+    ...vab.rpcUrls,
+    alchemy: {
+      http: ["https://arb-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const arbitrumGoerli: Chain = {
+  ...vabg,
+  rpcUrls: {
+    ...vabg.rpcUrls,
+    alchemy: {
+      http: ["https://arb-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const arbitrumSepolia: Chain = {
+  ...vabs,
+  rpcUrls: {
+    ...vabs.rpcUrls,
+    alchemy: {
+      http: ["https://arb-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+export const goerli: Chain = {
+  ...vgo,
+  rpcUrls: {
+    ...vgo.rpcUrls,
+    alchemy: {
+      http: ["https://eth-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+export const mainnet: Chain = {
+  ...vmain,
+  rpcUrls: {
+    ...vmain.rpcUrls,
+    alchemy: {
+      http: ["https://eth-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+export const optimism: Chain = {
+  ...vop,
+  rpcUrls: {
+    ...vop.rpcUrls,
+    alchemy: {
+      http: ["https://opt-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+export const optimismGoerli: Chain = {
+  ...vopg,
+  rpcUrls: {
+    ...vopg.rpcUrls,
+    alchemy: {
+      http: ["https://opt-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+export const optimismSepolia: Chain = {
+  ...vops,
+  rpcUrls: {
+    ...vops.rpcUrls,
+    alchemy: {
+      http: ["https://opt-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+export const sepolia: Chain = {
+  ...vsep,
+  rpcUrls: {
+    ...vsep.rpcUrls,
+    alchemy: {
+      http: ["https://eth-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+export const base: Chain = {
+  ...vbase,
+  rpcUrls: {
+    ...vbase.rpcUrls,
+    alchemy: {
+      http: ["https://base-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+export const baseGoerli: Chain = {
+  ...vbaseg,
+  rpcUrls: {
+    ...vbaseg.rpcUrls,
+    alchemy: {
+      http: ["https://base-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+export const baseSepolia: Chain = {
+  ...vbases,
+  rpcUrls: {
+    ...vbases.rpcUrls,
+    alchemy: {
+      http: ["https://base-sepolia.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const polygonMumbai: Chain = {
+  ...vpgm,
+  rpcUrls: {
+    ...vpgm.rpcUrls,
+    alchemy: {
+      http: ["https://polygon-mumbai.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const polygonAmoy: Chain = {
+  ...vpga,
+  rpcUrls: {
+    ...vpga.rpcUrls,
+    alchemy: {
+      http: ["https://polygon-amoy.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const polygon: Chain = {
+  ...vpg,
+  rpcUrls: {
+    ...vpg.rpcUrls,
+    alchemy: {
+      http: ["https://polygon-mainnet.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const fraxtal: Chain = {
+  ...vfrax,
+  rpcUrls: {
+    ...vfrax.rpcUrls,
+  },
+};
+
+export const fraxtalSepolia: Chain = defineChain({
+  id: 2523,
+  name: "Fraxtal Sepolia",
+  nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.testnet-sepolia.frax.com"],
+    },
+  },
+});
+
+export const zora: Chain = {
+  ...vzora,
+  rpcUrls: {
+    ...vzora.rpcUrls,
+  },
+};
+
+export const zoraSepolia: Chain = {
+  ...vzoras,
+  rpcUrls: {
+    ...vzoras.rpcUrls,
+  },
+};
+
+export const worldChainSepolia: Chain = defineChain({
+  id: 4801,
+  name: "World Chain Sepolia",
+  network: "World Chain Sepolia",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://worldchain-sepolia.g.alchemy.com/v2"],
+    },
+    public: {
+      http: ["https://worldchain-sepolia.g.alchemy.com/v2"],
+    },
+    alchemy: {
+      http: ["https://worldchain-sepolia.g.alchemy.com/v2"],
+    },
+  },
+});
+
+export const worldChain: Chain = defineChain({
+  id: 480,
+  name: "World Chain",
+  network: "World Chain",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://worldchain-mainnet.g.alchemy.com/v2"],
+    },
+    public: {
+      http: ["https://worldchain-mainnet.g.alchemy.com/v2"],
+    },
+    alchemy: {
+      http: ["https://worldchain-mainnet.g.alchemy.com/v2"],
+    },
+  },
+});

package/src/client/decorators/alchemyEnhancedApis.ts

@@ -14,41 +14,58 @@ export type AlchemyEnhancedApis = {
   config: Alchemy["config"];
 };
 
-export const alchemyEnhancedApiActions: (
-  alchemy: Alchemy
-) => <
-  TTransport extends Transport = Transport,
-  TChain extends Chain | undefined = Chain | undefined,
-  TAccount extends SmartContractAccount | undefined =
-    | SmartContractAccount
-    | undefined
->(
-  client: AlchemySmartAccountClient<TTransport, TChain, TAccount>
-) => AlchemyEnhancedApis = (alchemy) => (client) => {
-  const alchemySdk = AlchemySdkClientSchema.parse(alchemy);
+/**
+ * Given an instance of the Alchemy SDK, returns a smart account client decorator which contains actions for interacting Alchemy's enhanced APIs.
+ *
+ * @example
+ * ```ts
+ * import { Alchemy } from "alchemy-sdk";
+ * import { alchemyEnhancedApiActions } from "@account-kit/infra";
+ * import { alchemySCAClient } from "./client";
+ *
+ * const alchemy = new Alchemy(...);
+ * const enhancedApiDecorator = alchemyEnhancedApiActions(alchemy);
+ * const withEnhancedApis = alchemySCAClient.extend(enhancedApiDecorator);
+ * ```
+ *
+ * @param {Alchemy} alchemy The Alchemy instance containing the SDK client
+ * @returns {(client: AlchemySmartAccountClient) => AlchemyEnhancedApis} A client decorator for Alchemy Smart Account clients that adds the enhanced API methods
+ */
+export const alchemyEnhancedApiActions =
+  (alchemy: Alchemy) =>
+  <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartContractAccount | undefined =
+      | SmartContractAccount
+      | undefined
+  >(
+    client: AlchemySmartAccountClient<TTransport, TChain, TAccount>
+  ): AlchemyEnhancedApis => {
+    const alchemySdk = AlchemySdkClientSchema.parse(alchemy);
 
-  if (client.transport.type === "http") {
-    const { url } = client.transport as ReturnType<HttpTransport>["config"] &
-      ReturnType<HttpTransport>["value"];
+    if (client.transport.type === "http") {
+      const { url } = client.transport as ReturnType<HttpTransport>["config"] &
+        ReturnType<HttpTransport>["value"];
 
-    if (
-      client.transport.type === "http" &&
-      alchemy.config.url &&
-      alchemy.config.url !== url
-    ) {
-      throw new Error(
-        "Alchemy SDK client JSON-RPC URL must match AlchemyProvider JSON-RPC URL"
-      );
+      if (
+        client.transport.type === "http" &&
+        alchemy.config.url &&
+        alchemy.config.url !== url
+      ) {
+        throw new Error(
+          "Alchemy SDK client JSON-RPC URL must match AlchemyProvider JSON-RPC URL"
+        );
+      }
     }
-  }
 
-  return {
-    core: alchemySdk.core,
-    nft: alchemySdk.nft,
-    transact: alchemySdk.transact,
-    debug: alchemySdk.debug,
-    ws: alchemySdk.ws,
-    notify: alchemySdk.notify,
-    config: alchemySdk.config,
+    return {
+      core: alchemySdk.core,
+      nft: alchemySdk.nft,
+      transact: alchemySdk.transact,
+      debug: alchemySdk.debug,
+      ws: alchemySdk.ws,
+      notify: alchemySdk.notify,
+      config: alchemySdk.config,
+    };
   };
-};

package/src/client/decorators/smartAccount.ts

@@ -20,6 +20,21 @@ export type AlchemySmartAccountClientActions<
   ) => Promise<SimulateUserOperationAssetChangesResponse>;
 };
 
+/**
+ * Provides a set of actions for interacting with the Alchemy Smart Account client, including the ability to simulate user operations.
+ *
+ * @example
+ * ```ts
+ * import { alchemyActions } from "@account-kit/infra";
+ * import { createPublicClient } from "viem";
+ *
+ * const client = createPublicClient(...);
+ * const clientWithAlchemyActions = client.extend(alchemyActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance used to perform actions
+ * @returns {AlchemySmartAccountClientActions<TAccount, TContext>} An object containing Alchemy Smart Account client actions
+ */
 export const alchemyActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

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,
@@ -39,8 +39,8 @@ export function getSignerTypeHeader<
  * 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
+ * @param {CreateAlchemySmartAccountClientFromRpcClientParams<TAccount, TContext>} args configuration for the client
+ * @returns {AlchemySmartAccountClient} a smart account client configured to use Alchemy's RPC
  */
 export function createAlchemySmartAccountClientFromRpcClient<
   TChain extends Chain | undefined = Chain | 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,
+    policyId,
+    feeEstimator,
+    gasEstimator,
+    customMiddleware,
+    signUserOperation,
+    client,
+  } = args;
   const feeOptions =
     opts?.feeOptions ?? getDefaultUserOperationFeeOptions(client.chain);
 
@@ -86,7 +106,6 @@ export function createAlchemySmartAccountClientFromRpcClient({
       if (isSmartAccountWithSigner(args.account)) {
         client.updateHeaders(getSignerTypeHeader(args.account));
       }
-
       return customMiddleware ? customMiddleware(struct, args) : struct;
     },
     feeEstimator: feeEstimator ?? alchemyFeeEstimator(client),
@@ -94,22 +113,7 @@ export function createAlchemySmartAccountClientFromRpcClient({
       ? 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,
-        },
-      })),
+    ...(policyId && alchemyGasManagerMiddleware(policyId)),
     signUserOperation,
   }).extend(alchemyActions);
 

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

@@ -9,7 +9,6 @@ import {
 } 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";
@@ -30,7 +29,7 @@ export type AlchemySmartAccountClientConfig<
 > = {
   account?: account;
   useSimulation?: boolean;
-  gasManagerConfig?: AlchemyGasManagerConfig;
+  policyId?: string;
 } & AlchemyProviderConfig &
   Pick<
     SmartAccountClientConfig<transport, chain, account, context>,
@@ -95,7 +94,7 @@ export function createAlchemySmartAccountClient<
     | undefined
 >({
   account,
-  gasManagerConfig,
+  policyId,
   useSimulation,
   feeEstimator,
   customMiddleware,
@@ -115,9 +114,26 @@ 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,
+  policyId,
   useSimulation,
   feeEstimator,
   customMiddleware,
@@ -143,7 +159,7 @@ export function createAlchemySmartAccountClient({
       ...opts,
       feeOptions,
     },
-    gasManagerConfig,
+    policyId,
     useSimulation,
     feeEstimator,
     customMiddleware,

package/src/client/types.ts

@@ -1,40 +1,11 @@
 import { type BundlerClient, type UserOperationRequest } from "@aa-sdk/core";
-import type { Address, Hex, HttpTransport } from "viem";
+import type { 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;
@@ -50,30 +21,6 @@ export type AlchemyRpcSchema = [
 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;