@alchemy/common 0.0.0-alpha.0

package/dist/types/tracing/traceHeader.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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 declare 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 declare const TRACE_HEADER_STATE = "tracestate";
+/**
+ * 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 declare class TraceHeader {
+    readonly traceId: string;
+    readonly parentId: string;
+    readonly traceFlags: string;
+    readonly traceState: Record<string, string>;
+    /**
+     * 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: string, parentId: string, traceFlags: string, traceState: TraceHeader["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(): TraceHeader;
+    /**
+     * 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: Record<string, string>): TraceHeader | undefined;
+    /**
+     * 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(): {
+        readonly traceparent: `00-${string}-${string}-${string}`;
+        readonly tracestate: string;
+    };
+    /**
+     * 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: string): TraceHeader;
+}
+//# sourceMappingURL=traceHeader.d.ts.map

package/dist/types/tracing/traceHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceHeader.d.ts","sourceRoot":"","sources":["../../../src/tracing/traceHeader.ts"],"names":[],"mappings":"AASA;;;;GAIG;AAEH,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAC/C;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAG/C;;;;;GAKG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE5C;;;;;;;OAOG;gBAED,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC;IAQvC;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAO;IAQd;;;;;;;;;OASG;IACH,MAAM,CAAC,eAAe,CACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,WAAW,GAAG,SAAS;IA2B1B;;;;;;;;;OASG;IACH,aAAa;;;;IASb;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW;CAS1C"}

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

@@ -0,0 +1,25 @@
+/**
+ * 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;
+};
+//# sourceMappingURL=updateHeaders.d.ts.map

package/dist/types/tracing/updateHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateHeaders.d.ts","sourceRoot":"","sources":["../../../src/tracing/updateHeaders.ts"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,CAAC,EAAE,OAAO,QAQtD;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,OACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;EAYjD"}

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

@@ -0,0 +1,111 @@
+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 {};
+//# sourceMappingURL=alchemy.d.ts.map

package/dist/types/transport/alchemy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alchemy.d.ts","sourceRoot":"","sources":["../../../src/transport/alchemy.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,MAAM,CAAC;AAUd;;;;GAIG;AACH,MAAM,WAAW,sBACf,SAAQ,IAAI,CACV,mBAAmB,EACnB,OAAO,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,CAC7C;IACD,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uHAAuH;IACvH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,KAAK,oBAAoB,CAAC,SAAS,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,IAC3E,SAAS,CACP,aAAa,EACb;IACE,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;IACrD,MAAM,EAAE,sBAAsB,CAAC;CAChC,EACD,gBAAgB,CAAC,SAAS,CAAC,CAC5B,CAAC;AAEJ,MAAM,MAAM,gBAAgB,CAC1B,SAAS,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,IACjD,oBAAoB,CAAC,SAAS,CAAC,GAAG;IACpC,aAAa,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC;CAC9C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,KAAK,GACX,SAAS,IAAI,gBAAgB,CAE/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,EACnD,MAAM,EAAE,sBAAsB,GAAG,gBAAgB,CAAC,SAAS,CAAC,CA8F7D"}

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

@@ -0,0 +1,32 @@
+/**
+ * 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[];
+//# sourceMappingURL=chainRegistry.d.ts.map

package/dist/types/transport/chainRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainRegistry.d.ts","sourceRoot":"","sources":["../../../src/transport/chainRegistry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2EtD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C"}

package/dist/types/transport/connection.d.ts

@@ -0,0 +1,21 @@
+import type { Never } from "../utils/types";
+type AlchemyConnectionBaseConfig = {
+    proxyUrl: string;
+    apiKey?: never;
+    jwt?: never;
+} | {
+    proxyUrl?: never;
+    apiKey: string;
+    jwt?: never;
+} | {
+    proxyUrl?: never;
+    apiKey?: never;
+    jwt: string;
+};
+type AAOnlyChainConfig = {
+    alchemyConnection: AlchemyConnectionBaseConfig;
+    nodeRpcUrl: string;
+};
+export type AlchemyConnectionConfig = (AlchemyConnectionBaseConfig & Never<AAOnlyChainConfig>) | (AAOnlyChainConfig & Never<AlchemyConnectionBaseConfig>);
+export {};
+//# sourceMappingURL=connection.d.ts.map

package/dist/types/transport/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../src/transport/connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAG5C,KAAK,2BAA2B,GAI5B;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;IAAC,GAAG,CAAC,EAAE,KAAK,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,KAAK,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD,KAAK,iBAAiB,GAAG;IACvB,iBAAiB,EAAE,2BAA2B,CAAC;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAC/B,CAAC,2BAA2B,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAC,GACxD,CAAC,iBAAiB,GAAG,KAAK,CAAC,2BAA2B,CAAC,CAAC,CAAC"}

package/dist/types/transport/connectionSchema.d.ts

@@ -0,0 +1,125 @@
+import { z } from "zod";
+/**
+ * Alchemy Connection Configuration Schema
+ *
+ * Provides three authentication options for connecting to Alchemy services:
+ *
+ * 1. **API Key**: Authenticate using your Alchemy API key
+ * 2. **JWT**: Authenticate using a JWT token
+ * 3. **URL**: Connect directly using a full RPC URL
+ *
+ * @example
+ * Using API Key (uses chain's Alchemy URL):
+ * ```ts
+ * { apiKey: 'abc123' }
+ * ```
+ *
+ * @example
+ * Using JWT (uses chain's Alchemy URL):
+ * ```ts
+ * { jwt: 'eyJhbGc...' }
+ * ```
+ *
+ * @example
+ * Using direct URL only:
+ * ```ts
+ * { url: 'https://eth-mainnet.g.alchemy.com/v2/your-key' }
+ * ```
+ *
+ * @example
+ * Using custom URL with API key:
+ * ```ts
+ * { url: 'https://custom-alchemy.com/v2', apiKey: 'abc123' }
+ * ```
+ *
+ * @example
+ * Using custom URL with JWT:
+ * ```ts
+ * { url: 'https://custom-alchemy.com/v2', jwt: 'eyJhbGc...' }
+ * ```
+ */
+/**
+ * Main connection configuration allowing flexible combinations.
+ * Can specify URL, auth method, or both together.
+ */
+export declare const AlchemyConnectionConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    /** API key for Alchemy authentication */
+    apiKey: z.ZodOptional<z.ZodString>;
+    /** JWT token for authentication */
+    jwt: z.ZodOptional<z.ZodString>;
+    /** Custom RPC URL (optional - defaults to chain's Alchemy URL) */
+    url: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    apiKey?: string | undefined;
+    jwt?: string | undefined;
+    url?: string | undefined;
+}, {
+    apiKey?: string | undefined;
+    jwt?: string | undefined;
+    url?: string | undefined;
+}>, {
+    apiKey?: string | undefined;
+    jwt?: string | undefined;
+    url?: string | undefined;
+}, {
+    apiKey?: string | undefined;
+    jwt?: string | undefined;
+    url?: string | undefined;
+}>, {
+    apiKey?: string | undefined;
+    jwt?: string | undefined;
+    url?: string | undefined;
+}, {
+    apiKey?: string | undefined;
+    jwt?: string | undefined;
+    url?: string | undefined;
+}>;
+/**
+ * TypeScript type derived from the schema for external consumption.
+ * This provides clean type inference without exposing Zod implementation details.
+ */
+export type AlchemyConnectionConfig = z.infer<typeof AlchemyConnectionConfigSchema>;
+/**
+ * Validates an Alchemy connection configuration object.
+ *
+ * @param {unknown} config - The configuration object to validate
+ * @returns {AlchemyConnectionConfig} The validated configuration object
+ * @throws {ConnectionConfigError} If the configuration is invalid
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const config = validateAlchemyConnectionConfig({
+ *     apiKey: 'your-api-key'
+ *   });
+ *   // config is now typed as AlchemyConnectionConfig
+ * } catch (error) {
+ *   if (error instanceof ConnectionConfigError) {
+ *     console.error('Invalid config:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export declare function validateAlchemyConnectionConfig(config: unknown): AlchemyConnectionConfig;
+/**
+ * Type guard to check if a value is a valid Alchemy connection config.
+ *
+ * @param {unknown} value - The value to check for validity
+ * @returns {boolean} True if the value is a valid Alchemy connection config
+ *
+ * @example
+ * ```ts
+ * const maybeConfig: unknown = { apiKey: 'test' };
+ * if (isAlchemyConnectionConfig(maybeConfig)) {
+ *   // TypeScript knows maybeConfig is AlchemyConnectionConfig here
+ *   if (maybeConfig.apiKey) {
+ *     console.log('Using API key:', maybeConfig.apiKey);
+ *   }
+ *   if (maybeConfig.url) {
+ *     console.log('Using custom URL:', maybeConfig.url);
+ *   }
+ * }
+ * ```
+ */
+export declare function isAlchemyConnectionConfig(value: unknown): value is AlchemyConnectionConfig;
+//# sourceMappingURL=connectionSchema.d.ts.map

