@hfunlabs/hyperliquid 0.27.1-hfunlabs.5 → 0.29.1-hfunlabs.1

package/src/src/signing/mod.ts

@@ -4,12 +4,13 @@
  * @example Signing an L1 action
  * ```ts
  * import { signL1Action } from "@nktkas/hyperliquid/signing";
- * import { CancelRequest, parser } from "@nktkas/hyperliquid/api/exchange";
+ * import { CancelRequest } from "@nktkas/hyperliquid/api/exchange";
+ * import * as v from "npm:valibot";
  * import { privateKeyToAccount } from "npm:viem/accounts";
  *
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  *
- * const action = parser(CancelRequest.entries.action)({ // for correct signature generation
+ * const action = v.parse(CancelRequest.entries.action, { // not required, but for correct generation
  *   type: "cancel",
  *   cancels: [
  *     { a: 0, o: 12345 },
@@ -31,12 +32,13 @@
  * @example Signing a user-signed action
  * ```ts
  * import { signUserSignedAction } from "@nktkas/hyperliquid/signing";
- * import { ApproveAgentRequest, ApproveAgentTypes, parser } from "@nktkas/hyperliquid/api/exchange";
+ * import { ApproveAgentRequest, ApproveAgentTypes } from "@nktkas/hyperliquid/api/exchange";
+ * import * as v from "npm:valibot";
  * import { privateKeyToAccount } from "npm:viem/accounts";
  *
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  *
- * const action = parser(ApproveAgentRequest.entries.action)({ // for correct signature generation
+ * const action = v.parse(ApproveAgentRequest.entries.action, { // not required, but for correct generation
  *   type: "approveAgent",
  *   signatureChainId: "0x66eee",
  *   hyperliquidChain: "Mainnet",
@@ -56,92 +58,36 @@
  * const body = await response.json();
  * ```
  *
- * @example Signing a multi-signature action
- * ```ts
- * import { signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
- * import { MultiSigRequest, parser, ScheduleCancelRequest } from "@nktkas/hyperliquid/api/exchange";
- * import { privateKeyToAccount } from "npm:viem/accounts";
- *
- * const wallet = privateKeyToAccount("0x..."); // viem or ethers
- * const multiSigUser = "0x...";
- *
- * const action = parser(ScheduleCancelRequest.entries.action)({ // for correct signature generation
- *   type: "scheduleCancel",
- *   time: Date.now() + 10000,
- * });
- * const nonce = Date.now();
- *
- * // Create the required number of signatures
- * const signatures = await Promise.all(["0x...", "0x..."].map(async (signerPrivKey) => {
- *   return await signL1Action({
- *     wallet: privateKeyToAccount(signerPrivKey as `0x${string}`), // viem or ethers
- *     action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), action],
- *     nonce,
- *   });
- * }));
- *
- * // // or user-signed action
- * // const signatures = await Promise.all(["0x...", "0x..."].map(async (signerPrivKey) => {
- * //   return await signUserSignedAction({
- * //     wallet: privateKeyToAccount(signerPrivKey as `0x${string}`), // viem or ethers
- * //     action: {
- * //       ...action,
- * //       payloadMultiSigUser: multiSigUser,
- * //       outerSigner: wallet.address,
- * //     },
- * //     types: SomeTypes,
- * //   });
- * // }));
- *
- * // Then use signatures in the multi-sig action
- * const multiSigAction = parser(MultiSigRequest.entries.action)({
- *   type: "multiSig",
- *   signatureChainId: "0x66eee",
- *   signatures,
- *   payload: {
- *     multiSigUser,
- *     outerSigner: wallet.address,
- *     action,
- *   },
- * });
- * const multiSigSignature = await signMultiSigAction({ wallet, action: multiSigAction, nonce });
- *
- * // Send the multi-sig action to the Hyperliquid API
- * const response = await fetch("https://api.hyperliquid.xyz/exchange", {
- *   method: "POST",
- *   headers: { "Content-Type": "application/json" },
- *   body: JSON.stringify({ action: multiSigAction, signature: multiSigSignature, nonce }),
- * });
- * const body = await response.json();
- * ```
- *
  * @module
  */
 
 import { keccak_256 } from "@noble/hashes/sha3.js";
 import { bytesToHex, concatBytes, hexToBytes } from "@noble/hashes/utils.js";
 import { encode as encodeMsgpack, type ValueType } from "../../deps/jsr.io/@std/msgpack/1.0.3/mod.js";
-import { type AbstractWallet, type Signature, signTypedData } from "./_signTypedData.js";
+import { type AbstractWallet, type Signature, signTypedData } from "./_abstractWallet.js";
 
 export {
   type AbstractEthersV5Signer,
   type AbstractEthersV6Signer,
   type AbstractViemJsonRpcAccount,
   type AbstractViemLocalAccount,
+  type AbstractWallet,
   AbstractWalletError,
   getWalletAddress,
   getWalletChainId,
-} from "./_signTypedData.js";
-export type { AbstractWallet, Signature };
+  type Signature,
+} from "./_abstractWallet.js";
+export { PrivateKeySigner } from "./_privateKeySigner.js";
 
 /**
  * Create a hash of the L1 action.
  * @example
  * ```ts
  * import { createL1ActionHash } from "@nktkas/hyperliquid/signing";
- * import { CancelRequest, parser } from "@nktkas/hyperliquid/api/exchange";
+ * import { CancelRequest } from "@nktkas/hyperliquid/api/exchange";
+ * import * as v from "npm:valibot";
  *
- * const action = parser(CancelRequest.entries.action)({ // for correct signature generation
+ * const action = v.parse(CancelRequest.entries.action, { // not required, but for correct generation
  *   type: "cancel",
  *   cancels: [
  *     { a: 0, o: 12345 },
@@ -233,12 +179,13 @@ function removeUndefinedKeys(obj: ValueType): ValueType {
  * @example
  * ```ts
  * import { signL1Action } from "@nktkas/hyperliquid/signing";
- * import { CancelRequest, parser } from "@nktkas/hyperliquid/api/exchange";
+ * import { CancelRequest } from "@nktkas/hyperliquid/api/exchange";
+ * import * as v from "npm:valibot";
  * import { privateKeyToAccount } from "npm:viem/accounts";
  *
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  *
- * const action = parser(CancelRequest.entries.action)({ // for correct signature generation
+ * const action = v.parse(CancelRequest.entries.action, { // not required, but for correct generation
  *   type: "cancel",
  *   cancels: [
  *     { a: 0, o: 12345 },
@@ -264,28 +211,17 @@ export async function signL1Action(args: {
   action: Record<string, unknown> | unknown[];
   /** The current timestamp in ms. */
   nonce: number;
-  /** Indicates if the action is for the testnet. (default: false) */
+  /**
+   * Indicates if the action is for the testnet.
+   * @default false
+   */
   isTestnet?: boolean;
   /** Optional vault address used in the action. */
   vaultAddress?: `0x${string}`;
   /** Optional expiration time of the action in ms since the epoch. */
   expiresAfter?: number;
 }): Promise<Signature> {
-  const {
-    wallet,
-    action,
-    nonce,
-    isTestnet = false,
-    vaultAddress,
-    expiresAfter,
-  } = args;
-
-  const actionHash = createL1ActionHash({ action, nonce, vaultAddress, expiresAfter });
-  const message = {
-    source: isTestnet ? "b" : "a",
-    connectionId: actionHash,
-  };
-
+  const { wallet, action, nonce, isTestnet = false, vaultAddress, expiresAfter } = args;
   return await signTypedData({
     wallet,
     domain: {
@@ -301,7 +237,10 @@ export async function signL1Action(args: {
       ],
     },
     primaryType: "Agent",
-    message,
+    message: {
+      source: isTestnet ? "b" : "a",
+      connectionId: createL1ActionHash({ action, nonce, vaultAddress, expiresAfter }),
+    },
   });
 }
 
@@ -310,12 +249,13 @@ export async function signL1Action(args: {
  * @example
  * ```ts
  * import { signUserSignedAction } from "@nktkas/hyperliquid/signing";
- * import { ApproveAgentRequest, ApproveAgentTypes, parser } from "@nktkas/hyperliquid/api/exchange";
+ * import { ApproveAgentRequest, ApproveAgentTypes } from "@nktkas/hyperliquid/api/exchange";
+ * import * as v from "npm:valibot";
  * import { privateKeyToAccount } from "npm:viem/accounts";
  *
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  *
- * const action = parser(ApproveAgentRequest.entries.action)({ // for correct signature generation
+ * const action = v.parse(ApproveAgentRequest.entries.action, { // not required, but for correct generation
  *   type: "approveAgent",
  *   signatureChainId: "0x66eee",
  *   hyperliquidChain: "Mainnet",
@@ -358,20 +298,34 @@ export async function signUserSignedAction(args: {
   };
 }): Promise<Signature> {
   let { wallet, action, types } = args;
+  const primaryType = Object.keys(types)[0];
 
-  if (action.type === "approveAgent" && !action.agentName) { // special case for `approveAgent`
-    action = { ...action, agentName: "" }; // set to empty string instead of null
+  // Special case: for `approveAgent`
+  // If `agentName` is null or undefined, set it to an empty string
+  if (action.type === "approveAgent" && !action.agentName) {
+    action = { ...action, agentName: "" };
   }
-  if ("payloadMultiSigUser" in action && "outerSigner" in action) { // special case for multi-sign payload
-    types = structuredClone(types); // for safe mutation
-    Object.values(types)[0].splice( // array mutation
-      1, // after `hyperliquidChain`
-      0, // do not remove any elements
-      { name: "payloadMultiSigUser", type: "address" },
-      { name: "outerSigner", type: "address" },
-    );
+
+  // Special case: for multi-sign payload
+  // If the action contains `payloadMultiSigUser` and `outerSigner`, add them to the types
+  if ("payloadMultiSigUser" in action && "outerSigner" in action) {
+    const primaryTypeArray = types[primaryType];
+    types = {
+      ...types,
+      [primaryType]: [
+        primaryTypeArray[0], // after `hyperliquidChain`
+        { name: "payloadMultiSigUser", type: "address" },
+        { name: "outerSigner", type: "address" },
+        ...primaryTypeArray.slice(1),
+      ],
+    };
   }
 
+  // Special case: for some wallets
+  // If the action has extra keys not in the types, filter them out
+  const knownKeys = new Set(types[primaryType].map((f) => f.name));
+  const message = Object.fromEntries(Object.entries(action).filter(([k]) => knownKeys.has(k)));
+
   return await signTypedData({
     wallet,
     domain: {
@@ -381,8 +335,8 @@ export async function signUserSignedAction(args: {
       verifyingContract: "0x0000000000000000000000000000000000000000",
     },
     types,
-    primaryType: Object.keys(types)[0],
-    message: action,
+    primaryType,
+    message,
   });
 }
 
@@ -391,14 +345,15 @@ export async function signUserSignedAction(args: {
  * @example
  * ```ts
  * import { signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
- * import { MultiSigRequest, parser, ScheduleCancelRequest } from "@nktkas/hyperliquid/api/exchange";
+ * import { ScheduleCancelRequest } from "@nktkas/hyperliquid/api/exchange";
+ * import * as v from "npm:valibot";
  * import { privateKeyToAccount } from "npm:viem/accounts";
  *
  * const wallet = privateKeyToAccount("0x..."); // viem or ethers
  * const multiSigUser = "0x...";
  *
  * const nonce = Date.now();
- * const action = parser(ScheduleCancelRequest.entries.action)({ // for correct signature generation
+ * const action = v.parse(ScheduleCancelRequest.entries.action, { // not required, but for correct generation
  *   type: "scheduleCancel",
  *   time: Date.now() + 10000,
  * });
@@ -426,16 +381,16 @@ export async function signUserSignedAction(args: {
  * // }));
  *
  * // Then use signatures in the multi-sig action
- * const multiSigAction = parser(MultiSigRequest.entries.action)({
+ * const multiSigAction = {
  *   type: "multiSig",
- *   signatureChainId: "0x66eee",
+ *   signatureChainId: "0x66eee" as const,
  *   signatures,
  *   payload: {
  *     multiSigUser,
  *     outerSigner: wallet.address,
  *     action,
  *   },
- * });
+ * };
  * const multiSigSignature = await signMultiSigAction({ wallet, action: multiSigAction, nonce });
  *
  * // Send the multi-sig action to the Hyperliquid API
@@ -457,34 +412,23 @@ export async function signMultiSigAction(args: {
   };
   /** The current timestamp in ms. */
   nonce: number;
-  /** Indicates if the action is for the testnet. (default: false) */
+  /**
+   * Indicates if the action is for the testnet.
+   * @default false
+   */
   isTestnet?: boolean;
   /** Optional vault address used in the action. */
   vaultAddress?: `0x${string}`;
   /** Optional expiration time of the action in ms since the epoch. */
   expiresAfter?: number;
 }): Promise<Signature> {
-  let {
-    wallet,
-    action,
-    nonce,
-    isTestnet = false,
-    vaultAddress,
-    expiresAfter,
-  } = args;
+  let { wallet, action, nonce, isTestnet = false, vaultAddress, expiresAfter } = args;
 
   if ("type" in action) {
-    action = structuredClone(action); // for safe mutation
-    delete action.type;
+    const { type: _, ...actionWithoutType } = action;
+    action = actionWithoutType;
   }
 
-  const multiSigActionHash = createL1ActionHash({ action, nonce, vaultAddress, expiresAfter });
-  const message = {
-    hyperliquidChain: isTestnet ? "Testnet" : "Mainnet",
-    multiSigActionHash,
-    nonce,
-  };
-
   return await signTypedData({
     wallet,
     domain: {
@@ -501,6 +445,10 @@ export async function signMultiSigAction(args: {
       ],
     },
     primaryType: "HyperliquidTransaction:SendMultiSig",
-    message,
+    message: {
+      hyperliquidChain: isTestnet ? "Testnet" : "Mainnet",
+      multiSigActionHash: createL1ActionHash({ action, nonce, vaultAddress, expiresAfter }),
+      nonce,
+    },
   });
 }

package/src/src/transport/_polyfills.ts

@@ -1,7 +1,4 @@
 // deno-lint-ignore-file no-explicit-any
-/**
- * Polyfills for Node.js < 22 and React Native
- */
 
 export const Promise_ = /* @__PURE__ */ (() => {
   return {
@@ -46,10 +43,10 @@ export const AbortSignal_ = /* @__PURE__ */ (() => {
 /** @see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent */
 export const CustomEvent_ = /* @__PURE__ */ (() => {
   return globalThis.CustomEvent || class<T> extends Event {
-    readonly detail: T;
+    readonly detail: T | null;
     constructor(type: string, eventInitDict?: CustomEventInit<T>) {
       super(type, eventInitDict);
-      this.detail = eventInitDict?.detail ?? null as T;
+      this.detail = eventInitDict?.detail ?? null;
     }
   };
 })();

package/src/src/transport/http/mod.ts

@@ -1,13 +1,20 @@
-import { type IRequestTransport, TransportError } from "../base.js";
+import { TransportError } from "../../_errors.js";
 import { AbortSignal_ } from "../_polyfills.js";
 
-type MaybePromise<T> = T | Promise<T>;
-
 /** Error thrown when an HTTP request fails. */
 export class HttpRequestError extends TransportError {
+  /** The HTTP response that caused the error. */
   response?: Response;
+  /** The response body text. */
   body?: string;
 
+  /**
+   * Creates a new HTTP request error.
+   * @param args - The error arguments.
+   * @param args.response - The HTTP response that caused the error.
+   * @param args.body - The response body text.
+   * @param options - The error options.
+   */
   constructor(args?: { response?: Response; body?: string }, options?: ErrorOptions) {
     const { response, body } = args ?? {};
 
@@ -16,7 +23,7 @@ export class HttpRequestError extends TransportError {
       message = `${response.status} ${response.statusText}`.trim();
       if (body) message += ` - ${body}`;
     } else {
-      message = `Unknown error while making an HTTP request: ${options?.cause}`;
+      message = `Unknown HTTP request error: ${options?.cause}`;
     }
 
     super(message, options);
@@ -29,57 +36,54 @@ export class HttpRequestError extends TransportError {
 /** Configuration options for the HTTP transport layer. */
 export interface HttpTransportOptions {
   /**
-   * Specifies whether to use the testnet API endpoints from the {@linkcode server} property.
+   * Indicates this transport uses testnet endpoint.
    * @default false
    */
   isTestnet?: boolean;
+
   /**
    * Request timeout in ms. Set to `null` to disable.
    * @default 10_000
    */
   timeout?: number | null;
+
   /**
-   * Custom server to use for API requests.
-   * @default `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 [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/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 [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/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 [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response), it will replace the original response.
+   * Custom API URL for requests.
+   * @default `https://api.hyperliquid.xyz` for mainnet, `https://api.hyperliquid-testnet.xyz` for testnet.
    */
-  onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>;
+  apiUrl?: string | URL;
+
   /**
-   * A callback function that is called when an error occurs during fetching.
-   * @param error - The error that occurred.
-   * @returns If returned an [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error), it will be thrown instead of the original error (still wraps an error in {@linkcode HttpRequestError}).
+   * Custom RPC URL for explorer requests.
+   * @default `https://rpc.hyperliquid.xyz` for mainnet, `https://rpc.hyperliquid-testnet.xyz` for testnet.
    */
-  onError?: (error: unknown) => MaybePromise<Error | void | null | undefined>;
+  rpcUrl?: string | URL;
+
+  /** A custom [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) that is merged with a fetch request. */
+  fetchOptions?: Omit<RequestInit, "body" | "method">;
 }
 
-/** HTTP implementation of the REST transport interface. */
-export class HttpTransport implements IRequestTransport, HttpTransportOptions {
+/** Mainnet API URL. */
+export const MAINNET_API_URL = "https://api.hyperliquid.xyz";
+/** Testnet API URL. */
+export const TESTNET_API_URL = "https://api.hyperliquid-testnet.xyz";
+/** Mainnet RPC URL. */
+export const MAINNET_RPC_URL = "https://rpc.hyperliquid.xyz";
+/** Testnet RPC URL. */
+export const TESTNET_RPC_URL = "https://rpc.hyperliquid-testnet.xyz";
+
+/**
+ * HTTP transport for Hyperliquid API.
+ *
+ * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint
+ * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint
+ */
+export class HttpTransport implements HttpTransportOptions {
   isTestnet: boolean;
   timeout: number | null;
-  server: {
-    mainnet: { api: string | URL; rpc: string | URL };
-    testnet: { api: string | URL; rpc: string | URL };
-  };
+  apiUrl: string | URL;
+  rpcUrl: string | URL;
   fetchOptions: Omit<RequestInit, "body" | "method">;
-  onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>;
-  onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>;
-  onError?: (error: unknown) => MaybePromise<Error | void | null | undefined>;
 
   /**
    * Creates a new HTTP transport instance.
@@ -88,27 +92,18 @@ export class HttpTransport implements IRequestTransport, HttpTransportOptions {
   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.apiUrl = options?.apiUrl ?? (this.isTestnet ? TESTNET_API_URL : MAINNET_API_URL);
+    this.rpcUrl = options?.rpcUrl ?? (this.isTestnet ? TESTNET_RPC_URL : MAINNET_RPC_URL);
     this.fetchOptions = options?.fetchOptions ?? {};
-    this.onRequest = options?.onRequest;
-    this.onResponse = options?.onResponse;
-    this.onError = options?.onError;
   }
 
   /**
-   * Sends a request to the Hyperliquid API via fetch.
+   * Sends a request to the Hyperliquid API via [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).
+   *
    * @param endpoint - The API endpoint to send the request to.
    * @param payload - The payload to send with the request.
-   * @param signal - An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) can be used to cancel the request by calling [`abort()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort) on the corresponding [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+   * @param signal - [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) to cancel the request.
+   *
    * @returns A promise that resolves with parsed JSON response body.
    *
    * @throws {HttpRequestError} Thrown when the HTTP request fails.
@@ -116,11 +111,8 @@ export class HttpTransport implements IRequestTransport, HttpTransportOptions {
   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(
+      const url = new URL(endpoint, endpoint === "explorer" ? this.rpcUrl : this.apiUrl);
+      const init = this._mergeRequestInit(
         {
           body: JSON.stringify(payload),
           headers: {
@@ -134,29 +126,9 @@ export class HttpTransport implements IRequestTransport, HttpTransportOptions {
         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)
-        .catch(async (error) => {
-          if (this.onError) {
-            const customError = await this.onError(error);
-            if (customError instanceof Error) error = customError;
-          }
-          throw error;
-        });
-
-      // Call the onResponse callback, if provided
-      if (this.onResponse) {
-        const customResponse = await this.onResponse(response);
-        if (customResponse instanceof Response) response = customResponse;
-      }
+      const response = await fetch(url, init);
 
       // Validate the Response
       if (!response.ok || !response.headers.get("Content-Type")?.includes("application/json")) {
@@ -180,39 +152,33 @@ export class HttpTransport implements IRequestTransport, HttpTransportOptions {
       throw new HttpRequestError(undefined, { cause: error });
     }
   }
-}
-
-/** Merges multiple `HeadersInit` into one [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/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);
+  /** Merges multiple `HeadersInit` into one [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers). */
+  protected _mergeHeadersInit(...inits: HeadersInit[]): Headers {
+    const merged = new Headers();
+    for (const headers of inits) {
+      const entries = Symbol.iterator in headers ? headers : Object.entries(headers);
+      for (const [key, value] of entries) {
+        merged.set(key, value);
+      }
     }
+    return merged;
   }
-  return merged;
-}
 
-/** Merges multiple [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) into one [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit). */
-function mergeRequestInit(...inits: RequestInit[]): RequestInit {
-  const merged = inits.reduce((acc, init) => ({ ...acc, ...init }), {});
+  /** Merges multiple [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) into one [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit). */
+  protected _mergeRequestInit(...inits: RequestInit[]): RequestInit {
+    const merged: RequestInit = {};
+    const headersList: HeadersInit[] = [];
+    const signals: AbortSignal[] = [];
 
-  const headersList = inits.map((init) => init.headers)
-    .filter((headers) => typeof headers === "object");
-  if (headersList.length > 0) {
-    merged.headers = mergeHeadersInit(...headersList);
-  }
+    for (const init of inits) {
+      Object.assign(merged, init);
+      if (init.headers) headersList.push(init.headers);
+      if (init.signal) signals.push(init.signal);
+    }
+    if (headersList.length > 0) merged.headers = this._mergeHeadersInit(...headersList);
+    if (signals.length > 0) merged.signal = signals.length > 1 ? AbortSignal_.any(signals) : signals[0];
 
-  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;
   }
-
-  return merged;
 }