@alchemy/common 0.0.0-alpha.0

package/dist/esm/tracing/traceHeader.js

@@ -0,0 +1,145 @@
+function generateRandomHexString(numBytes) {
+    const hexPairs = new Array(numBytes).fill(0).map(() => Math.floor(Math.random() * 16)
+        .toString(16)
+        .padStart(2, "0"));
+    return hexPairs.join("");
+}
+/**
+ * These are the headers that are used in the trace headers, could be found in the spec
+ *
+ * @see https://www.w3.org/TR/trace-context/#design-overview
+ */
+export const TRACE_HEADER_NAME = "traceparent";
+/**
+ * These are the headers that are used in the trace headers, could be found in the spec
+ *
+ * @see https://www.w3.org/TR/trace-context/#design-overview
+ */
+export const TRACE_HEADER_STATE = "tracestate";
+const clientTraceId = generateRandomHexString(16);
+/**
+ * Some tools that are useful when dealing with the values
+ * of the trace header. Follows the W3C trace context standard.
+ *
+ * @see https://www.w3.org/TR/trace-context/
+ */
+export class TraceHeader {
+    /**
+     * Initializes a new instance with the provided trace identifiers and state information.
+     *
+     * @param {string} traceId The unique identifier for the trace
+     * @param {string} parentId The identifier of the parent trace
+     * @param {string} traceFlags Flags containing trace-related options
+     * @param {TraceHeader["traceState"]} traceState The trace state information for additional trace context
+     */
+    constructor(traceId, parentId, traceFlags, traceState) {
+        Object.defineProperty(this, "traceId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "parentId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "traceFlags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "traceState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.traceId = traceId;
+        this.parentId = parentId;
+        this.traceFlags = traceFlags;
+        this.traceState = traceState;
+    }
+    /**
+     * Creating a default trace id that is a random setup for both trace id and parent id
+     *
+     * @example ```ts
+     * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();
+     * ```
+     *
+     * @returns {TraceHeader} A default trace header
+     */
+    static default() {
+        return new TraceHeader(clientTraceId, generateRandomHexString(8), "00", //Means no flag have been set, and no sampled state https://www.w3.org/TR/trace-context/#trace-flags
+        {});
+    }
+    /**
+     * Should be able to consume a trace header from the headers of an http request
+     *
+     * @example ```ts
+     * const traceHeader = TraceHeader.fromTraceHeader(headers);
+     * ```
+     *
+     * @param {Record<string,string>} headers The headers from the http request
+     * @returns {TraceHeader | undefined} The trace header object, or nothing if not found
+     */
+    static fromTraceHeader(headers) {
+        if (!headers[TRACE_HEADER_NAME]) {
+            return undefined;
+        }
+        const [version, traceId, parentId, traceFlags] = headers[TRACE_HEADER_NAME]?.split("-");
+        const traceState = headers[TRACE_HEADER_STATE]?.split(",").reduce((acc, curr) => {
+            const [key, value] = curr.split("=");
+            acc[key] = value;
+            return acc;
+        }, {}) || {};
+        if (version !== "00") {
+            console.debug(new Error(`Invalid version for traceheader: ${headers[TRACE_HEADER_NAME]}`));
+            return undefined;
+        }
+        return new TraceHeader(traceId, parentId, traceFlags, traceState);
+    }
+    /**
+     * Should be able to convert the trace header to the format that is used in the headers of an http request
+     *
+     * @example ```ts
+     * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();
+     * const headers = traceHeader.toTraceHeader();
+     * ```
+     *
+     * @returns {{traceparent: string, tracestate: string}} The trace header in the format of a record, used in our http client
+     */
+    toTraceHeader() {
+        return {
+            [TRACE_HEADER_NAME]: `00-${this.traceId}-${this.parentId}-${this.traceFlags}`,
+            [TRACE_HEADER_STATE]: Object.entries(this.traceState)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(","),
+        };
+    }
+    /**
+     * Should be able to create a new trace header with a new event in the trace state,
+     *  as the key of the eventName as breadcrumbs appending onto previous breadcrumbs with the - infix if exists. And the
+     * trace parent gets updated as according to the docs
+     *
+     * @example ```ts
+     * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();
+     * const newTraceHeader = traceHeader.withEvent("newEvent");
+     * ```
+     *
+     * @param {string} eventName The key of the new event
+     * @returns {TraceHeader} The new trace header
+     */
+    withEvent(eventName) {
+        const breadcrumbs = this.traceState.breadcrumbs
+            ? `${this.traceState.breadcrumbs}-${eventName}`
+            : eventName;
+        return new TraceHeader(this.traceId, this.parentId, this.traceFlags, {
+            ...this.traceState,
+            breadcrumbs,
+        });
+    }
+}
+//# sourceMappingURL=traceHeader.js.map

package/dist/esm/tracing/traceHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceHeader.js","sourceRoot":"","sources":["../../../src/tracing/traceHeader.ts"],"names":[],"mappings":"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","sourcesContent":["function generateRandomHexString(numBytes: number) {\n  const hexPairs = new Array(numBytes).fill(0).map(() =>\n    Math.floor(Math.random() * 16)\n      .toString(16)\n      .padStart(2, \"0\"),\n  );\n  return hexPairs.join(\"\");\n}\n\n/**\n * These are the headers that are used in the trace headers, could be found in the spec\n *\n * @see https://www.w3.org/TR/trace-context/#design-overview\n */\n\nexport const TRACE_HEADER_NAME = \"traceparent\";\n/**\n * These are the headers that are used in the trace headers, could be found in the spec\n *\n * @see https://www.w3.org/TR/trace-context/#design-overview\n */\nexport const TRACE_HEADER_STATE = \"tracestate\";\n\nconst clientTraceId = generateRandomHexString(16);\n/**\n * Some tools that are useful when dealing with the values\n * of the trace header. Follows the W3C trace context standard.\n *\n * @see https://www.w3.org/TR/trace-context/\n */\nexport class TraceHeader {\n  readonly traceId: string;\n  readonly parentId: string;\n  readonly traceFlags: string;\n  readonly traceState: Record<string, string>;\n\n  /**\n   * Initializes a new instance with the provided trace identifiers and state information.\n   *\n   * @param {string} traceId The unique identifier for the trace\n   * @param {string} parentId The identifier of the parent trace\n   * @param {string} traceFlags Flags containing trace-related options\n   * @param {TraceHeader[\"traceState\"]} traceState The trace state information for additional trace context\n   */\n  constructor(\n    traceId: string,\n    parentId: string,\n    traceFlags: string,\n    traceState: TraceHeader[\"traceState\"],\n  ) {\n    this.traceId = traceId;\n    this.parentId = parentId;\n    this.traceFlags = traceFlags;\n    this.traceState = traceState;\n  }\n\n  /**\n   * Creating a default trace id that is a random setup for both trace id and parent id\n   *\n   * @example ```ts\n   * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();\n   * ```\n   *\n   * @returns {TraceHeader} A default trace header\n   */\n  static default() {\n    return new TraceHeader(\n      clientTraceId,\n      generateRandomHexString(8),\n      \"00\", //Means no flag have been set, and no sampled state https://www.w3.org/TR/trace-context/#trace-flags\n      {},\n    );\n  }\n  /**\n   * Should be able to consume a trace header from the headers of an http request\n   *\n   * @example ```ts\n   * const traceHeader = TraceHeader.fromTraceHeader(headers);\n   * ```\n   *\n   * @param {Record<string,string>} headers The headers from the http request\n   * @returns {TraceHeader | undefined} The trace header object, or nothing if not found\n   */\n  static fromTraceHeader(\n    headers: Record<string, string>,\n  ): TraceHeader | undefined {\n    if (!headers[TRACE_HEADER_NAME]) {\n      return undefined;\n    }\n    const [version, traceId, parentId, traceFlags] =\n      headers[TRACE_HEADER_NAME]?.split(\"-\");\n\n    const traceState =\n      headers[TRACE_HEADER_STATE]?.split(\",\").reduce(\n        (acc, curr) => {\n          const [key, value] = curr.split(\"=\");\n          acc[key] = value;\n          return acc;\n        },\n        {} as Record<string, string>,\n      ) || {};\n    if (version !== \"00\") {\n      console.debug(\n        new Error(\n          `Invalid version for traceheader: ${headers[TRACE_HEADER_NAME]}`,\n        ),\n      );\n      return undefined;\n    }\n    return new TraceHeader(traceId, parentId, traceFlags, traceState);\n  }\n\n  /**\n   * Should be able to convert the trace header to the format that is used in the headers of an http request\n   *\n   * @example ```ts\n   * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();\n   * const headers = traceHeader.toTraceHeader();\n   * ```\n   *\n   * @returns {{traceparent: string, tracestate: string}} The trace header in the format of a record, used in our http client\n   */\n  toTraceHeader() {\n    return {\n      [TRACE_HEADER_NAME]: `00-${this.traceId}-${this.parentId}-${this.traceFlags}`,\n      [TRACE_HEADER_STATE]: Object.entries(this.traceState)\n        .map(([key, value]) => `${key}=${value}`)\n        .join(\",\"),\n    } as const;\n  }\n\n  /**\n   * Should be able to create a new trace header with a new event in the trace state,\n   *  as the key of the eventName as breadcrumbs appending onto previous breadcrumbs with the - infix if exists. And the\n   * trace parent gets updated as according to the docs\n   *\n   * @example ```ts\n   * const traceHeader = TraceHeader.fromTraceHeader(headers) || TraceHeader.default();\n   * const newTraceHeader = traceHeader.withEvent(\"newEvent\");\n   * ```\n   *\n   * @param {string} eventName The key of the new event\n   * @returns {TraceHeader} The new trace header\n   */\n  withEvent(eventName: string): TraceHeader {\n    const breadcrumbs = this.traceState.breadcrumbs\n      ? `${this.traceState.breadcrumbs}-${eventName}`\n      : eventName;\n    return new TraceHeader(this.traceId, this.parentId, this.traceFlags, {\n      ...this.traceState,\n      breadcrumbs,\n    });\n  }\n}\n"]}

package/dist/esm/tracing/updateHeaders.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Remove the tracking headers. This is used in our split transport to ensure that we remove the headers that
+ * are not used by the other systems.
+ *
+ * @param {unknown} x The headers to remove the tracking headers from
+ */
+export declare function mutateRemoveTrackingHeaders(x?: unknown): void;
+/**
+ * Update the headers with the trace header and breadcrumb.
+ *
+ * These trace headers are used in the imply ingestion pipeline to trace the request.
+ * And the breadcrumb is used to get finer grain details in the trace.
+ *
+ * Then there are the trace headers that are part of the W3C trace context standard.
+ *
+ * @param {string} crumb The crumb to add to the breadcrumb
+ * @returns {Function} A function that updates the headers
+ */
+export declare function headersUpdate(crumb: string): (x: Record<string, string>) => {
+    traceparent: `00-${string}-${string}-${string}`;
+    tracestate: string;
+    "X-Alchemy-Client-Breadcrumb": string;
+    "X-Alchemy-Client-Trace-Id": string;
+};

package/dist/esm/tracing/updateHeaders.js

@@ -0,0 +1,61 @@
+import { TRACE_HEADER_NAME, TRACE_HEADER_STATE, TraceHeader, } from "./traceHeader.js";
+/**
+ * The header that is used to track the trace id.
+ * We use a client specific one to not mess with the span tracing of the servers.
+ *
+ * @see headersUpdate
+ */
+const TRACKER_HEADER = "X-Alchemy-Client-Trace-Id";
+/**
+ * The header that is used to track the breadcrumb.
+ *
+ * @see headersUpdate
+ */
+const TRACKER_BREADCRUMB = "X-Alchemy-Client-Breadcrumb";
+/**
+ * Remove the tracking headers. This is used in our split transport to ensure that we remove the headers that
+ * are not used by the other systems.
+ *
+ * @param {unknown} x The headers to remove the tracking headers from
+ */
+export function mutateRemoveTrackingHeaders(x) {
+    if (!x)
+        return;
+    if (Array.isArray(x))
+        return;
+    if (typeof x !== "object")
+        return;
+    TRACKER_HEADER in x && delete x[TRACKER_HEADER];
+    TRACKER_BREADCRUMB in x && delete x[TRACKER_BREADCRUMB];
+    TRACE_HEADER_NAME in x && delete x[TRACE_HEADER_NAME];
+    TRACE_HEADER_STATE in x && delete x[TRACE_HEADER_STATE];
+}
+function addCrumb(previous, crumb) {
+    if (!previous)
+        return crumb;
+    return `${previous} > ${crumb}`;
+}
+/**
+ * Update the headers with the trace header and breadcrumb.
+ *
+ * These trace headers are used in the imply ingestion pipeline to trace the request.
+ * And the breadcrumb is used to get finer grain details in the trace.
+ *
+ * Then there are the trace headers that are part of the W3C trace context standard.
+ *
+ * @param {string} crumb The crumb to add to the breadcrumb
+ * @returns {Function} A function that updates the headers
+ */
+export function headersUpdate(crumb) {
+    const headerUpdate_ = (x) => {
+        const traceHeader = (TraceHeader.fromTraceHeader(x) || TraceHeader.default()).withEvent(crumb);
+        return {
+            [TRACKER_HEADER]: traceHeader.parentId,
+            ...x,
+            [TRACKER_BREADCRUMB]: addCrumb(x[TRACKER_BREADCRUMB], crumb),
+            ...traceHeader.toTraceHeader(),
+        };
+    };
+    return headerUpdate_;
+}
+//# sourceMappingURL=updateHeaders.js.map

package/dist/esm/tracing/updateHeaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateHeaders.js","sourceRoot":"","sources":["../../../src/tracing/updateHeaders.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,GACZ,MAAM,kBAAkB,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,cAAc,GAAG,2BAA2B,CAAC;AAEnD;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,6BAA6B,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CAAC,CAAW;IACrD,IAAI,CAAC,CAAC;QAAE,OAAO;IACf,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO;IAC7B,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO;IAClC,cAAc,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,cAAc,CAAC,CAAC;IAChD,kBAAkB,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,kBAAkB,CAAC,CAAC;IACxD,iBAAiB,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,iBAAiB,CAAC,CAAC;IACtD,kBAAkB,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,QAAQ,CAAC,QAA4B,EAAE,KAAa;IAC3D,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5B,OAAO,GAAG,QAAQ,MAAM,KAAK,EAAE,CAAC;AAClC,CAAC;AACD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,MAAM,aAAa,GAAG,CAAC,CAAyB,EAAE,EAAE;QAClD,MAAM,WAAW,GAAG,CAClB,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,CACxD,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACnB,OAAO;YACL,CAAC,cAAc,CAAC,EAAE,WAAW,CAAC,QAAQ;YACtC,GAAG,CAAC;YACJ,CAAC,kBAAkB,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,kBAAkB,CAAC,EAAE,KAAK,CAAC;YAC5D,GAAG,WAAW,CAAC,aAAa,EAAE;SAC/B,CAAC;IACJ,CAAC,CAAC;IACF,OAAO,aAAa,CAAC;AACvB,CAAC","sourcesContent":["import {\n  TRACE_HEADER_NAME,\n  TRACE_HEADER_STATE,\n  TraceHeader,\n} from \"./traceHeader.js\";\n\n/**\n * The header that is used to track the trace id.\n * We use a client specific one to not mess with the span tracing of the servers.\n *\n * @see headersUpdate\n */\nconst TRACKER_HEADER = \"X-Alchemy-Client-Trace-Id\";\n\n/**\n * The header that is used to track the breadcrumb.\n *\n * @see headersUpdate\n */\nconst TRACKER_BREADCRUMB = \"X-Alchemy-Client-Breadcrumb\";\n\n/**\n * Remove the tracking headers. This is used in our split transport to ensure that we remove the headers that\n * are not used by the other systems.\n *\n * @param {unknown} x The headers to remove the tracking headers from\n */\nexport function mutateRemoveTrackingHeaders(x?: unknown) {\n  if (!x) return;\n  if (Array.isArray(x)) return;\n  if (typeof x !== \"object\") return;\n  TRACKER_HEADER in x && delete x[TRACKER_HEADER];\n  TRACKER_BREADCRUMB in x && delete x[TRACKER_BREADCRUMB];\n  TRACE_HEADER_NAME in x && delete x[TRACE_HEADER_NAME];\n  TRACE_HEADER_STATE in x && delete x[TRACE_HEADER_STATE];\n}\n\nfunction addCrumb(previous: string | undefined, crumb: string): string {\n  if (!previous) return crumb;\n  return `${previous} > ${crumb}`;\n}\n/**\n * Update the headers with the trace header and breadcrumb.\n *\n * These trace headers are used in the imply ingestion pipeline to trace the request.\n * And the breadcrumb is used to get finer grain details in the trace.\n *\n * Then there are the trace headers that are part of the W3C trace context standard.\n *\n * @param {string} crumb The crumb to add to the breadcrumb\n * @returns {Function} A function that updates the headers\n */\nexport function headersUpdate(crumb: string) {\n  const headerUpdate_ = (x: Record<string, string>) => {\n    const traceHeader = (\n      TraceHeader.fromTraceHeader(x) || TraceHeader.default()\n    ).withEvent(crumb);\n    return {\n      [TRACKER_HEADER]: traceHeader.parentId,\n      ...x,\n      [TRACKER_BREADCRUMB]: addCrumb(x[TRACKER_BREADCRUMB], crumb),\n      ...traceHeader.toTraceHeader(),\n    };\n  };\n  return headerUpdate_;\n}\n"]}