package/dist/types/transport/connectionSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionSchema.d.ts","sourceRoot":"","sources":["../../../src/transport/connectionSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;GAGG;AACH,eAAO,MAAM,6BAA6B;IAEtC,yCAAyC;;IAEzC,mCAAmC;;IAEnC,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBnE,CAAC;AAEJ;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,OAAO,GACd,uBAAuB,CAUzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,uBAAuB,CAElC"}

package/dist/types/utils/assertNever.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Asserts that a value is never.
+ *
+ * @param {never} _x - The value to assert.
+ * @param {string} msg - The message to throw if the value is not never.
+ * @returns {never} Always throws an error.
+ */
+export declare const assertNever: (_x: never, msg: string) => never;
+//# sourceMappingURL=assertNever.d.ts.map

package/dist/types/utils/assertNever.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertNever.d.ts","sourceRoot":"","sources":["../../../src/utils/assertNever.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,IAAI,KAAK,EAAE,KAAK,MAAM,KAAG,KAEpD,CAAC"}

package/dist/types/utils/bigint.d.ts

@@ -0,0 +1,25 @@
+/**
+ * BigNumberish represents values that can be converted to BigInt
+ */
+export type BigNumberish = string | number | bigint;
+/**
+ * Multiplier configuration for bigint multiplication
+ */
+export type Multiplier = {
+    multiplier: number;
+};
+export declare enum RoundingMode {
+    ROUND_DOWN = 0,
+    ROUND_UP = 1
+}
+/**
+ * Given a bigint and a number (which can be a float), returns the bigint value.
+ * Note: this function has loss and will round down to the nearest integer.
+ *
+ * @param {BigNumberish} base - the number to be multiplied
+ * @param {number} multiplier - the amount to multiply by
+ * @param {RoundingMode} roundingMode - the rounding mode to use when calculating the percent. defaults to ROUND_UP
+ * @returns {bigint} the bigint value of the multiplication with the number rounded by the rounding mode
+ */
+export declare const bigIntMultiply: (base: BigNumberish, multiplier: Multiplier["multiplier"], roundingMode?: RoundingMode) => bigint;
+//# sourceMappingURL=bigint.d.ts.map

