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

package/src/chains.ts

@@ -310,6 +310,24 @@ export const shape: Chain = defineChain({
   },
 });
 
+export const beraChainBartio: Chain = defineChain({
+  id: 80084,
+  name: "BeraChain Bartio",
+  network: "BeraChain Bartio",
+  nativeCurrency: { name: "Bera", symbol: "BERA", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://berachain-bartio.g.alchemy.com/v2"],
+    },
+    public: {
+      http: ["https://berachain-bartio.g.alchemy.com/v2"],
+    },
+    alchemy: {
+      http: ["https://berachain-bartio.g.alchemy.com/v2"],
+    },
+  },
+});
+
 export const arbitrumNova: Chain = {
   ...vabn,
   rpcUrls: {

package/src/client/decorators/alchemyEnhancedApis.ts

@@ -1,6 +1,6 @@
 import type { SmartContractAccount } from "@aa-sdk/core";
 import type { Alchemy } from "alchemy-sdk";
-import type { Chain, HttpTransport, Transport } from "viem";
+import type { Chain } from "viem";
 import { AlchemySdkClientSchema } from "../../schema.js";
 import type { AlchemySmartAccountClient } from "../smartAccountClient.js";
 
@@ -34,30 +34,23 @@ export type AlchemyEnhancedApis = {
 export function alchemyEnhancedApiActions(
   alchemy: Alchemy
 ): <
-  TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends SmartContractAccount | undefined =
     | SmartContractAccount
     | undefined
 >(
-  client: AlchemySmartAccountClient<TTransport, TChain, TAccount>
+  client: AlchemySmartAccountClient<TChain, TAccount>
 ) => AlchemyEnhancedApis {
   return (client) => {
     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" &&
-        alchemy.config.url &&
-        alchemy.config.url !== url
-      ) {
-        throw new Error(
-          "Alchemy SDK client JSON-RPC URL must match AlchemyProvider JSON-RPC URL"
-        );
-      }
+    if (
+      alchemy.config.url &&
+      alchemy.config.url !== client.transport.alchemyRpcUrl
+    ) {
+      throw new Error(
+        "Alchemy SDK client JSON-RPC URL must match AlchemyProvider JSON-RPC URL"
+      );
     }
 
     return {

package/src/client/decorators/smartAccount.ts

@@ -1,11 +1,26 @@
-import type {
-  SendUserOperationParameters,
-  SmartContractAccount,
-  UserOperationContext,
+import {
+  isSmartAccountWithSigner,
+  sendTransaction,
+  sendTransactions,
+  sendUserOperation,
+  type GetEntryPointFromAccount,
+  type SendTransactionsParameters,
+  type SendUserOperationParameters,
+  type SendUserOperationResult,
+  type SmartContractAccount,
+  type UserOperationContext,
+  type UserOperationOverrides,
 } from "@aa-sdk/core";
-import type { Chain, Client, Transport } from "viem";
+import type {
+  Chain,
+  Client,
+  Hex,
+  SendTransactionParameters,
+  Transport,
+} from "viem";
 import { simulateUserOperationChanges } from "../../actions/simulateUserOperationChanges.js";
 import type { SimulateUserOperationAssetChangesResponse } from "../../actions/types.js";
+import { InfraLogger } from "../../metrics.js";
 
 export type AlchemySmartAccountClientActions<
   TAccount extends SmartContractAccount | undefined =
@@ -13,11 +28,28 @@ export type AlchemySmartAccountClientActions<
     | undefined,
   TContext extends UserOperationContext | undefined =
     | UserOperationContext
-    | undefined
+    | undefined,
+  TChain extends Chain | undefined = Chain | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
 > = {
   simulateUserOperation: (
     args: SendUserOperationParameters<TAccount, TContext>
   ) => Promise<SimulateUserOperationAssetChangesResponse>;
+  sendUserOperation: (
+    args: SendUserOperationParameters<
+      TAccount,
+      TContext,
+      GetEntryPointFromAccount<TAccount>
+    >
+  ) => Promise<SendUserOperationResult<TEntryPointVersion>>;
+  sendTransaction: <TChainOverride extends Chain | undefined = undefined>(
+    args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
+    overrides?: UserOperationOverrides<TEntryPointVersion>,
+    context?: TContext
+  ) => Promise<Hex>;
+  sendTransactions: (
+    args: SendTransactionsParameters<TAccount, TContext>
+  ) => Promise<Hex>;
 };
 
 /**
@@ -46,7 +78,45 @@ export const alchemyActions: <
     | undefined
 >(
   client: Client<TTransport, TChain, TAccount>
-) => AlchemySmartAccountClientActions<TAccount, TContext> = (client) => ({
+) => AlchemySmartAccountClientActions<TAccount, TContext, TChain> = (
+  client
+) => ({
   simulateUserOperation: async (args) =>
     simulateUserOperationChanges(client, args),
+  sendUserOperation: async (args) => {
+    const { account = client.account } = args;
+
+    const result = sendUserOperation(client, args);
+    logSendUoEvent(client.chain!.id, account!);
+    return result;
+  },
+  sendTransaction: async (args, overrides, context) => {
+    const { account = client.account } = args;
+
+    const result = await sendTransaction(client, args, overrides, context);
+    logSendUoEvent(client.chain!.id, account as SmartContractAccount);
+    return result;
+  },
+  async sendTransactions(args) {
+    const { account = client.account } = args;
+
+    const result = sendTransactions(client, args);
+    logSendUoEvent(client.chain!.id, account!);
+    return result;
+  },
 });
+
+function logSendUoEvent(chainId: number, account: SmartContractAccount) {
+  const signerType = isSmartAccountWithSigner(account)
+    ? account.getSigner().signerType
+    : "unknown";
+
+  InfraLogger.trackEvent({
+    name: "client_send_uo",
+    data: {
+      chainId,
+      signerType: signerType,
+      entryPoint: account.getEntryPoint().address,
+    },
+  });
+}

package/src/client/isAlchemySmartAccountClient.ts

@@ -1,4 +1,4 @@
-import { isSmartAccountClient, type SmartContractAccount } from "@aa-sdk/core";
+import { type SmartContractAccount } from "@aa-sdk/core";
 import type { Chain, Client, Transport } from "viem";
 import type { AlchemySmartAccountClient } from "./smartAccountClient";
 
@@ -18,17 +18,12 @@ import type { AlchemySmartAccountClient } from "./smartAccountClient";
  * @returns {boolean} `true` if the client is an Alchemy Smart Account Client, otherwise `false`
  */
 export function 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);
+  client: Client<Transport, TChain, TAccount>
+): client is AlchemySmartAccountClient<TChain, TAccount> {
+  return client.transport.type === "alchemy";
 }

package/src/client/rpcClient.ts

@@ -1,11 +1,6 @@
-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 { createBundlerClient } from "@aa-sdk/core";
+import type { Chain } from "viem";
+import type { AlchemyTransport } from "../alchemyTransport.js";
 import type { ClientWithAlchemyMethods } from "./types.js";
 
 /**
@@ -13,14 +8,14 @@ import type { ClientWithAlchemyMethods } from "./types.js";
  *
  * @example
  * ```ts
- * import { createAlchemyPublicRpcClient } from "@account-kit/infra";
+ * import { createAlchemyPublicRpcClient, alchemy } from "@account-kit/infra";
  * import { sepolia } from "@account-kit/infra";
  *
  * const client = createAlchemyPublicRpcClient({
+ *  transport: alchemy({
+ *    apiKey: "ALCHEMY_API_KEY"
+ *  }),
  *  chain: sepolia,
- *  connectionConfig: {
- *    apiKey: "your-api-key",
- *  }
  * });
  * ```
  *
@@ -31,42 +26,14 @@ import type { ClientWithAlchemyMethods } from "./types.js";
  * @returns {ClientWithAlchemyMethods} A client object tailored with Alchemy methods and capabilities to interact with the blockchain
  */
 export const createAlchemyPublicRpcClient = ({
-  chain: chain_,
-  connectionConfig,
-  fetchOptions = {},
+  transport,
+  chain,
 }: {
-  connectionConfig: ConnectionConfig;
-  chain: Chain;
-  fetchOptions?: NoUndefined<HttpTransportConfig["fetchOptions"]>;
+  transport: AlchemyTransport;
+  chain: Chain | undefined;
 }): 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,
-      };
-    },
-  }));
+    chain,
+    transport,
+  });
 };

