@account-kit/infra 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "4.0.0-beta.6";
+export declare const VERSION = "4.0.0-beta.8";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@account-kit/infra",
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0-beta.8",
   "description": "adapters for @aa-sdk/core for interacting with alchemy services",
   "author": "Alchemy",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "vitest": "^2.0.4"
   },
   "dependencies": {
-    "@aa-sdk/core": "^4.0.0-beta.6",
+    "@aa-sdk/core": "^4.0.0-beta.8",
     "eventemitter3": "^5.0.1",
     "zod": "^3.22.4"
   },
@@ -64,7 +64,7 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "c25850c8617a78ee1956896b64c85db7a9ad6c08",
+  "gitHead": "de91f21bd8a8578a5cb119624fad7cc9b3726fee",
   "optionalDependencies": {
     "alchemy-sdk": "^3.0.0"
   }

package/src/alchemyTransport.ts

@@ -0,0 +1,214 @@
+import {
+  ChainNotFoundError,
+  ConnectionConfigSchema,
+  split,
+  type ConnectionConfig,
+  type NoUndefined,
+} from "@aa-sdk/core";
+import {
+  createTransport,
+  http,
+  type EIP1193RequestFn,
+  type HttpTransportConfig,
+  type PublicRpcSchema,
+  type Transport,
+  type TransportConfig,
+} from "viem";
+import type { AlchemyRpcSchema } from "./client/types.js";
+import { AlchemyChainSchema } from "./schema.js";
+import { VERSION } from "./version.js";
+
+type Never<T> = T extends object
+  ? {
+      [K in keyof T]?: never;
+    }
+  : never;
+
+type SplitTransportConfig = {
+  alchemyConnection: ConnectionConfig;
+  nodeRpcUrl: string;
+};
+
+const alchemyMethods = [
+  "eth_sendUserOperation",
+  "eth_estimateUserOperationGas",
+  "eth_getUserOperationReceipt",
+  "eth_getUserOperationByHash",
+  "eth_supportedEntryPoints",
+  "rundler_maxPriorityFeePerGas",
+  "pm_getPaymasterData",
+  "pm_getPaymasterStubData",
+];
+
+export type AlchemyTransportConfig = (
+  | (ConnectionConfig & Never<SplitTransportConfig>)
+  | (SplitTransportConfig & Never<ConnectionConfig>)
+) & {
+  /** The max number of times to retry. */
+  retryCount?: TransportConfig["retryCount"] | undefined;
+  /** The base delay (in ms) between retries. */
+  retryDelay?: TransportConfig["retryDelay"] | undefined;
+  fetchOptions?: NoUndefined<HttpTransportConfig["fetchOptions"]>;
+};
+
+type AlchemyTransportBase = Transport<
+  "alchemy",
+  {
+    alchemyRpcUrl: string;
+    fetchOptions?: AlchemyTransportConfig["fetchOptions"];
+  },
+  EIP1193RequestFn<[...PublicRpcSchema, ...AlchemyRpcSchema]>
+>;
+
+export type AlchemyTransport = AlchemyTransportBase & {
+  updateHeaders(newHeaders: HeadersInit): void;
+  config: AlchemyTransportConfig;
+};
+
+/**
+ * Creates an Alchemy transport with the specified configuration options.
+ * When sending all traffic to Alchemy, you must pass in one of rpcUrl, apiKey, or jwt.
+ * If you want to send Bundler and Paymaster traffic to Alchemy and Node traffic to a different RPC, you must pass in alchemyConnection and nodeRpcUrl.
+ *
+ * @example
+ * ### Basic Example
+ * If the chain you're using is supported for both Bundler and Node RPCs, then you can do the following:
+ * ```ts
+ * import { alchemy } from "@account-kit/infra";
+ *
+ * const transport = alchemy({
+ *  // NOTE: you can also pass in an rpcUrl or jwt here or rpcUrl and jwt
+ *  apiKey: "your-api-key",
+ * });
+ * ```
+ *
+ * ### AA Only Chains
+ * For AA-only chains, you need to specify the alchemyConnection and nodeRpcUrl since Alchemy only
+ * handles the Bundler and Paymaster RPCs for these chains.
+ * ```ts
+ * import { alchemy } from "@account-kit/infra";
+ *
+ * const transport = alchemy({
+ *  alchemyConnection: {
+ *    apiKey: "your-api-key",
+ *  },
+ *  nodeRpcUrl: "https://zora.rpc.url",
+ * });
+ * ```
+ *
+ * @param {AlchemyTransportConfig} config The configuration object for the Alchemy transport.
+ * @param {number} config.retryDelay Optional The delay between retries, in milliseconds.
+ * @param {number} config.retryCount Optional The number of retry attempts.
+ * @param {string} [config.alchemyConnection] Optional Alchemy connection configuration (if this is passed in, nodeRpcUrl is required).
+ * @param {string} [config.fetchOptions] Optional fetch options for HTTP requests.
+ * @param {string} [config.nodeRpcUrl] Optional RPC URL for node (if this is passed in, alchemyConnection is required).
+ * @param {string} [config.rpcUrl] Optional RPC URL.
+ * @param {string} [config.apiKey] Optional API key for Alchemy.
+ * @param {string} [config.jwt] Optional JSON Web Token for authorization.
+ * @returns {AlchemyTransport} The configured Alchemy transport object.
+ */
+export function alchemy(config: AlchemyTransportConfig): AlchemyTransport {
+  const { retryDelay, retryCount } = config;
+  // we create a copy here in case we create a split transport down below
+  // we don't want to add alchemy headers to 3rd party nodes
+  const fetchOptions = { ...config.fetchOptions };
+
+  const connectionConfig = ConnectionConfigSchema.parse(
+    config.alchemyConnection ?? config
+  );
+
+  const headersAsObject = convertHeadersToObject(fetchOptions.headers);
+
+  // TODO: we probably should just log these headers during telemetry logging instead of doing this mutable header stuff
+  fetchOptions.headers = {
+    ...headersAsObject,
+    "Alchemy-AA-Sdk-Version": VERSION,
+  };
+
+  if (connectionConfig.jwt != null) {
+    fetchOptions.headers = {
+      ...fetchOptions.headers,
+      Authorization: `Bearer ${connectionConfig.jwt}`,
+    };
+  }
+
+  const transport: AlchemyTransportBase = (opts) => {
+    const { chain: chain_ } = opts;
+    if (!chain_) {
+      throw new ChainNotFoundError();
+    }
+    const chain = AlchemyChainSchema.parse(chain_);
+
+    const rpcUrl =
+      connectionConfig.rpcUrl == null
+        ? `${chain.rpcUrls.alchemy.http[0]}/${connectionConfig.apiKey ?? ""}`
+        : connectionConfig.rpcUrl;
+
+    const innerTransport = (() => {
+      if (config.alchemyConnection && config.nodeRpcUrl) {
+        return split({
+          overrides: [
+            {
+              methods: alchemyMethods,
+              transport: http(rpcUrl, { fetchOptions }),
+            },
+          ],
+          fallback: http(config.nodeRpcUrl, {
+            fetchOptions: config.fetchOptions,
+          }),
+        });
+      }
+
+      return http(rpcUrl, { fetchOptions });
+    })();
+
+    return createTransport(
+      {
+        key: "alchemy",
+        name: "Alchemy Transport",
+        request: innerTransport(opts).request,
+        retryCount: retryCount ?? opts?.retryCount,
+        retryDelay,
+        type: "alchemy",
+      },
+      { alchemyRpcUrl: rpcUrl, fetchOptions }
+    );
+  };
+
+  return Object.assign(transport, {
+    updateHeaders(newHeaders_: HeadersInit) {
+      const newHeaders = convertHeadersToObject(newHeaders_);
+
+      fetchOptions.headers = {
+        ...fetchOptions.headers,
+        ...newHeaders,
+      };
+    },
+    config,
+  });
+}
+
+const convertHeadersToObject = (
+  headers?: HeadersInit
+): Record<string, string> => {
+  if (!headers) {
+    return {};
+  }
+
+  if (headers instanceof Headers) {
+    const headersObject = {} as Record<string, string>;
+    headers.forEach((value, key) => {
+      headersObject[key] = value;
+    });
+    return headersObject;
+  }
+
+  if (Array.isArray(headers)) {
+    return headers.reduce((acc, header) => {
+      acc[header[0]] = header[1];
+      return acc;
+    }, {} as Record<string, string>);
+  }
+
+  return headers;
+};

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/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;
 };