package/dist/types/utils/bigint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint.d.ts","sourceRoot":"","sources":["../../../src/utils/bigint.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,oBAAY,YAAY;IACtB,UAAU,IAAI;IACd,QAAQ,IAAI;CACb;AAcD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,YAAY,EAClB,YAAY,UAAU,CAAC,YAAY,CAAC,EACpC,eAAc,YAAoC,WAgBnD,CAAC"}

package/dist/types/utils/createEip1193HandlerFactory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates a typed handler factory for EIP1193 request methods.
+ * This helps with Viem's typing within custom EIP1193 request functions by
+ * automatically casting input params and ensuring the result matches what is required.
+ *
+ * @returns {(params: unknown) => unknown} A function that creates a handler factory for specific methods
+ */
+export declare const createEip1193HandlerFactory: <TMethods extends readonly {
+    Method: string;
+    Parameters?: unknown;
+    ReturnType?: unknown;
+}[]>() => <TMethod extends TMethods[number]["Method"]>(handle: (params: Extract<TMethods[number], {
+    Method: TMethod;
+}>["Parameters"]) => Promise<Extract<TMethods[number], {
+    Method: TMethod;
+}>["ReturnType"]>) => (params: unknown) => Promise<Extract<TMethods[number], {
+    Method: TMethod;
+}>["ReturnType"]>;
+//# sourceMappingURL=createEip1193HandlerFactory.d.ts.map