package/src/client/smartAccountClient.ts

@@ -1,24 +1,36 @@
 import {
+  ChainNotFoundError,
+  createSmartAccountClient,
+  isSmartAccountWithSigner,
   type Prettify,
   type SmartAccountClient,
   type SmartAccountClientActions,
   type SmartAccountClientConfig,
   type SmartAccountClientRpcSchema,
   type SmartContractAccount,
+  type SmartContractAccountWithSigner,
   type UserOperationContext,
 } from "@aa-sdk/core";
-import { type Chain, type Transport } from "viem";
+import { type Chain } from "viem";
+import type { AlchemyTransport } from "../alchemyTransport.js";
 import { getDefaultUserOperationFeeOptions } from "../defaults.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 { alchemyFeeEstimator } from "../middleware/feeEstimator.js";
+import { alchemyGasManagerMiddleware } from "../middleware/gasManager.js";
+import { alchemyUserOperationSimulator } from "../middleware/userOperationSimulator.js";
+import {
+  alchemyActions,
+  type AlchemySmartAccountClientActions,
+} from "./decorators/smartAccount.js";
 import type { AlchemyRpcSchema } from "./types.js";
 
+export function getSignerTypeHeader<
+  TAccount extends SmartContractAccountWithSigner
+>(account: TAccount) {
+  return { "Alchemy-Aa-Sdk-Signer": account.getSigner().signerType };
+}
+
 // #region AlchemySmartAccountClientConfig
 export type AlchemySmartAccountClientConfig<