package/dist/esm/transport/alchemy.d.ts

@@ -0,0 +1,110 @@
+import { type Chain, type EIP1193RequestFn, type HttpTransportConfig, type RpcSchema, type Transport } from "viem";
+/**
+ * Configuration options for the Alchemy transport.
+ * Extends viem's HttpTransportConfig with Alchemy-specific options while omitting
+ * options that are not relevant or supported by Alchemy.
+ */
+export interface AlchemyTransportConfig extends Omit<HttpTransportConfig, "batch" | "key" | "methods" | "name" | "raw"> {
+    /** API key for Alchemy authentication */
+    apiKey?: string;
+    /** JWT token for authentication */
+    jwt?: string;
+    /** Custom RPC URL (optional - defaults to chain's Alchemy URL, but can be used to override the chain's Alchemy URL) */
+    url?: string;
+}
+type AlchemyTransportBase<rpcSchema extends RpcSchema | undefined = undefined> = Transport<"alchemyHttp", {
+    alchemyRpcUrl: string;
+    fetchOptions: AlchemyTransportConfig["fetchOptions"];
+    config: AlchemyTransportConfig;
+}, EIP1193RequestFn<rpcSchema>>;
+export type AlchemyTransport<rpcSchema extends RpcSchema | undefined = undefined> = AlchemyTransportBase<rpcSchema> & {
+    updateHeaders(newHeaders: HeadersInit): void;
+};
+/**
+ * A type guard for the transport to determine if it is an Alchemy transport.
+ * Used in cases where we would like to do switching depending on the transport.
+ *
+ * @param {Transport} transport The transport to check
+ * @param {Chain} chain Chain for the transport to run its function to return the transport config
+ * @returns {boolean} `true` if the transport is an Alchemy transport, otherwise `false`
+ */
+export declare function isAlchemyTransport(transport: Transport, chain: Chain): transport is AlchemyTransport;
+/**
+ * Creates an Alchemy HTTP transport for connecting to Alchemy's services.
+ *
+ * @example
+ * Using API Key:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({ apiKey: "your-api-key" });
+ * ```
+ *
+ * @example
+ * Using JWT:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({ jwt: "your-jwt-token" });
+ * ```
+ *
+ * @example
+ * Using URL directly:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({ url: "https://eth-mainnet.g.alchemy.com/v2/your-key" });
+ * ```
+ *
+ * @example
+ * Using custom URL with API key:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({
+ *   url: "https://custom-alchemy.com/v2",
+ *   apiKey: "your-api-key"
+ * });
+ * ```
+ *
+ * @example
+ * Using custom URL with JWT:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({
+ *   url: "https://custom-alchemy.com/v2",
+ *   jwt: "your-jwt-token"
+ * });
+ * ```
+ *
+ * @example
+ * Using HTTP debugging options:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({
+ *   apiKey: "your-api-key",
+ *   onFetchRequest: (request) => console.log("Request:", request),
+ *   onFetchResponse: (response) => console.log("Response:", response),
+ *   timeout: 30000,
+ *   retryCount: 3,
+ *   retryDelay: 1000
+ * });
+ * ```
+ *
+ * @param {AlchemyTransportConfig} config - The configuration object for the Alchemy transport (extends viem's HttpTransportConfig)
+ * @param {string} [config.apiKey] - API key for Alchemy authentication
+ * @param {string} [config.jwt] - JWT token for authentication
+ * @param {string} [config.url] - Direct URL to Alchemy endpoint or a proxy URL
+ * @param {Function} [config.onFetchRequest] - Callback for debugging outgoing requests
+ * @param {Function} [config.onFetchResponse] - Callback for debugging responses
+ * @param {number} [config.timeout] - Request timeout in milliseconds
+ * @param {number} [config.retryCount] - The number of retry attempts
+ * @param {number} [config.retryDelay] - The delay between retries, in milliseconds
+ * @param {object} [config.fetchOptions] - Optional fetch options for HTTP requests
+ * @param {object} [config.httpOptions] - HTTP transport options for debugging (onFetchRequest, onFetchResponse, timeout, batch)
+ * @returns {AlchemyTransport} The configured Alchemy transport function
+ */
+export declare function alchemyTransport<rpcSchema extends RpcSchema | undefined = undefined>(config: AlchemyTransportConfig): AlchemyTransport<rpcSchema>;
+export {};