package/dist/types/utils/createEip1193HandlerFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEip1193HandlerFactory.d.ts","sourceRoot":"","sources":["../../../src/utils/createEip1193HandlerFactory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GAEpC,QAAQ,SAAS,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,EAAE,QAEJ,OAAO,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EACzC,QAAQ,CACN,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,YAAY,CAAC,KACjE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,YAAY,CAAC,CAAC,MAE3E,QAAQ,OAAO;YAFmC,OAAO;iBAMzD,CAAC"}

package/dist/types/utils/headers.d.ts

@@ -0,0 +1,8 @@
+export type WithAlchemyHeadersParams = {
+    headers?: HeadersInit;
+    apiKey?: string;
+    jwt?: string;
+};
+export declare function withAlchemyHeaders({ headers, apiKey, jwt, }: WithAlchemyHeadersParams): Record<string, string>;
+export declare function convertHeadersToObject(headers?: HeadersInit): Record<string, string>;
+//# sourceMappingURL=headers.d.ts.map

package/dist/types/utils/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../src/utils/headers.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EACjC,OAAO,EACP,MAAM,EACN,GAAG,GACJ,EAAE,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOnD;AAED,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwBxB"}

package/dist/types/utils/lowerAddress.d.ts

@@ -0,0 +1,9 @@
+import { type Address } from "viem";
+/**
+ * Lowercase an address
+ *
+ * @param {Address} addr - The address to lowercase
+ * @returns {Address} The lowercase address
+ */
+export declare const lowerAddress: (addr: Address) => Address;
+//# sourceMappingURL=lowerAddress.d.ts.map

package/dist/types/utils/lowerAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowerAddress.d.ts","sourceRoot":"","sources":["../../../src/utils/lowerAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,OAAO,KAAG,OACd,CAAC"}

package/dist/types/utils/raise.d.ts

@@ -0,0 +1,9 @@
+import { BaseError } from "viem";
+/**
+ * Raises an error.
+ *
+ * @param {string | BaseError} err - The error to raise.
+ * @returns {never} Always throws an error.
+ */
+export declare const raise: (err: string | BaseError) => never;
+//# sourceMappingURL=raise.d.ts.map

package/dist/types/utils/raise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raise.d.ts","sourceRoot":"","sources":["../../../src/utils/raise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK,MAAM,GAAG,SAAS,KAAG,KAK/C,CAAC"}

package/dist/types/utils/types.d.ts

@@ -0,0 +1,11 @@
+export type Never<T> = T extends object ? {
+    [K in keyof T]?: never;
+} : never;
+export type ExtractRpcMethod<T extends readonly {
+    Method: string;
+    Parameters?: unknown;
+    ReturnType: unknown;
+}[], M extends T[number]["Method"]> = Extract<T[number], {
+    Method: M;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GACnC;KACG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK;CACvB,GACD,KAAK,CAAC;AAEV,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,SAAS;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;CACrB,EAAE,EACH,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,IAC3B,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE;IAAE,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC"}

package/dist/types/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.0.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/types/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@alchemy/common",
+  "version": "0.0.0-alpha.0",
+  "description": "A collection of interfaces and utilities to be used by other Alchemy packages",
+  "author": "Alchemy",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "./dist/esm/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "typings": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src/**/*.ts",
+    "!dist/**/*.tsbuildinfo",
+    "!vitest.config.ts",
+    "!.env",
+    "!src/**/*.test.ts",
+    "!src/**/*.test-d.ts",
+    "!src/__tests__/**/*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./chains": {
+      "types": "./dist/types/chains.d.ts",
+      "import": "./dist/esm/chains.js",
+      "default": "./dist/esm/chains.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "prebuild": "tsx ./inject-version.ts",
+    "build": "yarn clean && yarn build:esm && yarn build:types",
+    "build:esm": "tsc --project tsconfig.build.json --outDir ./dist/esm",
+    "build:types": "tsc --project tsconfig.build.json --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
+    "clean": "rm -rf ./dist",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "devDependencies": {
+    "typescript-template": "*"
+  },
+  "dependencies": {
+    "@aa-sdk/core": "*",
+    "@account-kit/infra": "*",
+    "viem": "^2.32.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alchemyplatform/aa-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alchemyplatform/aa-sdk/issues"
+  },
+  "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
+  "gitHead": "c0301f7bb5f4499fe35b5850293be6170057fae6"
+}