-  transport extends Transport = Transport,
   chain extends Chain | undefined = Chain | undefined,
   account extends SmartContractAccount | undefined =
     | SmartContractAccount
@@ -30,11 +42,16 @@ export type AlchemySmartAccountClientConfig<
   account?: account;
   useSimulation?: boolean;
   policyId?: string;
-} & AlchemyProviderConfig &
-  Pick<
-    SmartAccountClientConfig<transport, chain, account, context>,
-    "customMiddleware" | "feeEstimator" | "gasEstimator" | "signUserOperation"
-  >;
+} & Pick<
+  SmartAccountClientConfig<AlchemyTransport, chain, account, context>,
+  | "customMiddleware"
+  | "feeEstimator"
+  | "gasEstimator"
+  | "signUserOperation"
+  | "transport"
+  | "chain"
+  | "opts"
+>;
 // #endregion AlchemySmartAccountClientConfig
 
 export type BaseAlchemyActions<
@@ -49,7 +66,6 @@ export type BaseAlchemyActions<
   AlchemySmartAccountClientActions<account, context>;
 
 export type AlchemySmartAccountClient_Base<
-  transport extends Transport = Transport,
   chain extends Chain | undefined = Chain | undefined,
   account extends SmartContractAccount | undefined =
     | SmartContractAccount
@@ -60,7 +76,7 @@ export type AlchemySmartAccountClient_Base<
     | undefined
 > = Prettify<
   SmartAccountClient<
-    transport,
+    AlchemyTransport,
     chain,
     account,
     actions & BaseAlchemyActions<chain, account, context>,
@@ -70,7 +86,6 @@ export type AlchemySmartAccountClient_Base<
 >;
 
 export type AlchemySmartAccountClient<
-  transport extends Transport = Transport,
   chain extends Chain | undefined = Chain | undefined,
   account extends SmartContractAccount | undefined =
     | SmartContractAccount
@@ -79,12 +94,9 @@ export type AlchemySmartAccountClient<
   context extends UserOperationContext | undefined =
     | UserOperationContext
     | undefined
-> = Prettify<
-  AlchemySmartAccountClient_Base<transport, chain, account, actions, context>
->;
+> = Prettify<AlchemySmartAccountClient_Base<chain, account, actions, context>>;
 
 export function createAlchemySmartAccountClient<
-  TTransport extends Transport = Transport,
   TChain extends Chain = Chain,
   TAccount extends SmartContractAccount | undefined =
     | SmartContractAccount
@@ -92,39 +104,21 @@ export function createAlchemySmartAccountClient<
   TContext extends UserOperationContext | undefined =
     | UserOperationContext
     | undefined