package/dist/esm/transport/alchemy.js

@@ -0,0 +1,164 @@
+import { createTransport, http, } from "viem";
+import { BaseError } from "../errors/BaseError.js";
+import { mutateRemoveTrackingHeaders } from "../tracing/updateHeaders.js";
+import { ChainNotFoundError } from "../errors/ChainNotFoundError.js";
+import { getAlchemyRpcUrl } from "./chainRegistry.js";
+import { convertHeadersToObject, withAlchemyHeaders, } from "../utils/headers.js";
+/**
+ * A type guard for the transport to determine if it is an Alchemy transport.
+ * Used in cases where we would like to do switching depending on the transport.
+ *
+ * @param {Transport} transport The transport to check
+ * @param {Chain} chain Chain for the transport to run its function to return the transport config
+ * @returns {boolean} `true` if the transport is an Alchemy transport, otherwise `false`
+ */
+export function isAlchemyTransport(transport, chain) {
+    return transport({ chain }).config.type === "alchemyHttp";
+}
+/**
+ * Creates an Alchemy HTTP transport for connecting to Alchemy's services.
+ *
+ * @example
+ * Using API Key:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({ apiKey: "your-api-key" });
+ * ```
+ *
+ * @example
+ * Using JWT:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({ jwt: "your-jwt-token" });
+ * ```
+ *
+ * @example
+ * Using URL directly:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({ url: "https://eth-mainnet.g.alchemy.com/v2/your-key" });
+ * ```
+ *
+ * @example
+ * Using custom URL with API key:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({
+ *   url: "https://custom-alchemy.com/v2",
+ *   apiKey: "your-api-key"
+ * });
+ * ```
+ *
+ * @example
+ * Using custom URL with JWT:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({
+ *   url: "https://custom-alchemy.com/v2",
+ *   jwt: "your-jwt-token"
+ * });
+ * ```
+ *
+ * @example
+ * Using HTTP debugging options:
+ * ```ts
+ * import { alchemyTransport } from "@alchemy/common";
+ *
+ * const transport = alchemyTransport({
+ *   apiKey: "your-api-key",
+ *   onFetchRequest: (request) => console.log("Request:", request),
+ *   onFetchResponse: (response) => console.log("Response:", response),
+ *   timeout: 30000,
+ *   retryCount: 3,
+ *   retryDelay: 1000
+ * });
+ * ```
+ *
+ * @param {AlchemyTransportConfig} config - The configuration object for the Alchemy transport (extends viem's HttpTransportConfig)
+ * @param {string} [config.apiKey] - API key for Alchemy authentication
+ * @param {string} [config.jwt] - JWT token for authentication
+ * @param {string} [config.url] - Direct URL to Alchemy endpoint or a proxy URL
+ * @param {Function} [config.onFetchRequest] - Callback for debugging outgoing requests
+ * @param {Function} [config.onFetchResponse] - Callback for debugging responses
+ * @param {number} [config.timeout] - Request timeout in milliseconds
+ * @param {number} [config.retryCount] - The number of retry attempts
+ * @param {number} [config.retryDelay] - The delay between retries, in milliseconds
+ * @param {object} [config.fetchOptions] - Optional fetch options for HTTP requests
+ * @param {object} [config.httpOptions] - HTTP transport options for debugging (onFetchRequest, onFetchResponse, timeout, batch)
+ * @returns {AlchemyTransport} The configured Alchemy transport function
+ */
+export function alchemyTransport(config) {
+    const { apiKey, jwt, url, fetchOptions: fetchOptions_, retryCount, retryDelay, ...httpTransportConfig } = config;
+    // Create a copy of fetch options for modification
+    const fetchOptions = { ...fetchOptions_ };
+    fetchOptions.headers = withAlchemyHeaders({
+        headers: fetchOptions.headers,
+        apiKey,
+        jwt,
+    });
+    const transport = (opts) => {
+        const { chain } = opts;
+        mutateRemoveTrackingHeaders(config?.fetchOptions?.headers);
+        const rpcUrl = (() => {
+            if (url) {
+                return url;
+            }
+            if (!chain) {
+                throw new ChainNotFoundError();
+            }
+            const alchemyUrl = getAlchemyRpcUrl(chain.id);
+            if (alchemyUrl) {
+                return alchemyUrl;
+            }
+            // Fallback: check for legacy alchemy RPC URLs in chain definition
+            if (chain.rpcUrls?.alchemy?.http?.[0]) {
+                return chain.rpcUrls.alchemy.http[0];
+            }
+            throw new BaseError(`Chain ${chain.id} (${chain.name}) is not supported by Alchemy. To use this chain:\n\n` +
+                `1. Use a direct RPC URL:\n` +
+                `   alchemyTransport({ url: "https://your-alchemy-endpoint.com/v2/your-key" })\n\n` +
+                `2. Add alchemy RPC to your chain definition:\n` +
+                `   defineChain({ rpcUrls: { alchemy: { http: ["https://your-alchemy-url/v2"] }}})\n\n` +
+                `3. Or use a standard RPC provider:\n` +
+                `   import { http } from "viem";\n` +
+                `   http("https://your-standard-rpc.com")`);
+        })();
+        const innerTransport = http(rpcUrl, {
+            // Standard viem options are passed through to the underlying transport, with
+            // the exception of retryCount and retryDelay because those are handled by
+            // the outer Alchemy transport.
+            ...httpTransportConfig,
+            fetchOptions,
+            // Retry count must be 0 here in order to respect the retry
+            // count that is already specified on the underlying transport.
+            retryCount: 0,
+        });
+        return createTransport({
+            key: "alchemyHttp",
+            name: "Alchemy HTTP Transport",
+            request: innerTransport(opts).request,
+            retryCount: retryCount ?? opts?.retryCount,
+            retryDelay,
+            type: "alchemyHttp",
+        }, {
+            alchemyRpcUrl: rpcUrl,
+            fetchOptions,
+            config,
+        });
+    };
+    return Object.assign(transport, {
+        updateHeaders(newHeaders_) {
+            const newHeaders = convertHeadersToObject(newHeaders_);
+            fetchOptions.headers = {
+                ...fetchOptions.headers,
+                ...newHeaders,
+            };
+        },
+    });
+}
+//# sourceMappingURL=alchemy.js.map

