@nktkas/hyperliquid 0.25.0-beta.1 → 0.25.0-beta.3

package/src/src/signing/signTypedData/mod.ts

@@ -0,0 +1,121 @@
+import {
+    type AbstractEthersV5Signer,
+    type AbstractEthersV6Signer,
+    isAbstractEthersV5Signer,
+    isAbstractEthersV6Signer,
+} from "./ethers.js";
+import { isValidPrivateKey, privateKeyToAddress, signTypedData as signTypedDataWithPrivateKey } from "./private_key.js";
+import { type AbstractViemJsonRpcAccount, type AbstractViemLocalAccount, isAbstractViemWallet } from "./viem.js";
+
+/** Abstract interface for a wallet that can sign typed data. */
+export type AbstractWallet =
+    | `0x${string}` // Private key
+    | AbstractViemJsonRpcAccount
+    | AbstractViemLocalAccount
+    | AbstractEthersV6Signer
+    | AbstractEthersV5Signer;
+
+/** ECDSA signature components for Ethereum transactions and typed data. */
+export interface Signature {
+    /** First 32-byte component of ECDSA signature */
+    r: `0x${string}`;
+    /** Second 32-byte component of ECDSA signature */
+    s: `0x${string}`;
+    /** Recovery identifier */
+    v: 27 | 28;
+}
+
+export async function signTypedData(args: {
+    wallet: AbstractWallet;
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        [key: string]: {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: string;
+    message: Record<string, unknown>;
+}): Promise<Signature> {
+    const { wallet, domain, types, primaryType, message } = args;
+
+    let signature: `0x${string}`;
+    if (isAbstractViemWallet(wallet)) {
+        signature = await wallet.signTypedData({
+            domain,
+            types: {
+                EIP712Domain: [
+                    { name: "name", type: "string" },
+                    { name: "version", type: "string" },
+                    { name: "chainId", type: "uint256" },
+                    { name: "verifyingContract", type: "address" },
+                ],
+                ...types,
+            },
+            primaryType,
+            message,
+        });
+    } else if (isAbstractEthersV6Signer(wallet)) {
+        signature = await wallet.signTypedData(domain, types, message) as `0x${string}`;
+    } else if (isAbstractEthersV5Signer(wallet)) {
+        signature = await wallet._signTypedData(domain, types, message) as `0x${string}`;
+    } else if (isValidPrivateKey(wallet)) {
+        signature = await signTypedDataWithPrivateKey({ privateKey: wallet, domain, types, primaryType, message });
+    } else {
+        throw new Error("Unsupported wallet for signing typed data");
+    }
+
+    return splitSignature(signature);
+}
+
+function splitSignature(signature: `0x${string}`): Signature {
+    const r = `0x${signature.slice(2, 66)}` as const;
+    const s = `0x${signature.slice(66, 130)}` as const;
+    const v = parseInt(signature.slice(130, 132), 16) as 27 | 28;
+    return { r, s, v };
+}
+
+/** Get the chain ID of the wallet. */
+export async function getWalletChainId(wallet: AbstractWallet): Promise<`0x${string}`> {
+    if (isAbstractViemWallet(wallet)) {
+        if ("getChainId" in wallet && wallet.getChainId) {
+            const chainId = await wallet.getChainId();
+            return `0x${chainId.toString(16)}`;
+        } else {
+            return "0x1";
+        }
+    } else if (isAbstractEthersV6Signer(wallet) || isAbstractEthersV5Signer(wallet)) {
+        if ("provider" in wallet && wallet.provider) {
+            const network = await wallet.provider.getNetwork();
+            return `0x${network.chainId.toString(16)}`;
+        } else {
+            return "0x1";
+        }
+    } else {
+        return "0x1";
+    }
+}
+
+/** Get the wallet address from various wallet types. */
+export async function getWalletAddress(wallet: AbstractWallet): Promise<`0x${string}`> {
+    if (isAbstractViemWallet(wallet)) {
+        if ("address" in wallet && wallet.address) {
+            return wallet.address;
+        } else if ("getAddresses" in wallet && wallet.getAddresses) {
+            const addresses = await wallet.getAddresses();
+            return addresses[0];
+        }
+    } else if (isAbstractEthersV6Signer(wallet) || isAbstractEthersV5Signer(wallet)) {
+        if ("getAddress" in wallet && wallet.getAddress) {
+            return await wallet.getAddress() as `0x${string}`;
+        }
+    } else if (isValidPrivateKey(wallet)) {
+        return privateKeyToAddress(wallet);
+    }
+    throw new Error("Unsupported wallet for getting address");
+}

package/src/src/signing/signTypedData/private_key.ts

@@ -0,0 +1,234 @@
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { etc, getPublicKey, signAsync, utils } from "@noble/secp256k1";
+
+interface Types {
+    [type: string]: {
+        name: string;
+        type: string;
+    }[];
+}
+
+interface Domain extends Record<string, unknown> {
+    name?: string;
+    version?: string;
+    chainId?: number | string | bigint | `0x${string}`;
+    verifyingContract?: `0x${string}`;
+    salt?: `0x${string}`;
+}
+
+/** Signs typed data with a private key. */
+export async function signTypedData(args: {
+    privateKey: string;
+    domain?: Domain;
+    types: Types;
+    primaryType: string;
+    message: Record<string, unknown>;
+}): Promise<`0x${string}`> {
+    const {
+        privateKey,
+        domain = {},
+        types,
+        primaryType,
+        message,
+    } = args;
+
+    const hash = hashTypedData({ domain, types, primaryType, message });
+
+    const signature = await signAsync(
+        hash,
+        etc.hexToBytes(cleanHex(privateKey)),
+        { prehash: false, format: "recovered" },
+    );
+
+    const r = etc.bytesToHex(signature.slice(1, 33));
+    const s = etc.bytesToHex(signature.slice(33, 65));
+    const v = (signature[0] + 27).toString(16).padStart(2, "0");
+
+    return `0x${r}${s}${v}`;
+}
+
+function hashTypedData(args: {
+    domain: Domain;
+    types: Types;
+    primaryType: string;
+    message: Record<string, unknown>;
+}): Uint8Array {
+    const { domain, types: types_, primaryType, message } = args;
+
+    const domainFields = [];
+    if (domain.name !== undefined) {
+        domainFields.push({ name: "name", type: "string" });
+    }
+    if (domain.version !== undefined) {
+        domainFields.push({ name: "version", type: "string" });
+    }
+    if (domain.chainId !== undefined) {
+        domainFields.push({ name: "chainId", type: "uint256" });
+    }
+    if (domain.verifyingContract !== undefined) {
+        domainFields.push({ name: "verifyingContract", type: "address" });
+    }
+    if (domain.salt !== undefined) {
+        domainFields.push({ name: "salt", type: "bytes32" });
+    }
+
+    const types = {
+        EIP712Domain: domainFields,
+        ...types_,
+    };
+
+    const bytes: Uint8Array[] = [new Uint8Array([0x19, 0x01])];
+    bytes.push(hashStruct("EIP712Domain", domain, types));
+    if (primaryType !== "EIP712Domain") bytes.push(hashStruct(primaryType, message, types));
+
+    return keccak_256(etc.concatBytes(...bytes));
+}
+
+function hashStruct(primaryType: string, data: Record<string, unknown>, types: Types): Uint8Array {
+    const typeHash = keccak_256(new TextEncoder().encode(encodeType(primaryType, types)));
+    const encodedValues = types[primaryType].map((field) => encodeValue(field.type, data[field.name], types));
+    return keccak_256(etc.concatBytes(typeHash, ...encodedValues));
+}
+
+function encodeType(primaryType: string, types: Types): string {
+    const deps = findTypeDependencies(primaryType, types);
+    const sortedDeps = [primaryType, ...deps.filter((d) => d !== primaryType).sort()];
+    return sortedDeps
+        .map((type) =>
+            `${type}(${types[type].map((field) => `${resolveTypeAlias(field.type)} ${field.name}`).join(",")})`
+        )
+        .join("");
+}
+
+function resolveTypeAlias(type: string): string {
+    if (type === "uint") return "uint256";
+    if (type === "int") return "int256";
+    return type;
+}
+
+function findTypeDependencies(primaryType: string, types: Types, _found = new Set<string>()): string[] {
+    if (_found.has(primaryType) || !types[primaryType]) return [];
+    _found.add(primaryType);
+
+    for (const field of types[primaryType]) {
+        const baseType = field.type.replace(/\[.*?\]/g, "");
+        if (types[baseType]) {
+            findTypeDependencies(baseType, types, _found);
+        }
+    }
+    return Array.from(_found);
+}
+
+function encodeValue(type: string, value: unknown, types: Types): Uint8Array {
+    const arrayMatch = type.match(/^(.*)\[(\d*)\]$/);
+    if (arrayMatch) {
+        // Extract type info: base type and optional length
+        const [, baseType, len] = arrayMatch;
+        if (!Array.isArray(value)) {
+            throw new Error(`Expected array for ${type}. Received: ${typeof value}`);
+        }
+        if (len && value.length !== +len) {
+            throw new Error(`Invalid length for ${type}: expected ${len}. Received: ${value.length}`);
+        }
+
+        // Encode each element in the array and hash them together
+        const encodedElements = value.map((v) => encodeValue(baseType, v, types));
+        return keccak_256(etc.concatBytes(...encodedElements));
+    }
+
+    if (types[type]) {
+        if (value === undefined) return new Uint8Array(32);
+        return hashStruct(type, value as Record<string, unknown>, types);
+    }
+
+    if (type === "string") {
+        return keccak_256(new TextEncoder().encode(value as string));
+    }
+
+    if (type === "address") {
+        const bytes = etc.hexToBytes(cleanHex(value as string));
+        if (bytes.length !== 20) {
+            throw new Error(`Address must be 20 bytes.`);
+        }
+        const padded = new Uint8Array(32);
+        padded.set(bytes, 12);
+        return padded;
+    }
+
+    if (type.startsWith("uint") || type.startsWith("int")) {
+        // Extract type info: uint/int and bit size
+        const isUint = type.startsWith("uint");
+        const bitsStr = type.slice(isUint ? 4 : 3);
+        const bits = parseInt(bitsStr || "256");
+        if (bits > 256 || bits % 8 !== 0) {
+            throw new Error(`Invalid ${isUint ? "uint" : "int"} size: ${bitsStr}. Must be 8-256 in steps of 8`);
+        }
+
+        // Apply Two's complement for specified bit size
+        const bigIntValue = BigInt(value as number | string | bigint | `0x${string}`);
+        const resizedValue = isUint ? BigInt.asUintN(bits, bigIntValue) : BigInt.asIntN(bits, bigIntValue);
+
+        // Convert to 32-byte big-endian
+        const hex = BigInt.asUintN(256, resizedValue).toString(16).padStart(64, "0");
+        return etc.hexToBytes(hex);
+    }
+
+    if (type === "bool") {
+        const result = new Uint8Array(32);
+        result[31] = value ? 1 : 0;
+        return result;
+    }
+
+    if (type === "bytes") {
+        const bytes = typeof value === "string" ? etc.hexToBytes(cleanHex(value)) : value as Uint8Array;
+        return keccak_256(bytes);
+    }
+
+    const bytesMatch = type.match(/^bytes(\d+)$/);
+    if (bytesMatch) {
+        // Extract type info: bytes size
+        const size = parseInt(bytesMatch[1]);
+        if (size === 0 || size > 32) {
+            throw new Error(`bytesN size must be 1-32. Received: ${size}`);
+        }
+
+        // Convert hex to bytes
+        const bytes = etc.hexToBytes(cleanHex(value as string));
+        if (bytes.length !== size) {
+            throw new Error(`${type} requires exactly ${size} bytes. Received: ${bytes.length} from '${value}'`);
+        }
+
+        // Pad to 32 bytes
+        const padded = new Uint8Array(32);
+        padded.set(bytes, 0);
+        return padded;
+    }
+
+    throw new Error(`Unsupported type: '${type}'.`);
+}
+
+function cleanHex(hex: string): string {
+    return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+
+/** Validates if a string is a valid secp256k1 private key. */
+export function isValidPrivateKey(privateKey: unknown): privateKey is string {
+    if (typeof privateKey !== "string") return false;
+    const privateKeyBytes = etc.hexToBytes(cleanHex(privateKey));
+    return utils.isValidSecretKey(privateKeyBytes);
+}
+
+/** Converts a private key to an Ethereum address. */
+export function privateKeyToAddress(privateKey: string): `0x${string}` {
+    const privateKeyBytes = etc.hexToBytes(cleanHex(privateKey));
+
+    const publicKey = getPublicKey(privateKeyBytes, false);
+    const publicKeyWithoutPrefix = publicKey.slice(1);
+
+    const hash = keccak_256(publicKeyWithoutPrefix);
+
+    const addressBytes = hash.slice(-20);
+    const address = etc.bytesToHex(addressBytes);
+
+    return `0x${address}`;
+}

package/src/src/signing/signTypedData/viem.ts

@@ -0,0 +1,55 @@
+/** Abstract interface for a viem {@link https://viem.sh/docs/accounts/jsonRpc#json-rpc-account | JSON-RPC Account}. */
+export interface AbstractViemJsonRpcAccount {
+    signTypedData(
+        params: {
+            domain: {
+                name: string;
+                version: string;
+                chainId: number;
+                verifyingContract: `0x${string}`;
+            };
+            types: {
+                [key: string]: {
+                    name: string;
+                    type: string;
+                }[];
+            };
+            primaryType: string;
+            message: Record<string, unknown>;
+        },
+        options?: unknown,
+    ): Promise<`0x${string}`>;
+    getAddresses?(): Promise<`0x${string}`[]>;
+    getChainId?(): Promise<number>;
+}
+
+/** Abstract interface for a viem {@link https://viem.sh/docs/accounts/local | Local Account}. */
+export interface AbstractViemLocalAccount {
+    signTypedData(
+        params: {
+            domain: {
+                name: string;
+                version: string;
+                chainId: number;
+                verifyingContract: `0x${string}`;
+            };
+            types: {
+                [key: string]: {
+                    name: string;
+                    type: string;
+                }[];
+            };
+            primaryType: string;
+            message: Record<string, unknown>;
+        },
+        options?: unknown,
+    ): Promise<`0x${string}`>;
+    address?: `0x${string}`;
+}
+
+/** Checks if the given value is an abstract viem wallet. */
+export function isAbstractViemWallet(client: unknown): client is AbstractViemJsonRpcAccount | AbstractViemLocalAccount {
+    return typeof client === "object" && client !== null &&
+        "signTypedData" in client && typeof client.signTypedData === "function" &&
+        (client.signTypedData.length === 1 || client.signTypedData.length === 2);
+}

package/src/src/transports/base.ts

@@ -0,0 +1,54 @@
+import { HyperliquidError } from "../_errors.js";
+
+/**
+ * Interface representing a REST transport.
+ * Handles communication with Hyperliquid API endpoints.
+ * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint | Info endpoint}
+ * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint | Exchange endpoint}
+ * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/post-requests | Websocket post requests}
+ */
+export interface IRequestTransport extends Partial<AsyncDisposable> {
+    /** Indicates this transport uses testnet endpoint(s). */
+    isTestnet: boolean;
+    /**
+     * Sends a request to the Hyperliquid API.
+     * @param endpoint - The API endpoint to send the request to.
+     * @param payload - The payload to send with the request.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns A promise that resolves with parsed JSON response body.
+     */
+    request<T>(endpoint: "info" | "exchange", payload: unknown, signal?: AbortSignal): Promise<T>;
+    request<T>(endpoint: "info" | "exchange" | "explorer", payload: unknown, signal?: AbortSignal): Promise<T>;
+}
+
+/**
+ * Interface representing an event subscription transport.
+ * Handles WebSocket subscriptions for real-time updates.
+ * @see {@link https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions | Websocket subscriptions}
+ */
+export interface ISubscriptionTransport extends Partial<AsyncDisposable> {
+    /**
+     * Subscribes to a Hyperliquid event channel.
+     * @param channel - The event channel to listen to.
+     * @param payload - The payload to send with the subscription request.
+     * @param listener - The function to call when the event is dispatched.
+     * @returns A promise that resolves with a {@link Subscription} object to manage the subscription lifecycle.
+     */
+    subscribe<T>(channel: string, payload: unknown, listener: (data: CustomEvent<T>) => void): Promise<Subscription>;
+}
+
+/** Controls event subscription lifecycle. */
+export interface Subscription {
+    /** Unsubscribes from the event and sends an unsubscribe request to the server. */
+    unsubscribe(): Promise<void>;
+    /** Signal that aborts when resubscription fails during reconnection. */
+    resubscribeSignal?: AbortSignal;
+}
+
+/** Thrown when a transport layer error occurs. */
+export class TransportError extends HyperliquidError {
+    constructor(message?: string, options?: ErrorOptions) {
+        super(message, options);
+        this.name = "TransportError";
+    }
+}

package/src/src/transports/http/http_transport.ts

@@ -0,0 +1,208 @@
+import { TransportError } from "../base.js";
+import type { IRequestTransport } from "../base.js";
+
+type MaybePromise<T> = T | Promise<T>;
+
+/** Error thrown when an HTTP request fails. */
+export class HttpRequestError extends TransportError {
+    response?: Response;
+    body?: string;
+
+    constructor(args?: { response?: Response; body?: string }, options?: ErrorOptions) {
+        const { response, body } = args ?? {};
+
+        let message: string;
+        if (response) {
+            message = `${response.status} ${response.statusText}`.trim();
+            if (body) message += ` - ${body}`;
+        } else {
+            message = `Unknown error while making an HTTP request: ${options?.cause}`;
+        }
+
+        super(message, options);
+        this.name = "HttpRequestError";
+        this.response = response;
+        this.body = body;
+    }
+}
+
+/** Configuration options for the HTTP transport layer. */
+export interface HttpTransportOptions {
+    /**
+     * Specifies whether to use the testnet API endpoints from the {@linkcode server} property.
+     * @defaultValue `false`
+     */
+    isTestnet?: boolean;
+
+    /**
+     * Request timeout in ms. Set to `null` to disable.
+     * @defaultValue `10_000`
+     */
+    timeout?: number | null;
+
+    /**
+     * Custom server to use for API requests.
+     * @defaultValue `https://api.hyperliquid.xyz` for mainnet and `https://api.hyperliquid-testnet.xyz` for testnet.
+     */
+    server?: {
+        mainnet?: { api?: string | URL; rpc?: string | URL };
+        testnet?: { api?: string | URL; rpc?: string | URL };
+    };
+
+    /** A custom {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} that is merged with a fetch request. */
+    fetchOptions?: Omit<RequestInit, "body" | "method">;
+
+    /**
+     * A callback function that is called before the request is sent.
+     * @param request - An original request to send.
+     * @returns If returned a {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/Request/Request | Request}, it will replace the original request.
+     */
+    onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>;
+
+    /**
+     * A callback function that is called after the response is received.
+     * @param response - An original response to process.
+     * @returns If returned a {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/Response/Response | Response}, it will replace the original response.
+     */
+    onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>;
+}
+
+/** HTTP implementation of the REST transport interface. */
+export class HttpTransport implements IRequestTransport, HttpTransportOptions {
+    isTestnet: boolean;
+    timeout: number | null;
+    server: {
+        mainnet: { api: string | URL; rpc: string | URL };
+        testnet: { api: string | URL; rpc: string | URL };
+    };
+    fetchOptions: Omit<RequestInit, "body" | "method">;
+    onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>;
+    onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>;
+
+    /**
+     * Creates a new HTTP transport instance.
+     * @param options - Configuration options for the HTTP transport layer.
+     */
+    constructor(options?: HttpTransportOptions) {
+        this.isTestnet = options?.isTestnet ?? false;
+        this.timeout = options?.timeout === undefined ? 10_000 : options.timeout;
+        this.server = {
+            mainnet: {
+                api: options?.server?.mainnet?.api ?? "https://api.hyperliquid.xyz",
+                rpc: options?.server?.mainnet?.rpc ?? "https://rpc.hyperliquid.xyz",
+            },
+            testnet: {
+                api: options?.server?.testnet?.api ?? "https://api.hyperliquid-testnet.xyz",
+                rpc: options?.server?.testnet?.rpc ?? "https://rpc.hyperliquid-testnet.xyz",
+            },
+        };
+        this.fetchOptions = options?.fetchOptions ?? {};
+        this.onRequest = options?.onRequest;
+        this.onResponse = options?.onResponse;
+    }
+
+    /**
+     * Sends a request to the Hyperliquid API via fetch.
+     * @param endpoint - The API endpoint to send the request to.
+     * @param payload - The payload to send with the request.
+     * @param signal - An {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}. If this option is set, the request can be canceled by calling {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort | abort()} on the corresponding {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}.
+     * @returns A promise that resolves with parsed JSON response body.
+     *
+     * @throws {HttpRequestError} Thrown when the HTTP request fails.
+     */
+    async request<T>(endpoint: "info" | "exchange" | "explorer", payload: unknown, signal?: AbortSignal): Promise<T> {
+        try {
+            // Construct a Request
+            const url = new URL(
+                endpoint,
+                this.server[this.isTestnet ? "testnet" : "mainnet"][endpoint === "explorer" ? "rpc" : "api"],
+            );
+            const init = mergeRequestInit(
+                {
+                    body: JSON.stringify(payload),
+                    headers: {
+                        "Accept-Encoding": "gzip, deflate, br, zstd",
+                        "Content-Type": "application/json",
+                    },
+                    keepalive: true,
+                    method: "POST",
+                    signal: this.timeout ? AbortSignal.timeout(this.timeout) : undefined,
+                },
+                this.fetchOptions,
+                { signal },
+            );
+            let request = new Request(url, init);
+
+            // Call the onRequest callback, if provided
+            if (this.onRequest) {
+                const customRequest = await this.onRequest(request);
+                if (customRequest instanceof Request) request = customRequest;
+            }
+
+            // Send the Request and wait for a Response
+            let response = await fetch(request);
+
+            // Call the onResponse callback, if provided
+            if (this.onResponse) {
+                const customResponse = await this.onResponse(response);
+                if (customResponse instanceof Response) response = customResponse;
+            }
+
+            // Validate the Response
+            if (!response.ok || !response.headers.get("Content-Type")?.includes("application/json")) {
+                // Unload the response body to prevent memory leaks
+                const body = await response.text().catch(() => undefined);
+                throw new HttpRequestError({ response, body });
+            }
+
+            // Parse the response body
+            const body = await response.json();
+
+            // Check if the response is an error
+            if (body?.type === "error") {
+                throw new HttpRequestError({ response, body: body?.message });
+            }
+
+            // Return the response body
+            return body;
+        } catch (error) {
+            if (error instanceof TransportError) throw error; // Re-throw known errors
+            throw new HttpRequestError(undefined, { cause: error });
+        }
+    }
+}
+
+/** Merges multiple {@linkcode HeadersInit} into one {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers | Headers}. */
+function mergeHeadersInit(...inits: HeadersInit[]): Headers {
+    if (inits.length === 0 || inits.length === 1) {
+        return new Headers(inits[0] as HeadersInit | undefined);
+    }
+
+    const merged = new Headers();
+    for (const headers of inits) {
+        const iterator = Symbol.iterator in headers ? headers : Object.entries(headers);
+        for (const [key, value] of iterator) {
+            merged.set(key, value);
+        }
+    }
+    return merged;
+}
+
+/** Merges multiple {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit} into one {@linkcode https://developer.mozilla.org/en-US/docs/Web/API/RequestInit | RequestInit}. */
+function mergeRequestInit(...inits: RequestInit[]): RequestInit {
+    const merged = inits.reduce((acc, init) => ({ ...acc, ...init }), {});
+
+    const headersList = inits.map((init) => init.headers)
+        .filter((headers) => typeof headers === "object");
+    if (headersList.length > 0) {
+        merged.headers = mergeHeadersInit(...headersList);
+    }
+
+    const signals = inits.map((init) => init.signal)
+        .filter((signal) => signal instanceof AbortSignal);
+    if (signals.length > 0) {
+        merged.signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    }
+
+    return merged;
+}