->({
-  account,
-  policyId,
-  useSimulation,
-  feeEstimator,
-  customMiddleware,
-  gasEstimator,
-  signUserOperation,
-  ...config_
-}: AlchemySmartAccountClientConfig<
-  TTransport,
-  TChain,
-  TAccount,
-  TContext
->): AlchemySmartAccountClient<
-  TTransport,
-  TChain,
-  TAccount,
-  Record<string, never>,
-  TContext
->;
+>(
+  params: AlchemySmartAccountClientConfig<TChain, TAccount, TContext>
+): AlchemySmartAccountClient<TChain, TAccount, Record<string, never>, 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 { createAlchemySmartAccountClient, alchemy } from "@account-kit/infra";
  * import { sepolia } from "@account-kit/infra/chain";
  *
  * const client = createAlchemySmartAccountClient({
  *  chain: sepolia,
- *  apiKey: "your-api-key",
+ *  transport: alchemy({ apiKey: "your-api-key" }),
  * });
  * ```
  *
@@ -139,31 +133,44 @@ export function createAlchemySmartAccountClient({
   customMiddleware,
   gasEstimator,
   signUserOperation,
-  ...config_
+  transport,
+  chain,
+  opts,
 }: AlchemySmartAccountClientConfig): AlchemySmartAccountClient {
-  const config = AlchemyProviderConfigSchema.parse(config_);
-  const { chain, opts, ...connectionConfig } = config;
-
-  const client = createAlchemyPublicRpcClient({
-    chain,
-    connectionConfig,
-  });
+  if (!chain) {
+    throw new ChainNotFoundError();
+  }
 
   const feeOptions =
     opts?.feeOptions ?? getDefaultUserOperationFeeOptions(chain);
 
-  return createAlchemySmartAccountClientFromRpcClient({
-    client,
+  const scaClient = createSmartAccountClient({
     account,
+    transport,
+    chain,
+    type: "AlchemySmartAccountClient",
     opts: {
       ...opts,
       feeOptions,
     },
-    policyId,
-    useSimulation,
-    feeEstimator,
-    customMiddleware,
+    customMiddleware: async (struct, args) => {
+      if (isSmartAccountWithSigner(args.account)) {
+        transport.updateHeaders(getSignerTypeHeader(args.account));
+      }
+      return customMiddleware ? customMiddleware(struct, args) : struct;
+    },
+    feeEstimator: feeEstimator ?? alchemyFeeEstimator(transport),
+    userOperationSimulator: useSimulation
+      ? alchemyUserOperationSimulator(transport)
+      : undefined,
     gasEstimator,
+    ...(policyId && alchemyGasManagerMiddleware(policyId)),
     signUserOperation,
-  });
+  }).extend(alchemyActions);
+
+  if (account && isSmartAccountWithSigner(account)) {
+    transport.updateHeaders(getSignerTypeHeader(account));
+  }
+
+  return scaClient;
 }

package/src/client/types.ts

@@ -1,9 +1,13 @@
-import { type BundlerClient, type UserOperationRequest } from "@aa-sdk/core";
-import type { HttpTransport } from "viem";
+import {
+  type BundlerClient,
+  type Erc7677RpcSchema,
+  type UserOperationRequest,
+} from "@aa-sdk/core";
 import type {
   SimulateUserOperationAssetChangesRequest,
   SimulateUserOperationAssetChangesResponse,
 } from "../actions/types";
+import type { AlchemyTransport } from "../alchemyTransport";
 
 export type AlchemyRpcSchema = [
   {
@@ -15,11 +19,12 @@ export type AlchemyRpcSchema = [
     Method: "rundler_maxPriorityFeePerGas";
     Parameters: [];
     ReturnType: UserOperationRequest["maxPriorityFeePerGas"];
-  }
+  },
+  ...Erc7677RpcSchema<{ policyId: string }>
 ];
 
-export type ClientWithAlchemyMethods = BundlerClient<HttpTransport> & {
-  request: BundlerClient<HttpTransport>["request"] &
+export type ClientWithAlchemyMethods = BundlerClient<AlchemyTransport> & {
+  request: BundlerClient<AlchemyTransport>["request"] &
     {
       request(args: {
         method: "alchemy_simulateUserOperationAssetChanges";
@@ -31,6 +36,4 @@ export type ClientWithAlchemyMethods = BundlerClient<HttpTransport> & {
         params: [];
       }): Promise<UserOperationRequest["maxPriorityFeePerGas"]>;
     }["request"];
-} & {
-  updateHeaders: (headers: HeadersInit) => void;
 };

package/src/index.ts

@@ -1,12 +1,14 @@
 export type * from "./actions/simulateUserOperationChanges.js";
 export { simulateUserOperationChanges } from "./actions/simulateUserOperationChanges.js";
 export type * from "./actions/types.js";
+export type * from "./alchemyTransport.js";
+export { alchemy } from "./alchemyTransport.js";
 export type * from "./chains.js";
 export {
   arbitrum,
   arbitrumGoerli,
-  arbitrumSepolia,
   arbitrumNova,
+  arbitrumSepolia,
   base,
   baseGoerli,
   baseSepolia,
@@ -22,18 +24,18 @@ export {
   polygonAmoy,
   polygonMumbai,
   sepolia,
-  zora,
-  zoraSepolia,
-  worldChain,
-  worldChainSepolia,
   shape,
   shapeSepolia,
+  worldChain,
+  worldChainSepolia,
+  zora,
+  zoraSepolia,
+  beraChainBartio,
 } 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";
@@ -47,5 +49,3 @@ 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/metrics.ts

@@ -0,0 +1,19 @@
+import { createLogger } from "@account-kit/logging";
+import type { Address } from "viem";
+import { VERSION } from "./version.js";
+
+export type InfraEventsSchema = [
+  {
+    EventName: "client_send_uo";
+    EventData: {
+      signerType: string;
+      chainId: number;
+      entryPoint: Address;
+    };
+  }
+];
+
+export const InfraLogger = createLogger<InfraEventsSchema>({
+  package: "@account-kit/infra",
+  version: VERSION,
+});

package/src/middleware/feeEstimator.ts

@@ -1,6 +1,6 @@
 import type { ClientMiddlewareFn } from "@aa-sdk/core";
 import { applyUserOpOverrideOrFeeOption } from "@aa-sdk/core";
-import type { ClientWithAlchemyMethods } from "../client/types";
+import type { AlchemyTransport } from "../alchemyTransport";
 
 /**
  * Function that estimates the transaction fees using Alchemy methods for a given client.
@@ -8,28 +8,33 @@ import type { ClientWithAlchemyMethods } from "../client/types";
  *
  * @example
  * ```ts