package/dist/esm/transport/alchemy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alchemy.js","sourceRoot":"","sources":["../../../src/transport/alchemy.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createTransport,\n  http,\n  type Chain,\n  type EIP1193RequestFn,\n  type HttpTransportConfig,\n  type RpcSchema,\n  type Transport,\n} from \"viem\";\nimport { BaseError } from \"../errors/BaseError.js\";\nimport { mutateRemoveTrackingHeaders } from \"../tracing/updateHeaders.js\";\nimport { ChainNotFoundError } from \"../errors/ChainNotFoundError.js\";\nimport { getAlchemyRpcUrl } from \"./chainRegistry.js\";\nimport {\n  convertHeadersToObject,\n  withAlchemyHeaders,\n} from \"../utils/headers.js\";\n\n/**\n * Configuration options for the Alchemy transport.\n * Extends viem's HttpTransportConfig with Alchemy-specific options while omitting\n * options that are not relevant or supported by Alchemy.\n */\nexport interface AlchemyTransportConfig\n  extends Omit<\n    HttpTransportConfig,\n    \"batch\" | \"key\" | \"methods\" | \"name\" | \"raw\"\n  > {\n  /** API key for Alchemy authentication */\n  apiKey?: string;\n  /** JWT token for authentication */\n  jwt?: string;\n  /** Custom RPC URL (optional - defaults to chain's Alchemy URL, but can be used to override the chain's Alchemy URL) */\n  url?: string;\n}\n\ntype AlchemyTransportBase<rpcSchema extends RpcSchema | undefined = undefined> =\n  Transport<\n    \"alchemyHttp\",\n    {\n      alchemyRpcUrl: string;\n      fetchOptions: AlchemyTransportConfig[\"fetchOptions\"];\n      config: AlchemyTransportConfig;\n    },\n    EIP1193RequestFn<rpcSchema>\n  >;\n\nexport type AlchemyTransport<\n  rpcSchema extends RpcSchema | undefined = undefined,\n> = AlchemyTransportBase<rpcSchema> & {\n  updateHeaders(newHeaders: HeadersInit): void;\n};\n\n/**\n * A type guard for the transport to determine if it is an Alchemy transport.\n * Used in cases where we would like to do switching depending on the transport.\n *\n * @param {Transport} transport The transport to check\n * @param {Chain} chain Chain for the transport to run its function to return the transport config\n * @returns {boolean} `true` if the transport is an Alchemy transport, otherwise `false`\n */\nexport function isAlchemyTransport(\n  transport: Transport,\n  chain: Chain,\n): transport is AlchemyTransport {\n  return transport({ chain }).config.type === \"alchemyHttp\";\n}\n\n/**\n * Creates an Alchemy HTTP transport for connecting to Alchemy's services.\n *\n * @example\n * Using API Key:\n * ```ts\n * import { alchemyTransport } from \"@alchemy/common\";\n *\n * const transport = alchemyTransport({ apiKey: \"your-api-key\" });\n * ```\n *\n * @example\n * Using JWT:\n * ```ts\n * import { alchemyTransport } from \"@alchemy/common\";\n *\n * const transport = alchemyTransport({ jwt: \"your-jwt-token\" });\n * ```\n *\n * @example\n * Using URL directly:\n * ```ts\n * import { alchemyTransport } from \"@alchemy/common\";\n *\n * const transport = alchemyTransport({ url: \"https://eth-mainnet.g.alchemy.com/v2/your-key\" });\n * ```\n *\n * @example\n * Using custom URL with API key:\n * ```ts\n * import { alchemyTransport } from \"@alchemy/common\";\n *\n * const transport = alchemyTransport({\n *   url: \"https://custom-alchemy.com/v2\",\n *   apiKey: \"your-api-key\"\n * });\n * ```\n *\n * @example\n * Using custom URL with JWT:\n * ```ts\n * import { alchemyTransport } from \"@alchemy/common\";\n *\n * const transport = alchemyTransport({\n *   url: \"https://custom-alchemy.com/v2\",\n *   jwt: \"your-jwt-token\"\n * });\n * ```\n *\n * @example\n * Using HTTP debugging options:\n * ```ts\n * import { alchemyTransport } from \"@alchemy/common\";\n *\n * const transport = alchemyTransport({\n *   apiKey: \"your-api-key\",\n *   onFetchRequest: (request) => console.log(\"Request:\", request),\n *   onFetchResponse: (response) => console.log(\"Response:\", response),\n *   timeout: 30000,\n *   retryCount: 3,\n *   retryDelay: 1000\n * });\n * ```\n *\n * @param {AlchemyTransportConfig} config - The configuration object for the Alchemy transport (extends viem's HttpTransportConfig)\n * @param {string} [config.apiKey] - API key for Alchemy authentication\n * @param {string} [config.jwt] - JWT token for authentication\n * @param {string} [config.url] - Direct URL to Alchemy endpoint or a proxy URL\n * @param {Function} [config.onFetchRequest] - Callback for debugging outgoing requests\n * @param {Function} [config.onFetchResponse] - Callback for debugging responses\n * @param {number} [config.timeout] - Request timeout in milliseconds\n * @param {number} [config.retryCount] - The number of retry attempts\n * @param {number} [config.retryDelay] - The delay between retries, in milliseconds\n * @param {object} [config.fetchOptions] - Optional fetch options for HTTP requests\n * @param {object} [config.httpOptions] - HTTP transport options for debugging (onFetchRequest, onFetchResponse, timeout, batch)\n * @returns {AlchemyTransport} The configured Alchemy transport function\n */\nexport function alchemyTransport<\n  rpcSchema extends RpcSchema | undefined = undefined,\n>(config: AlchemyTransportConfig): AlchemyTransport<rpcSchema> {\n  const {\n    apiKey,\n    jwt,\n    url,\n    fetchOptions: fetchOptions_,\n    retryCount,\n    retryDelay,\n    ...httpTransportConfig\n  } = config;\n\n  // Create a copy of fetch options for modification\n  const fetchOptions = { ...fetchOptions_ };\n\n  fetchOptions.headers = withAlchemyHeaders({\n    headers: fetchOptions.headers,\n    apiKey,\n    jwt,\n  });\n\n  const transport: AlchemyTransportBase = (opts) => {\n    const { chain } = opts;\n\n    mutateRemoveTrackingHeaders(config?.fetchOptions?.headers);\n\n    const rpcUrl = (() => {\n      if (url) {\n        return url;\n      }\n\n      if (!chain) {\n        throw new ChainNotFoundError();\n      }\n\n      const alchemyUrl = getAlchemyRpcUrl(chain.id);\n      if (alchemyUrl) {\n        return alchemyUrl;\n      }\n\n      // Fallback: check for legacy alchemy RPC URLs in chain definition\n      if (chain.rpcUrls?.alchemy?.http?.[0]) {\n        return chain.rpcUrls.alchemy.http[0];\n      }\n\n      throw new BaseError(\n        `Chain ${chain.id} (${chain.name}) is not supported by Alchemy. To use this chain:\\n\\n` +\n          `1. Use a direct RPC URL:\\n` +\n          `   alchemyTransport({ url: \"https://your-alchemy-endpoint.com/v2/your-key\" })\\n\\n` +\n          `2. Add alchemy RPC to your chain definition:\\n` +\n          `   defineChain({ rpcUrls: { alchemy: { http: [\"https://your-alchemy-url/v2\"] }}})\\n\\n` +\n          `3. Or use a standard RPC provider:\\n` +\n          `   import { http } from \"viem\";\\n` +\n          `   http(\"https://your-standard-rpc.com\")`,\n      );\n    })();\n\n    const innerTransport = http(rpcUrl, {\n      // Standard viem options are passed through to the underlying transport, with\n      // the exception of retryCount and retryDelay because those are handled by\n      // the outer Alchemy transport.\n      ...httpTransportConfig,\n      fetchOptions,\n      // Retry count must be 0 here in order to respect the retry\n      // count that is already specified on the underlying transport.\n      retryCount: 0,\n    });\n\n    return createTransport(\n      {\n        key: \"alchemyHttp\",\n        name: \"Alchemy HTTP Transport\",\n        request: innerTransport(opts).request,\n        retryCount: retryCount ?? opts?.retryCount,\n        retryDelay,\n        type: \"alchemyHttp\",\n      },\n      {\n        alchemyRpcUrl: rpcUrl,\n        fetchOptions,\n        config,\n      },\n    );\n  };\n\n  return Object.assign(transport, {\n    updateHeaders(newHeaders_: HeadersInit) {\n      const newHeaders = convertHeadersToObject(newHeaders_);\n\n      fetchOptions.headers = {\n        ...fetchOptions.headers,\n        ...newHeaders,\n      };\n    },\n  });\n}\n"]}