- * import { alchemyFeeEstimator, createAlchemyPublicRpcClient } from "@account-kit/infra";
+ * import { alchemyFeeEstimator, alchemy } from "@account-kit/infra";
  * import { createSmartAccountClient } from "@aa-sdk/core";
  *
- * const bundlerClient = createAlchemyPublicRpcClient(...);
+ * const alchemyTransport = alchemy({
+ *  chain: sepolia,
+ *  apiKey: "your-api-key"
+ * });
+ *
  * const client = createSmartAccountClient({
- *  feeEstimator: alchemyFeeEstimator(bundlerClient),
+ *  feeEstimator: alchemyFeeEstimator(alchemyTransport),
  *  ...otherParams
  * });
  * ```
  *
- * @param {ClientWithAlchemyMethods} client The client with Alchemy methods
+ * @param {AlchemyTransport} transport An alchemy transport for making Alchemy specific RPC calls
  * @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
+export const alchemyFeeEstimator: (
+  transport: AlchemyTransport
 ) => ClientMiddlewareFn =
-  (client) =>
-  async (struct, { overrides, feeOptions }) => {
+  (transport) =>
+  async (struct, { overrides, feeOptions, client }) => {
+    const transport_ = transport({ chain: client.chain });
     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({
+      transport_.request({
         method: "rundler_maxPriorityFeePerGas",
         params: [],
       }),

package/src/middleware/gasManager.ts

@@ -6,15 +6,14 @@ import { erc7677Middleware } from "@aa-sdk/core";
  *
  * @example
  *  ```ts
- *
- * import { sepolia } from "@account-kit/infra";
+ * import { sepolia, alchemyErc7677Middleware } from "@account-kit/infra";
  * import { http } from "viem";
  *
  * const client = createSmartAccountClient({
- *      http("rpc-url"),
- *      sepolia,
- *      alchemyErc7677Middleware("policyId")
- *    );
+ *  transport: http("rpc-url"),
+ *  chain: sepolia,
+ *  ...alchemyErc7677Middleware("policyId")
+ * });
  * ```
  *
  * @param {string} policyId the policyId for Alchemy's gas manager