package/dist/esm/transport/chainRegistry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Internal registry mapping chain IDs to Alchemy RPC base URLs.
+ * This replaces the need for custom chain exports with embedded Alchemy URLs.
+ */
+export declare const ALCHEMY_RPC_MAPPING: Record<number, string>;
+/**
+ * Gets the Alchemy RPC base URL for a given chain ID.
+ *
+ * @param {number} chainId The chain ID to lookup
+ * @returns {string | undefined} The Alchemy RPC base URL or undefined if not supported
+ *
+ * @example
+ * ```ts
+ * const rpcUrl = getAlchemyRpcUrl(1); // "https://eth-mainnet.g.alchemy.com/v2"
+ * const customUrl = getAlchemyRpcUrl(999); // undefined
+ * ```
+ */
+export declare function getAlchemyRpcUrl(chainId: number): string | undefined;
+/**
+ * Checks if a chain ID is supported by the Alchemy RPC registry.
+ *
+ * @param {number} chainId The chain ID to check
+ * @returns {boolean} True if the chain is supported, false otherwise
+ */
+export declare function isChainSupported(chainId: number): boolean;
+/**
+ * Gets all supported chain IDs from the registry.
+ *
+ * @returns {number[]} Array of supported chain IDs
+ */
+export declare function getSupportedChainIds(): number[];