@solana/rpc-transport-http 2.0.0-experimental.00fa195

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2023 Solana Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+[![npm][npm-image]][npm-url]
+[![npm-downloads][npm-downloads-image]][npm-url]
+[![semantic-release][semantic-release-image]][semantic-release-url]
+<br />
+[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
+
+[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
+[code-style-prettier-url]: https://github.com/prettier/prettier
+[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/rpc-transport-http/experimental.svg?style=flat
+[npm-image]: https://img.shields.io/npm/v/@solana/rpc-transport-http/experimental.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/@solana/rpc-transport-http/v/experimental
+[semantic-release-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
+[semantic-release-url]: https://github.com/semantic-release/semantic-release
+
+# @solana/rpc-transport-http
+
+This package allows developers to create custom RPC transports. With this library, one can implement highly specialized functionality for leveraging multiple transports, attempting/handling retries, and more.
+
+## Functions
+
+### `createHttpTransport()`
+
+Call this to create a function that conforms to the `RpcTransport` interface (see `@solana/rpc-spec`). You can use that function in your programs to make `POST` requests with headers suitable for sending JSON data to a server.
+
+```ts
+import { createHttpTransport } from '@solana/rpc-transport-http';
+
+const transport = createHttpTransport({ url: 'https://api.mainnet-beta.solana.com' });
+const response = await transport({
+    payload: { id: 1, jsonrpc: '2.0', method: 'getSlot' },
+});
+```
+
+#### Config
+
+##### `dispatcher_NODE_ONLY`
+
+In Node environments you can tune how requests are dispatched to the network. Use this config parameter to install a [`undici.Dispatcher`](https://undici.nodejs.org/#/docs/api/Agent) in your transport.
+
+```ts
+import { createHttpTransport } from '@solana/rpc-transport-http';
+import { Agent, BalancedPool } from 'undici';
+
+// Create a dispatcher that, when called with a special URL, creates a round-robin pool of RPCs.
+const dispatcher = new Agent({
+    factory(origin, opts) {
+        if (origin === 'https://mypool') {
+            const upstreams = [
+                'https://api.mainnet-beta.solana.com',
+                'https://mainnet.helius-rpc.com',
+                'https://several-neat-iguana.quiknode.pro',
+            ];
+            return new BalancedPool(upstreams, {
+                ...opts,
+                bodyTimeout: 60e3,
+                headersTimeout: 5e3,
+                keepAliveTimeout: 19e3,
+            });
+        } else {
+            return new Pool(origin, opts);
+        }
+    },
+});
+const transport = createHttpTransport({
+    dispatcher_NODE_ONLY: dispatcher,
+    url: 'https://mypool',
+});
+let id = 0;
+const balances = await Promise.allSettled(
+    accounts.map(account =>
+        transport({
+            payload: {
+                id: ++id,
+                jsonrpc: '2.0',
+                method: 'getBalance',
+                params: [account],
+            },
+        }),
+    ),
+);
+```
+
+##### `headers`
+
+An object of headers to set on the request. Avoid [forbidden headers](https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name). Additionally, the headers `Accept`, `Content-Length`, and `Content-Type` are disallowed.
+
+```ts
+import { createHttpTransport } from '@solana/rpc-transport-http';
+
+const transport = createHttpTransport({
+    headers: {
+        // Authorize with the RPC using a bearer token
+        Authorization: `Bearer ${process.env.RPC_AUTH_TOKEN}`,
+    },
+    url: 'https://several-neat-iguana.quiknode.pro',
+});
+```
+
+##### `url`
+
+A string representing the target endpoint. In Node, it must be an absolute URL using the `http` or `https` protocol.
+
+## Augmenting Transports
+
+Using this core transport, you can implement specialized functionality for leveraging multiple transports, attempting/handling retries, and more.
+
+### Round Robin
+
+Here’s an example of how someone might implement a “round robin” approach to distribute requests to multiple transports:
+
+```ts
+import { RpcTransport } from '@solana/rpc-spec';
+import { createHttpTransport } from '@solana/rpc-transport-http';
+
+// Create a transport for each RPC server
+const transports = [
+    createHttpTransport({ url: 'https://mainnet-beta.my-server-1.com' }),
+    createHttpTransport({ url: 'https://mainnet-beta.my-server-2.com' }),
+    createHttpTransport({ url: 'https://mainnet-beta.my-server-3.com' }),
+];
+
+// Create a wrapper transport that distributes requests to them
+let nextTransport = 0;
+async function roundRobinTransport<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
+    const transport = transports[nextTransport];
+    nextTransport = (nextTransport + 1) % transports.length;
+    return await transport(...args);
+}
+```
+
+### Sharding
+
+Another example of a possible customization for a transport is to shard requests deterministically among a set of servers. Here’s an example:
+
+Perhaps your application needs to make a large number of requests, or needs to fan request for different methods out to different servers. Here’s an example of an implementation that does the latter:
+
+```ts
+import { RpcTransport } from '@solana/rpc-spec';
+import { createHttpTransport } from '@solana/rpc-transport-http';
+
+// Create multiple transports
+const transportA = createHttpTransport({ url: 'https://mainnet-beta.my-server-1.com' });
+const transportB = createHttpTransport({ url: 'https://mainnet-beta.my-server-2.com' });
+const transportC = createHttpTransport({ url: 'https://mainnet-beta.my-server-3.com' });
+const transportD = createHttpTransport({ url: 'https://mainnet-beta.my-server-4.com' });
+
+// Function to determine which shard to use based on the request method
+function selectShard(method: string): RpcTransport {
+    switch (method) {
+        case 'getAccountInfo':
+        case 'getBalance':
+            return transportA;
+        case 'getTransaction':
+        case 'getRecentBlockhash':
+            return transportB;
+        case 'sendTransaction':
+            return transportC;
+        default:
+            return transportD;
+    }
+}
+
+async function shardingTransport<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
+    const payload = args[0].payload as { method: string };
+    const selectedTransport = selectShard(payload.method);
+    return await selectedTransport(...args);
+}
+```
+
+### Retry Logic
+
+The transport library can also be used to implement custom retry logic on any request:
+
+```ts
+import { RpcTransport } from '@solana/rpc-spec';
+import { createHttpTransport } from '@solana/rpc-transport-http';
+
+// Set the maximum number of attempts to retry a request
+const MAX_ATTEMPTS = 4;
+
+// Create the default transport
+const defaultTransport = createHttpTransport({ url: 'https://mainnet-beta.my-server-1.com' });
+
+// Sleep function to wait for a given number of milliseconds
+function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Calculate the delay for a given attempt
+function calculateRetryDelay(attempt: number): number {
+    // Exponential backoff with a maximum of 1.5 seconds
+    return Math.min(100 * Math.pow(2, attempt), 1500);
+}
+
+// A retrying transport that will retry up to `MAX_ATTEMPTS` times before failing
+async function retryingTransport<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
+    let requestError;
+    for (let attempts = 0; attempts < MAX_ATTEMPTS; attempts++) {
+        try {
+            return await defaultTransport(...args);
+        } catch (err) {
+            requestError = err;
+            // Only sleep if we have more attempts remaining
+            if (attempts < MAX_ATTEMPTS - 1) {
+                const retryDelay = calculateRetryDelay(attempts);
+                await sleep(retryDelay);
+            }
+        }
+    }
+    throw requestError;
+}
+```
+
+### Failover
+
+Here’s an example of some failover logic integrated into a transport:
+
+```ts
+import { RpcTransport } from '@solana/rpc-spec';
+import { createHttpTransport } from '@solana/rpc-transport-http';
+
+// Create a transport for each RPC server
+const transports = [
+    createHttpTransport({ url: 'https://mainnet-beta.my-server-1.com' }),
+    createHttpTransport({ url: 'https://mainnet-beta.my-server-2.com' }),
+    createHttpTransport({ url: 'https://mainnet-beta.my-server-2.com' }),
+];
+
+// A failover transport that will try each transport in order until one succeeds before failing
+async function failoverTransport<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
+    let requestError;
+
+    for (const transport of transports) {
+        try {
+            return await transport(...args);
+        } catch (err) {
+            requestError = err;
+            console.error(err);
+        }
+    }
+    throw requestError;
+}
+
+```

package/dist/index.browser.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+var errors = require('@solana/errors');
+
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+var DISALLOWED_HEADERS = {
+  accept: true,
+  "content-length": true,
+  "content-type": true
+};
+var FORBIDDEN_HEADERS = {
+  "accept-charset": true,
+  "accept-encoding": true,
+  "access-control-request-headers": true,
+  "access-control-request-method": true,
+  connection: true,
+  "content-length": true,
+  cookie: true,
+  date: true,
+  dnt: true,
+  expect: true,
+  host: true,
+  "keep-alive": true,
+  origin: true,
+  "permissions-policy": true,
+  // Prefix matching is implemented in code, below.
+  // 'proxy-': true,
+  // 'sec-': true,
+  referer: true,
+  te: true,
+  trailer: true,
+  "transfer-encoding": true,
+  upgrade: true,
+  via: true
+};
+function assertIsAllowedHttpRequestHeaders(headers) {
+  const badHeaders = Object.keys(headers).filter((headerName) => {
+    const lowercaseHeaderName = headerName.toLowerCase();
+    return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+  });
+  if (badHeaders.length > 0) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {
+      headers: badHeaders
+    });
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/http-transport.ts
+var didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;
+function warnDispatcherWasSuppliedInNonNodeEnvironment() {
+  if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {
+    return;
+  }
+  didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;
+  console.warn(
+    "You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored because Undici dispatchers only work in Node environments. To eliminate this warning, omit the `dispatcher_NODE_ONLY` property from your config when running in a non-Node environment."
+  );
+}
+function createHttpTransport(config) {
+  if (__DEV__ && true && "dispatcher_NODE_ONLY" in config) {
+    warnDispatcherWasSuppliedInNonNodeEnvironment();
+  }
+  const { headers, url } = config;
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  let dispatcherConfig;
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      ...dispatcherConfig,
+      body,
+      headers: {
+        ...customHeaders,
+        // Keep these headers lowercase so they will override any user-supplied headers above.
+        accept: "application/json",
+        "content-length": body.length.toString(),
+        "content-type": "application/json; charset=utf-8"
+      },
+      method: "POST",
+      signal
+    };
+    const response = await fetch(url, requestInfo);
+    if (!response.ok) {
+      throw new errors.SolanaError(errors.SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+exports.createHttpTransport = createHttpTransport;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.browser.cjs.map

package/dist/index.browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/http-transport.ts","../src/http-transport-headers.ts"],"names":["SolanaError"],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,yCAAyC,eAAAA,oBAAmB;;;ACArE,SAAS,oDAAoD,mBAAmB;AA2ChF,IAAM,qBAA8C;AAAA,EAChD,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AACpB;AAEA,IAAM,oBAA6C;AAAA,EAC/C,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,kCAAkC;AAAA,EAClC,iCAAiC;AAAA,EACjC,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,sBAAsB;AAAA;AAAA;AAAA;AAAA,EAItB,SAAS;AAAA,EACT,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,qBAAqB;AAAA,EACrB,SAAS;AAAA,EACT,KAAK;AACT;AAEO,SAAS,kCACZ,SAC4C;AAC5C,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,OAAO,gBAAc;AACzD,UAAM,sBAAsB,WAAW,YAAY;AACnD,WACI,mBAAmB,WAAW,YAAY,CAAC,MAAM,QACjD,kBAAkB,WAAW,YAAY,CAAC,MAAM,QAChD,oBAAoB,WAAW,QAAQ,KACvC,oBAAoB,WAAW,MAAM;AAAA,EAE7C,CAAC;AACD,MAAI,WAAW,SAAS,GAAG;AACvB,UAAM,IAAI,YAAY,oDAAoD;AAAA,MACtE,SAAS;AAAA,IACb,CAAC;AAAA,EACL;AACJ;AAMO,SAAS,iBACZ,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;AAAA,EACtD;AACA,SAAO;AACX;;;AD1FA,IAAI,mDAAmD;AACvD,SAAS,gDAAgD;AACrD,MAAI,kDAAkD;AAClD;AAAA,EACJ;AACA,qDAAmD;AACnD,UAAQ;AAAA,IACJ;AAAA,EAIJ;AACJ;AAEO,SAAS,oBAAoB,QAA8B;AAC9D,MAAI,WAAW,QAAe,0BAA0B,QAAQ;AAC5D,kDAA8C;AAAA,EAClD;AACA,QAAM,EAAE,SAAS,IAAI,IAAI;AACzB,MAAI,WAAW,SAAS;AACpB,sCAAkC,OAAO;AAAA,EAC7C;AACA,MAAI;AACJ,MAAI,OAAgD;AAChD,uBAAmB,EAAE,YAAY,OAAO,qBAAqB;AAAA,EACjE;AACA,QAAM,gBAAgB,WAAW,iBAAiB,OAAO;AACzD,SAAO,eAAe,gBAA2B;AAAA,IAC7C;AAAA,IACA;AAAA,EACJ,GAAoD;AAChD,UAAM,OAAO,KAAK,UAAU,OAAO;AACnC,UAAM,cAAc;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,SAAS;AAAA,QACL,GAAG;AAAA;AAAA,QAEH,QAAQ;AAAA,QACR,kBAAkB,KAAK,OAAO,SAAS;AAAA,QACvC,gBAAgB;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,IACJ;AACA,UAAM,WAAW,MAAM,MAAM,KAAK,WAAW;AAC7C,QAAI,CAAC,SAAS,IAAI;AACd,YAAM,IAAIA,aAAY,yCAAyC;AAAA,QAC3D,SAAS,SAAS;AAAA,QAClB,YAAY,SAAS;AAAA,MACzB,CAAC;AAAA,IACL;AACA,WAAQ,MAAM,SAAS,KAAK;AAAA,EAChC;AACJ","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SolanaError } from '@solana/errors';\nimport { RpcTransport } from '@solana/rpc-spec';\nimport type Dispatcher from 'undici/types/dispatcher';\n\nimport {\n    AllowedHttpRequestHeaders,\n    assertIsAllowedHttpRequestHeaders,\n    normalizeHeaders,\n} from './http-transport-headers';\n\ntype Config = Readonly<{\n    dispatcher_NODE_ONLY?: Dispatcher;\n    headers?: AllowedHttpRequestHeaders;\n    url: string;\n}>;\n\nlet didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;\nfunction warnDispatcherWasSuppliedInNonNodeEnvironment() {\n    if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {\n        return;\n    }\n    didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;\n    console.warn(\n        'You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored ' +\n            'because Undici dispatchers only work in Node environments. To eliminate this ' +\n            'warning, omit the `dispatcher_NODE_ONLY` property from your config when running in ' +\n            'a non-Node environment.',\n    );\n}\n\nexport function createHttpTransport(config: Config): RpcTransport {\n    if (__DEV__ && !__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        warnDispatcherWasSuppliedInNonNodeEnvironment();\n    }\n    const { headers, url } = config;\n    if (__DEV__ && headers) {\n        assertIsAllowedHttpRequestHeaders(headers);\n    }\n    let dispatcherConfig: { dispatcher: Dispatcher | undefined } | undefined;\n    if (__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };\n    }\n    const customHeaders = headers && normalizeHeaders(headers);\n    return async function makeHttpRequest<TResponse>({\n        payload,\n        signal,\n    }: Parameters<RpcTransport>[0]): Promise<TResponse> {\n        const body = JSON.stringify(payload);\n        const requestInfo = {\n            ...dispatcherConfig,\n            body,\n            headers: {\n                ...customHeaders,\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                accept: 'application/json',\n                'content-length': body.length.toString(),\n                'content-type': 'application/json; charset=utf-8',\n            },\n            method: 'POST',\n            signal,\n        };\n        const response = await fetch(url, requestInfo);\n        if (!response.ok) {\n            throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {\n                message: response.statusText,\n                statusCode: response.status,\n            });\n        }\n        return (await response.json()) as TResponse;\n    };\n}\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, SolanaError } from '@solana/errors';\n\nexport type AllowedHttpRequestHeaders = Readonly<\n    {\n        // Someone can still sneak a forbidden header past Typescript if they do something like\n        // fOo-BaR, but at that point they deserve the runtime failure.\n        [K in DisallowedHeaders | ForbiddenHeaders as\n            | Capitalize<Lowercase<K>> // `Foo-bar`\n            | K // `Foo-Bar`\n            | Lowercase<K> // `foo-bar`\n            | Uncapitalize<K> // `foo-Bar`\n            // `FOO-BAR`\n            | Uppercase<K>]?: never;\n    } & { [headerName: string]: string }\n>;\n// These are headers that we simply don't allow the developer to override because they're\n// fundamental to the operation of the JSON-RPC transport.\ntype DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';\ntype ForbiddenHeaders =\n    | 'Accept-Charset'\n    | 'Accept-Encoding'\n    | 'Access-Control-Request-Headers'\n    | 'Access-Control-Request-Method'\n    | 'Connection'\n    | 'Content-Length'\n    | 'Cookie'\n    | 'Date'\n    | 'DNT'\n    | 'Expect'\n    | 'Host'\n    | 'Keep-Alive'\n    | 'Origin'\n    | 'Permissions-Policy'\n    | 'Referer'\n    | 'TE'\n    | 'Trailer'\n    | 'Transfer-Encoding'\n    | 'Upgrade'\n    | 'Via'\n    | `Proxy-${string}`\n    | `Sec-${string}`;\n\n// These are headers which are fundamental to the JSON-RPC transport, and must not be modified.\nconst DISALLOWED_HEADERS: Record<string, boolean> = {\n    accept: true,\n    'content-length': true,\n    'content-type': true,\n};\n// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name\nconst FORBIDDEN_HEADERS: Record<string, boolean> = {\n    'accept-charset': true,\n    'accept-encoding': true,\n    'access-control-request-headers': true,\n    'access-control-request-method': true,\n    connection: true,\n    'content-length': true,\n    cookie: true,\n    date: true,\n    dnt: true,\n    expect: true,\n    host: true,\n    'keep-alive': true,\n    origin: true,\n    'permissions-policy': true,\n    // Prefix matching is implemented in code, below.\n    // 'proxy-': true,\n    // 'sec-': true,\n    referer: true,\n    te: true,\n    trailer: true,\n    'transfer-encoding': true,\n    upgrade: true,\n    via: true,\n};\n\nexport function assertIsAllowedHttpRequestHeaders(\n    headers: Record<string, string>,\n): asserts headers is AllowedHttpRequestHeaders {\n    const badHeaders = Object.keys(headers).filter(headerName => {\n        const lowercaseHeaderName = headerName.toLowerCase();\n        return (\n            DISALLOWED_HEADERS[headerName.toLowerCase()] === true ||\n            FORBIDDEN_HEADERS[headerName.toLowerCase()] === true ||\n            lowercaseHeaderName.startsWith('proxy-') ||\n            lowercaseHeaderName.startsWith('sec-')\n        );\n    });\n    if (badHeaders.length > 0) {\n        throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {\n            headers: badHeaders,\n        });\n    }\n}\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers, such as those defined\n * in the `DisallowedHeaders` type.\n */\nexport function normalizeHeaders<T extends Record<string, string>>(\n    headers: T,\n): { [K in string & keyof T as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in string & keyof T as Lowercase<K>]: T[K] };\n}\n"]}

package/dist/index.browser.js

@@ -0,0 +1,106 @@
+import { SolanaError, SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN } from '@solana/errors';
+
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+var DISALLOWED_HEADERS = {
+  accept: true,
+  "content-length": true,
+  "content-type": true
+};
+var FORBIDDEN_HEADERS = {
+  "accept-charset": true,
+  "accept-encoding": true,
+  "access-control-request-headers": true,
+  "access-control-request-method": true,
+  connection: true,
+  "content-length": true,
+  cookie: true,
+  date: true,
+  dnt: true,
+  expect: true,
+  host: true,
+  "keep-alive": true,
+  origin: true,
+  "permissions-policy": true,
+  // Prefix matching is implemented in code, below.
+  // 'proxy-': true,
+  // 'sec-': true,
+  referer: true,
+  te: true,
+  trailer: true,
+  "transfer-encoding": true,
+  upgrade: true,
+  via: true
+};
+function assertIsAllowedHttpRequestHeaders(headers) {
+  const badHeaders = Object.keys(headers).filter((headerName) => {
+    const lowercaseHeaderName = headerName.toLowerCase();
+    return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+  });
+  if (badHeaders.length > 0) {
+    throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {
+      headers: badHeaders
+    });
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/http-transport.ts
+var didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;
+function warnDispatcherWasSuppliedInNonNodeEnvironment() {
+  if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {
+    return;
+  }
+  didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;
+  console.warn(
+    "You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored because Undici dispatchers only work in Node environments. To eliminate this warning, omit the `dispatcher_NODE_ONLY` property from your config when running in a non-Node environment."
+  );
+}
+function createHttpTransport(config) {
+  if (__DEV__ && true && "dispatcher_NODE_ONLY" in config) {
+    warnDispatcherWasSuppliedInNonNodeEnvironment();
+  }
+  const { headers, url } = config;
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  let dispatcherConfig;
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      ...dispatcherConfig,
+      body,
+      headers: {
+        ...customHeaders,
+        // Keep these headers lowercase so they will override any user-supplied headers above.
+        accept: "application/json",
+        "content-length": body.length.toString(),
+        "content-type": "application/json; charset=utf-8"
+      },
+      method: "POST",
+      signal
+    };
+    const response = await fetch(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+export { createHttpTransport };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.browser.js.map

package/dist/index.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/http-transport.ts","../src/http-transport-headers.ts"],"names":["SolanaError"],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,yCAAyC,eAAAA,oBAAmB;;;ACArE,SAAS,oDAAoD,mBAAmB;AA2ChF,IAAM,qBAA8C;AAAA,EAChD,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AACpB;AAEA,IAAM,oBAA6C;AAAA,EAC/C,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,kCAAkC;AAAA,EAClC,iCAAiC;AAAA,EACjC,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,sBAAsB;AAAA;AAAA;AAAA;AAAA,EAItB,SAAS;AAAA,EACT,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,qBAAqB;AAAA,EACrB,SAAS;AAAA,EACT,KAAK;AACT;AAEO,SAAS,kCACZ,SAC4C;AAC5C,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,OAAO,gBAAc;AACzD,UAAM,sBAAsB,WAAW,YAAY;AACnD,WACI,mBAAmB,WAAW,YAAY,CAAC,MAAM,QACjD,kBAAkB,WAAW,YAAY,CAAC,MAAM,QAChD,oBAAoB,WAAW,QAAQ,KACvC,oBAAoB,WAAW,MAAM;AAAA,EAE7C,CAAC;AACD,MAAI,WAAW,SAAS,GAAG;AACvB,UAAM,IAAI,YAAY,oDAAoD;AAAA,MACtE,SAAS;AAAA,IACb,CAAC;AAAA,EACL;AACJ;AAMO,SAAS,iBACZ,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;AAAA,EACtD;AACA,SAAO;AACX;;;AD1FA,IAAI,mDAAmD;AACvD,SAAS,gDAAgD;AACrD,MAAI,kDAAkD;AAClD;AAAA,EACJ;AACA,qDAAmD;AACnD,UAAQ;AAAA,IACJ;AAAA,EAIJ;AACJ;AAEO,SAAS,oBAAoB,QAA8B;AAC9D,MAAI,WAAW,QAAe,0BAA0B,QAAQ;AAC5D,kDAA8C;AAAA,EAClD;AACA,QAAM,EAAE,SAAS,IAAI,IAAI;AACzB,MAAI,WAAW,SAAS;AACpB,sCAAkC,OAAO;AAAA,EAC7C;AACA,MAAI;AACJ,MAAI,OAAgD;AAChD,uBAAmB,EAAE,YAAY,OAAO,qBAAqB;AAAA,EACjE;AACA,QAAM,gBAAgB,WAAW,iBAAiB,OAAO;AACzD,SAAO,eAAe,gBAA2B;AAAA,IAC7C;AAAA,IACA;AAAA,EACJ,GAAoD;AAChD,UAAM,OAAO,KAAK,UAAU,OAAO;AACnC,UAAM,cAAc;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,SAAS;AAAA,QACL,GAAG;AAAA;AAAA,QAEH,QAAQ;AAAA,QACR,kBAAkB,KAAK,OAAO,SAAS;AAAA,QACvC,gBAAgB;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,IACJ;AACA,UAAM,WAAW,MAAM,MAAM,KAAK,WAAW;AAC7C,QAAI,CAAC,SAAS,IAAI;AACd,YAAM,IAAIA,aAAY,yCAAyC;AAAA,QAC3D,SAAS,SAAS;AAAA,QAClB,YAAY,SAAS;AAAA,MACzB,CAAC;AAAA,IACL;AACA,WAAQ,MAAM,SAAS,KAAK;AAAA,EAChC;AACJ","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SolanaError } from '@solana/errors';\nimport { RpcTransport } from '@solana/rpc-spec';\nimport type Dispatcher from 'undici/types/dispatcher';\n\nimport {\n    AllowedHttpRequestHeaders,\n    assertIsAllowedHttpRequestHeaders,\n    normalizeHeaders,\n} from './http-transport-headers';\n\ntype Config = Readonly<{\n    dispatcher_NODE_ONLY?: Dispatcher;\n    headers?: AllowedHttpRequestHeaders;\n    url: string;\n}>;\n\nlet didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;\nfunction warnDispatcherWasSuppliedInNonNodeEnvironment() {\n    if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {\n        return;\n    }\n    didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;\n    console.warn(\n        'You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored ' +\n            'because Undici dispatchers only work in Node environments. To eliminate this ' +\n            'warning, omit the `dispatcher_NODE_ONLY` property from your config when running in ' +\n            'a non-Node environment.',\n    );\n}\n\nexport function createHttpTransport(config: Config): RpcTransport {\n    if (__DEV__ && !__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        warnDispatcherWasSuppliedInNonNodeEnvironment();\n    }\n    const { headers, url } = config;\n    if (__DEV__ && headers) {\n        assertIsAllowedHttpRequestHeaders(headers);\n    }\n    let dispatcherConfig: { dispatcher: Dispatcher | undefined } | undefined;\n    if (__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };\n    }\n    const customHeaders = headers && normalizeHeaders(headers);\n    return async function makeHttpRequest<TResponse>({\n        payload,\n        signal,\n    }: Parameters<RpcTransport>[0]): Promise<TResponse> {\n        const body = JSON.stringify(payload);\n        const requestInfo = {\n            ...dispatcherConfig,\n            body,\n            headers: {\n                ...customHeaders,\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                accept: 'application/json',\n                'content-length': body.length.toString(),\n                'content-type': 'application/json; charset=utf-8',\n            },\n            method: 'POST',\n            signal,\n        };\n        const response = await fetch(url, requestInfo);\n        if (!response.ok) {\n            throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {\n                message: response.statusText,\n                statusCode: response.status,\n            });\n        }\n        return (await response.json()) as TResponse;\n    };\n}\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, SolanaError } from '@solana/errors';\n\nexport type AllowedHttpRequestHeaders = Readonly<\n    {\n        // Someone can still sneak a forbidden header past Typescript if they do something like\n        // fOo-BaR, but at that point they deserve the runtime failure.\n        [K in DisallowedHeaders | ForbiddenHeaders as\n            | Capitalize<Lowercase<K>> // `Foo-bar`\n            | K // `Foo-Bar`\n            | Lowercase<K> // `foo-bar`\n            | Uncapitalize<K> // `foo-Bar`\n            // `FOO-BAR`\n            | Uppercase<K>]?: never;\n    } & { [headerName: string]: string }\n>;\n// These are headers that we simply don't allow the developer to override because they're\n// fundamental to the operation of the JSON-RPC transport.\ntype DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';\ntype ForbiddenHeaders =\n    | 'Accept-Charset'\n    | 'Accept-Encoding'\n    | 'Access-Control-Request-Headers'\n    | 'Access-Control-Request-Method'\n    | 'Connection'\n    | 'Content-Length'\n    | 'Cookie'\n    | 'Date'\n    | 'DNT'\n    | 'Expect'\n    | 'Host'\n    | 'Keep-Alive'\n    | 'Origin'\n    | 'Permissions-Policy'\n    | 'Referer'\n    | 'TE'\n    | 'Trailer'\n    | 'Transfer-Encoding'\n    | 'Upgrade'\n    | 'Via'\n    | `Proxy-${string}`\n    | `Sec-${string}`;\n\n// These are headers which are fundamental to the JSON-RPC transport, and must not be modified.\nconst DISALLOWED_HEADERS: Record<string, boolean> = {\n    accept: true,\n    'content-length': true,\n    'content-type': true,\n};\n// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name\nconst FORBIDDEN_HEADERS: Record<string, boolean> = {\n    'accept-charset': true,\n    'accept-encoding': true,\n    'access-control-request-headers': true,\n    'access-control-request-method': true,\n    connection: true,\n    'content-length': true,\n    cookie: true,\n    date: true,\n    dnt: true,\n    expect: true,\n    host: true,\n    'keep-alive': true,\n    origin: true,\n    'permissions-policy': true,\n    // Prefix matching is implemented in code, below.\n    // 'proxy-': true,\n    // 'sec-': true,\n    referer: true,\n    te: true,\n    trailer: true,\n    'transfer-encoding': true,\n    upgrade: true,\n    via: true,\n};\n\nexport function assertIsAllowedHttpRequestHeaders(\n    headers: Record<string, string>,\n): asserts headers is AllowedHttpRequestHeaders {\n    const badHeaders = Object.keys(headers).filter(headerName => {\n        const lowercaseHeaderName = headerName.toLowerCase();\n        return (\n            DISALLOWED_HEADERS[headerName.toLowerCase()] === true ||\n            FORBIDDEN_HEADERS[headerName.toLowerCase()] === true ||\n            lowercaseHeaderName.startsWith('proxy-') ||\n            lowercaseHeaderName.startsWith('sec-')\n        );\n    });\n    if (badHeaders.length > 0) {\n        throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {\n            headers: badHeaders,\n        });\n    }\n}\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers, such as those defined\n * in the `DisallowedHeaders` type.\n */\nexport function normalizeHeaders<T extends Record<string, string>>(\n    headers: T,\n): { [K in string & keyof T as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in string & keyof T as Lowercase<K>]: T[K] };\n}\n"]}

package/dist/index.native.js

@@ -0,0 +1,106 @@
+import { SolanaError, SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN } from '@solana/errors';
+
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+var DISALLOWED_HEADERS = {
+  accept: true,
+  "content-length": true,
+  "content-type": true
+};
+var FORBIDDEN_HEADERS = {
+  "accept-charset": true,
+  "accept-encoding": true,
+  "access-control-request-headers": true,
+  "access-control-request-method": true,
+  connection: true,
+  "content-length": true,
+  cookie: true,
+  date: true,
+  dnt: true,
+  expect: true,
+  host: true,
+  "keep-alive": true,
+  origin: true,
+  "permissions-policy": true,
+  // Prefix matching is implemented in code, below.
+  // 'proxy-': true,
+  // 'sec-': true,
+  referer: true,
+  te: true,
+  trailer: true,
+  "transfer-encoding": true,
+  upgrade: true,
+  via: true
+};
+function assertIsAllowedHttpRequestHeaders(headers) {
+  const badHeaders = Object.keys(headers).filter((headerName) => {
+    const lowercaseHeaderName = headerName.toLowerCase();
+    return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+  });
+  if (badHeaders.length > 0) {
+    throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {
+      headers: badHeaders
+    });
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/http-transport.ts
+var didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;
+function warnDispatcherWasSuppliedInNonNodeEnvironment() {
+  if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {
+    return;
+  }
+  didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;
+  console.warn(
+    "You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored because Undici dispatchers only work in Node environments. To eliminate this warning, omit the `dispatcher_NODE_ONLY` property from your config when running in a non-Node environment."
+  );
+}
+function createHttpTransport(config) {
+  if (__DEV__ && true && "dispatcher_NODE_ONLY" in config) {
+    warnDispatcherWasSuppliedInNonNodeEnvironment();
+  }
+  const { headers, url } = config;
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  let dispatcherConfig;
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      ...dispatcherConfig,
+      body,
+      headers: {
+        ...customHeaders,
+        // Keep these headers lowercase so they will override any user-supplied headers above.
+        accept: "application/json",
+        "content-length": body.length.toString(),
+        "content-type": "application/json; charset=utf-8"
+      },
+      method: "POST",
+      signal
+    };
+    const response = await fetch(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+export { createHttpTransport };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.native.js.map

package/dist/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/http-transport.ts","../src/http-transport-headers.ts"],"names":["SolanaError"],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,yCAAyC,eAAAA,oBAAmB;;;ACArE,SAAS,oDAAoD,mBAAmB;AA2ChF,IAAM,qBAA8C;AAAA,EAChD,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AACpB;AAEA,IAAM,oBAA6C;AAAA,EAC/C,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,kCAAkC;AAAA,EAClC,iCAAiC;AAAA,EACjC,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,sBAAsB;AAAA;AAAA;AAAA;AAAA,EAItB,SAAS;AAAA,EACT,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,qBAAqB;AAAA,EACrB,SAAS;AAAA,EACT,KAAK;AACT;AAEO,SAAS,kCACZ,SAC4C;AAC5C,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,OAAO,gBAAc;AACzD,UAAM,sBAAsB,WAAW,YAAY;AACnD,WACI,mBAAmB,WAAW,YAAY,CAAC,MAAM,QACjD,kBAAkB,WAAW,YAAY,CAAC,MAAM,QAChD,oBAAoB,WAAW,QAAQ,KACvC,oBAAoB,WAAW,MAAM;AAAA,EAE7C,CAAC;AACD,MAAI,WAAW,SAAS,GAAG;AACvB,UAAM,IAAI,YAAY,oDAAoD;AAAA,MACtE,SAAS;AAAA,IACb,CAAC;AAAA,EACL;AACJ;AAMO,SAAS,iBACZ,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;AAAA,EACtD;AACA,SAAO;AACX;;;AD1FA,IAAI,mDAAmD;AACvD,SAAS,gDAAgD;AACrD,MAAI,kDAAkD;AAClD;AAAA,EACJ;AACA,qDAAmD;AACnD,UAAQ;AAAA,IACJ;AAAA,EAIJ;AACJ;AAEO,SAAS,oBAAoB,QAA8B;AAC9D,MAAI,WAAW,QAAe,0BAA0B,QAAQ;AAC5D,kDAA8C;AAAA,EAClD;AACA,QAAM,EAAE,SAAS,IAAI,IAAI;AACzB,MAAI,WAAW,SAAS;AACpB,sCAAkC,OAAO;AAAA,EAC7C;AACA,MAAI;AACJ,MAAI,OAAgD;AAChD,uBAAmB,EAAE,YAAY,OAAO,qBAAqB;AAAA,EACjE;AACA,QAAM,gBAAgB,WAAW,iBAAiB,OAAO;AACzD,SAAO,eAAe,gBAA2B;AAAA,IAC7C;AAAA,IACA;AAAA,EACJ,GAAoD;AAChD,UAAM,OAAO,KAAK,UAAU,OAAO;AACnC,UAAM,cAAc;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,SAAS;AAAA,QACL,GAAG;AAAA;AAAA,QAEH,QAAQ;AAAA,QACR,kBAAkB,KAAK,OAAO,SAAS;AAAA,QACvC,gBAAgB;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,IACJ;AACA,UAAM,WAAW,MAAM,MAAM,KAAK,WAAW;AAC7C,QAAI,CAAC,SAAS,IAAI;AACd,YAAM,IAAIA,aAAY,yCAAyC;AAAA,QAC3D,SAAS,SAAS;AAAA,QAClB,YAAY,SAAS;AAAA,MACzB,CAAC;AAAA,IACL;AACA,WAAQ,MAAM,SAAS,KAAK;AAAA,EAChC;AACJ","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SolanaError } from '@solana/errors';\nimport { RpcTransport } from '@solana/rpc-spec';\nimport type Dispatcher from 'undici/types/dispatcher';\n\nimport {\n    AllowedHttpRequestHeaders,\n    assertIsAllowedHttpRequestHeaders,\n    normalizeHeaders,\n} from './http-transport-headers';\n\ntype Config = Readonly<{\n    dispatcher_NODE_ONLY?: Dispatcher;\n    headers?: AllowedHttpRequestHeaders;\n    url: string;\n}>;\n\nlet didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;\nfunction warnDispatcherWasSuppliedInNonNodeEnvironment() {\n    if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {\n        return;\n    }\n    didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;\n    console.warn(\n        'You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored ' +\n            'because Undici dispatchers only work in Node environments. To eliminate this ' +\n            'warning, omit the `dispatcher_NODE_ONLY` property from your config when running in ' +\n            'a non-Node environment.',\n    );\n}\n\nexport function createHttpTransport(config: Config): RpcTransport {\n    if (__DEV__ && !__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        warnDispatcherWasSuppliedInNonNodeEnvironment();\n    }\n    const { headers, url } = config;\n    if (__DEV__ && headers) {\n        assertIsAllowedHttpRequestHeaders(headers);\n    }\n    let dispatcherConfig: { dispatcher: Dispatcher | undefined } | undefined;\n    if (__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };\n    }\n    const customHeaders = headers && normalizeHeaders(headers);\n    return async function makeHttpRequest<TResponse>({\n        payload,\n        signal,\n    }: Parameters<RpcTransport>[0]): Promise<TResponse> {\n        const body = JSON.stringify(payload);\n        const requestInfo = {\n            ...dispatcherConfig,\n            body,\n            headers: {\n                ...customHeaders,\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                accept: 'application/json',\n                'content-length': body.length.toString(),\n                'content-type': 'application/json; charset=utf-8',\n            },\n            method: 'POST',\n            signal,\n        };\n        const response = await fetch(url, requestInfo);\n        if (!response.ok) {\n            throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {\n                message: response.statusText,\n                statusCode: response.status,\n            });\n        }\n        return (await response.json()) as TResponse;\n    };\n}\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, SolanaError } from '@solana/errors';\n\nexport type AllowedHttpRequestHeaders = Readonly<\n    {\n        // Someone can still sneak a forbidden header past Typescript if they do something like\n        // fOo-BaR, but at that point they deserve the runtime failure.\n        [K in DisallowedHeaders | ForbiddenHeaders as\n            | Capitalize<Lowercase<K>> // `Foo-bar`\n            | K // `Foo-Bar`\n            | Lowercase<K> // `foo-bar`\n            | Uncapitalize<K> // `foo-Bar`\n            // `FOO-BAR`\n            | Uppercase<K>]?: never;\n    } & { [headerName: string]: string }\n>;\n// These are headers that we simply don't allow the developer to override because they're\n// fundamental to the operation of the JSON-RPC transport.\ntype DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';\ntype ForbiddenHeaders =\n    | 'Accept-Charset'\n    | 'Accept-Encoding'\n    | 'Access-Control-Request-Headers'\n    | 'Access-Control-Request-Method'\n    | 'Connection'\n    | 'Content-Length'\n    | 'Cookie'\n    | 'Date'\n    | 'DNT'\n    | 'Expect'\n    | 'Host'\n    | 'Keep-Alive'\n    | 'Origin'\n    | 'Permissions-Policy'\n    | 'Referer'\n    | 'TE'\n    | 'Trailer'\n    | 'Transfer-Encoding'\n    | 'Upgrade'\n    | 'Via'\n    | `Proxy-${string}`\n    | `Sec-${string}`;\n\n// These are headers which are fundamental to the JSON-RPC transport, and must not be modified.\nconst DISALLOWED_HEADERS: Record<string, boolean> = {\n    accept: true,\n    'content-length': true,\n    'content-type': true,\n};\n// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name\nconst FORBIDDEN_HEADERS: Record<string, boolean> = {\n    'accept-charset': true,\n    'accept-encoding': true,\n    'access-control-request-headers': true,\n    'access-control-request-method': true,\n    connection: true,\n    'content-length': true,\n    cookie: true,\n    date: true,\n    dnt: true,\n    expect: true,\n    host: true,\n    'keep-alive': true,\n    origin: true,\n    'permissions-policy': true,\n    // Prefix matching is implemented in code, below.\n    // 'proxy-': true,\n    // 'sec-': true,\n    referer: true,\n    te: true,\n    trailer: true,\n    'transfer-encoding': true,\n    upgrade: true,\n    via: true,\n};\n\nexport function assertIsAllowedHttpRequestHeaders(\n    headers: Record<string, string>,\n): asserts headers is AllowedHttpRequestHeaders {\n    const badHeaders = Object.keys(headers).filter(headerName => {\n        const lowercaseHeaderName = headerName.toLowerCase();\n        return (\n            DISALLOWED_HEADERS[headerName.toLowerCase()] === true ||\n            FORBIDDEN_HEADERS[headerName.toLowerCase()] === true ||\n            lowercaseHeaderName.startsWith('proxy-') ||\n            lowercaseHeaderName.startsWith('sec-')\n        );\n    });\n    if (badHeaders.length > 0) {\n        throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {\n            headers: badHeaders,\n        });\n    }\n}\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers, such as those defined\n * in the `DisallowedHeaders` type.\n */\nexport function normalizeHeaders<T extends Record<string, string>>(\n    headers: T,\n): { [K in string & keyof T as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in string & keyof T as Lowercase<K>]: T[K] };\n}\n"]}

package/dist/index.node.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+var errors = require('@solana/errors');
+
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+var DISALLOWED_HEADERS = {
+  accept: true,
+  "content-length": true,
+  "content-type": true
+};
+var FORBIDDEN_HEADERS = {
+  "accept-charset": true,
+  "accept-encoding": true,
+  "access-control-request-headers": true,
+  "access-control-request-method": true,
+  connection: true,
+  "content-length": true,
+  cookie: true,
+  date: true,
+  dnt: true,
+  expect: true,
+  host: true,
+  "keep-alive": true,
+  origin: true,
+  "permissions-policy": true,
+  // Prefix matching is implemented in code, below.
+  // 'proxy-': true,
+  // 'sec-': true,
+  referer: true,
+  te: true,
+  trailer: true,
+  "transfer-encoding": true,
+  upgrade: true,
+  via: true
+};
+function assertIsAllowedHttpRequestHeaders(headers) {
+  const badHeaders = Object.keys(headers).filter((headerName) => {
+    const lowercaseHeaderName = headerName.toLowerCase();
+    return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+  });
+  if (badHeaders.length > 0) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {
+      headers: badHeaders
+    });
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/http-transport.ts
+function createHttpTransport(config) {
+  if (__DEV__ && false) {
+    warnDispatcherWasSuppliedInNonNodeEnvironment();
+  }
+  const { headers, url } = config;
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  let dispatcherConfig;
+  if ("dispatcher_NODE_ONLY" in config) {
+    dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };
+  }
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      ...dispatcherConfig,
+      body,
+      headers: {
+        ...customHeaders,
+        // Keep these headers lowercase so they will override any user-supplied headers above.
+        accept: "application/json",
+        "content-length": body.length.toString(),
+        "content-type": "application/json; charset=utf-8"
+      },
+      method: "POST",
+      signal
+    };
+    const response = await fetch(url, requestInfo);
+    if (!response.ok) {
+      throw new errors.SolanaError(errors.SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+exports.createHttpTransport = createHttpTransport;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.node.cjs.map

package/dist/index.node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/http-transport.ts","../src/http-transport-headers.ts"],"names":["SolanaError"],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,yCAAyC,eAAAA,oBAAmB;;;ACArE,SAAS,oDAAoD,mBAAmB;AA2ChF,IAAM,qBAA8C;AAAA,EAChD,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AACpB;AAEA,IAAM,oBAA6C;AAAA,EAC/C,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,kCAAkC;AAAA,EAClC,iCAAiC;AAAA,EACjC,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,sBAAsB;AAAA;AAAA;AAAA;AAAA,EAItB,SAAS;AAAA,EACT,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,qBAAqB;AAAA,EACrB,SAAS;AAAA,EACT,KAAK;AACT;AAEO,SAAS,kCACZ,SAC4C;AAC5C,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,OAAO,gBAAc;AACzD,UAAM,sBAAsB,WAAW,YAAY;AACnD,WACI,mBAAmB,WAAW,YAAY,CAAC,MAAM,QACjD,kBAAkB,WAAW,YAAY,CAAC,MAAM,QAChD,oBAAoB,WAAW,QAAQ,KACvC,oBAAoB,WAAW,MAAM;AAAA,EAE7C,CAAC;AACD,MAAI,WAAW,SAAS,GAAG;AACvB,UAAM,IAAI,YAAY,oDAAoD;AAAA,MACtE,SAAS;AAAA,IACb,CAAC;AAAA,EACL;AACJ;AAMO,SAAS,iBACZ,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;AAAA,EACtD;AACA,SAAO;AACX;;;AD5EO,SAAS,oBAAoB,QAA8B;AAC9D,MAAI,WAAW,OAAiD;AAC5D,kDAA8C;AAAA,EAClD;AACA,QAAM,EAAE,SAAS,IAAI,IAAI;AACzB,MAAI,WAAW,SAAS;AACpB,sCAAkC,OAAO;AAAA,EAC7C;AACA,MAAI;AACJ,MAAkB,0BAA0B,QAAQ;AAChD,uBAAmB,EAAE,YAAY,OAAO,qBAAqB;AAAA,EACjE;AACA,QAAM,gBAAgB,WAAW,iBAAiB,OAAO;AACzD,SAAO,eAAe,gBAA2B;AAAA,IAC7C;AAAA,IACA;AAAA,EACJ,GAAoD;AAChD,UAAM,OAAO,KAAK,UAAU,OAAO;AACnC,UAAM,cAAc;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,SAAS;AAAA,QACL,GAAG;AAAA;AAAA,QAEH,QAAQ;AAAA,QACR,kBAAkB,KAAK,OAAO,SAAS;AAAA,QACvC,gBAAgB;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,IACJ;AACA,UAAM,WAAW,MAAM,MAAM,KAAK,WAAW;AAC7C,QAAI,CAAC,SAAS,IAAI;AACd,YAAM,IAAIA,aAAY,yCAAyC;AAAA,QAC3D,SAAS,SAAS;AAAA,QAClB,YAAY,SAAS;AAAA,MACzB,CAAC;AAAA,IACL;AACA,WAAQ,MAAM,SAAS,KAAK;AAAA,EAChC;AACJ","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SolanaError } from '@solana/errors';\nimport { RpcTransport } from '@solana/rpc-spec';\nimport type Dispatcher from 'undici/types/dispatcher';\n\nimport {\n    AllowedHttpRequestHeaders,\n    assertIsAllowedHttpRequestHeaders,\n    normalizeHeaders,\n} from './http-transport-headers';\n\ntype Config = Readonly<{\n    dispatcher_NODE_ONLY?: Dispatcher;\n    headers?: AllowedHttpRequestHeaders;\n    url: string;\n}>;\n\nlet didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;\nfunction warnDispatcherWasSuppliedInNonNodeEnvironment() {\n    if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {\n        return;\n    }\n    didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;\n    console.warn(\n        'You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored ' +\n            'because Undici dispatchers only work in Node environments. To eliminate this ' +\n            'warning, omit the `dispatcher_NODE_ONLY` property from your config when running in ' +\n            'a non-Node environment.',\n    );\n}\n\nexport function createHttpTransport(config: Config): RpcTransport {\n    if (__DEV__ && !__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        warnDispatcherWasSuppliedInNonNodeEnvironment();\n    }\n    const { headers, url } = config;\n    if (__DEV__ && headers) {\n        assertIsAllowedHttpRequestHeaders(headers);\n    }\n    let dispatcherConfig: { dispatcher: Dispatcher | undefined } | undefined;\n    if (__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };\n    }\n    const customHeaders = headers && normalizeHeaders(headers);\n    return async function makeHttpRequest<TResponse>({\n        payload,\n        signal,\n    }: Parameters<RpcTransport>[0]): Promise<TResponse> {\n        const body = JSON.stringify(payload);\n        const requestInfo = {\n            ...dispatcherConfig,\n            body,\n            headers: {\n                ...customHeaders,\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                accept: 'application/json',\n                'content-length': body.length.toString(),\n                'content-type': 'application/json; charset=utf-8',\n            },\n            method: 'POST',\n            signal,\n        };\n        const response = await fetch(url, requestInfo);\n        if (!response.ok) {\n            throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {\n                message: response.statusText,\n                statusCode: response.status,\n            });\n        }\n        return (await response.json()) as TResponse;\n    };\n}\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, SolanaError } from '@solana/errors';\n\nexport type AllowedHttpRequestHeaders = Readonly<\n    {\n        // Someone can still sneak a forbidden header past Typescript if they do something like\n        // fOo-BaR, but at that point they deserve the runtime failure.\n        [K in DisallowedHeaders | ForbiddenHeaders as\n            | Capitalize<Lowercase<K>> // `Foo-bar`\n            | K // `Foo-Bar`\n            | Lowercase<K> // `foo-bar`\n            | Uncapitalize<K> // `foo-Bar`\n            // `FOO-BAR`\n            | Uppercase<K>]?: never;\n    } & { [headerName: string]: string }\n>;\n// These are headers that we simply don't allow the developer to override because they're\n// fundamental to the operation of the JSON-RPC transport.\ntype DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';\ntype ForbiddenHeaders =\n    | 'Accept-Charset'\n    | 'Accept-Encoding'\n    | 'Access-Control-Request-Headers'\n    | 'Access-Control-Request-Method'\n    | 'Connection'\n    | 'Content-Length'\n    | 'Cookie'\n    | 'Date'\n    | 'DNT'\n    | 'Expect'\n    | 'Host'\n    | 'Keep-Alive'\n    | 'Origin'\n    | 'Permissions-Policy'\n    | 'Referer'\n    | 'TE'\n    | 'Trailer'\n    | 'Transfer-Encoding'\n    | 'Upgrade'\n    | 'Via'\n    | `Proxy-${string}`\n    | `Sec-${string}`;\n\n// These are headers which are fundamental to the JSON-RPC transport, and must not be modified.\nconst DISALLOWED_HEADERS: Record<string, boolean> = {\n    accept: true,\n    'content-length': true,\n    'content-type': true,\n};\n// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name\nconst FORBIDDEN_HEADERS: Record<string, boolean> = {\n    'accept-charset': true,\n    'accept-encoding': true,\n    'access-control-request-headers': true,\n    'access-control-request-method': true,\n    connection: true,\n    'content-length': true,\n    cookie: true,\n    date: true,\n    dnt: true,\n    expect: true,\n    host: true,\n    'keep-alive': true,\n    origin: true,\n    'permissions-policy': true,\n    // Prefix matching is implemented in code, below.\n    // 'proxy-': true,\n    // 'sec-': true,\n    referer: true,\n    te: true,\n    trailer: true,\n    'transfer-encoding': true,\n    upgrade: true,\n    via: true,\n};\n\nexport function assertIsAllowedHttpRequestHeaders(\n    headers: Record<string, string>,\n): asserts headers is AllowedHttpRequestHeaders {\n    const badHeaders = Object.keys(headers).filter(headerName => {\n        const lowercaseHeaderName = headerName.toLowerCase();\n        return (\n            DISALLOWED_HEADERS[headerName.toLowerCase()] === true ||\n            FORBIDDEN_HEADERS[headerName.toLowerCase()] === true ||\n            lowercaseHeaderName.startsWith('proxy-') ||\n            lowercaseHeaderName.startsWith('sec-')\n        );\n    });\n    if (badHeaders.length > 0) {\n        throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {\n            headers: badHeaders,\n        });\n    }\n}\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers, such as those defined\n * in the `DisallowedHeaders` type.\n */\nexport function normalizeHeaders<T extends Record<string, string>>(\n    headers: T,\n): { [K in string & keyof T as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in string & keyof T as Lowercase<K>]: T[K] };\n}\n"]}

package/dist/index.node.js

@@ -0,0 +1,99 @@
+import { SolanaError, SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN } from '@solana/errors';
+
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+var DISALLOWED_HEADERS = {
+  accept: true,
+  "content-length": true,
+  "content-type": true
+};
+var FORBIDDEN_HEADERS = {
+  "accept-charset": true,
+  "accept-encoding": true,
+  "access-control-request-headers": true,
+  "access-control-request-method": true,
+  connection: true,
+  "content-length": true,
+  cookie: true,
+  date: true,
+  dnt: true,
+  expect: true,
+  host: true,
+  "keep-alive": true,
+  origin: true,
+  "permissions-policy": true,
+  // Prefix matching is implemented in code, below.
+  // 'proxy-': true,
+  // 'sec-': true,
+  referer: true,
+  te: true,
+  trailer: true,
+  "transfer-encoding": true,
+  upgrade: true,
+  via: true
+};
+function assertIsAllowedHttpRequestHeaders(headers) {
+  const badHeaders = Object.keys(headers).filter((headerName) => {
+    const lowercaseHeaderName = headerName.toLowerCase();
+    return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+  });
+  if (badHeaders.length > 0) {
+    throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {
+      headers: badHeaders
+    });
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/http-transport.ts
+function createHttpTransport(config) {
+  if (__DEV__ && false) {
+    warnDispatcherWasSuppliedInNonNodeEnvironment();
+  }
+  const { headers, url } = config;
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  let dispatcherConfig;
+  if ("dispatcher_NODE_ONLY" in config) {
+    dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };
+  }
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      ...dispatcherConfig,
+      body,
+      headers: {
+        ...customHeaders,
+        // Keep these headers lowercase so they will override any user-supplied headers above.
+        accept: "application/json",
+        "content-length": body.length.toString(),
+        "content-type": "application/json; charset=utf-8"
+      },
+      method: "POST",
+      signal
+    };
+    const response = await fetch(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+export { createHttpTransport };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.node.js.map

package/dist/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/http-transport.ts","../src/http-transport-headers.ts"],"names":["SolanaError"],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,yCAAyC,eAAAA,oBAAmB;;;ACArE,SAAS,oDAAoD,mBAAmB;AA2ChF,IAAM,qBAA8C;AAAA,EAChD,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,gBAAgB;AACpB;AAEA,IAAM,oBAA6C;AAAA,EAC/C,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,kCAAkC;AAAA,EAClC,iCAAiC;AAAA,EACjC,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,sBAAsB;AAAA;AAAA;AAAA;AAAA,EAItB,SAAS;AAAA,EACT,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,qBAAqB;AAAA,EACrB,SAAS;AAAA,EACT,KAAK;AACT;AAEO,SAAS,kCACZ,SAC4C;AAC5C,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,OAAO,gBAAc;AACzD,UAAM,sBAAsB,WAAW,YAAY;AACnD,WACI,mBAAmB,WAAW,YAAY,CAAC,MAAM,QACjD,kBAAkB,WAAW,YAAY,CAAC,MAAM,QAChD,oBAAoB,WAAW,QAAQ,KACvC,oBAAoB,WAAW,MAAM;AAAA,EAE7C,CAAC;AACD,MAAI,WAAW,SAAS,GAAG;AACvB,UAAM,IAAI,YAAY,oDAAoD;AAAA,MACtE,SAAS;AAAA,IACb,CAAC;AAAA,EACL;AACJ;AAMO,SAAS,iBACZ,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;AAAA,EACtD;AACA,SAAO;AACX;;;AD5EO,SAAS,oBAAoB,QAA8B;AAC9D,MAAI,WAAW,OAAiD;AAC5D,kDAA8C;AAAA,EAClD;AACA,QAAM,EAAE,SAAS,IAAI,IAAI;AACzB,MAAI,WAAW,SAAS;AACpB,sCAAkC,OAAO;AAAA,EAC7C;AACA,MAAI;AACJ,MAAkB,0BAA0B,QAAQ;AAChD,uBAAmB,EAAE,YAAY,OAAO,qBAAqB;AAAA,EACjE;AACA,QAAM,gBAAgB,WAAW,iBAAiB,OAAO;AACzD,SAAO,eAAe,gBAA2B;AAAA,IAC7C;AAAA,IACA;AAAA,EACJ,GAAoD;AAChD,UAAM,OAAO,KAAK,UAAU,OAAO;AACnC,UAAM,cAAc;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,SAAS;AAAA,QACL,GAAG;AAAA;AAAA,QAEH,QAAQ;AAAA,QACR,kBAAkB,KAAK,OAAO,SAAS;AAAA,QACvC,gBAAgB;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,IACJ;AACA,UAAM,WAAW,MAAM,MAAM,KAAK,WAAW;AAC7C,QAAI,CAAC,SAAS,IAAI;AACd,YAAM,IAAIA,aAAY,yCAAyC;AAAA,QAC3D,SAAS,SAAS;AAAA,QAClB,YAAY,SAAS;AAAA,MACzB,CAAC;AAAA,IACL;AACA,WAAQ,MAAM,SAAS,KAAK;AAAA,EAChC;AACJ","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, SolanaError } from '@solana/errors';\nimport { RpcTransport } from '@solana/rpc-spec';\nimport type Dispatcher from 'undici/types/dispatcher';\n\nimport {\n    AllowedHttpRequestHeaders,\n    assertIsAllowedHttpRequestHeaders,\n    normalizeHeaders,\n} from './http-transport-headers';\n\ntype Config = Readonly<{\n    dispatcher_NODE_ONLY?: Dispatcher;\n    headers?: AllowedHttpRequestHeaders;\n    url: string;\n}>;\n\nlet didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;\nfunction warnDispatcherWasSuppliedInNonNodeEnvironment() {\n    if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {\n        return;\n    }\n    didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;\n    console.warn(\n        'You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored ' +\n            'because Undici dispatchers only work in Node environments. To eliminate this ' +\n            'warning, omit the `dispatcher_NODE_ONLY` property from your config when running in ' +\n            'a non-Node environment.',\n    );\n}\n\nexport function createHttpTransport(config: Config): RpcTransport {\n    if (__DEV__ && !__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        warnDispatcherWasSuppliedInNonNodeEnvironment();\n    }\n    const { headers, url } = config;\n    if (__DEV__ && headers) {\n        assertIsAllowedHttpRequestHeaders(headers);\n    }\n    let dispatcherConfig: { dispatcher: Dispatcher | undefined } | undefined;\n    if (__NODEJS__ && 'dispatcher_NODE_ONLY' in config) {\n        dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };\n    }\n    const customHeaders = headers && normalizeHeaders(headers);\n    return async function makeHttpRequest<TResponse>({\n        payload,\n        signal,\n    }: Parameters<RpcTransport>[0]): Promise<TResponse> {\n        const body = JSON.stringify(payload);\n        const requestInfo = {\n            ...dispatcherConfig,\n            body,\n            headers: {\n                ...customHeaders,\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                accept: 'application/json',\n                'content-length': body.length.toString(),\n                'content-type': 'application/json; charset=utf-8',\n            },\n            method: 'POST',\n            signal,\n        };\n        const response = await fetch(url, requestInfo);\n        if (!response.ok) {\n            throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {\n                message: response.statusText,\n                statusCode: response.status,\n            });\n        }\n        return (await response.json()) as TResponse;\n    };\n}\n","import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, SolanaError } from '@solana/errors';\n\nexport type AllowedHttpRequestHeaders = Readonly<\n    {\n        // Someone can still sneak a forbidden header past Typescript if they do something like\n        // fOo-BaR, but at that point they deserve the runtime failure.\n        [K in DisallowedHeaders | ForbiddenHeaders as\n            | Capitalize<Lowercase<K>> // `Foo-bar`\n            | K // `Foo-Bar`\n            | Lowercase<K> // `foo-bar`\n            | Uncapitalize<K> // `foo-Bar`\n            // `FOO-BAR`\n            | Uppercase<K>]?: never;\n    } & { [headerName: string]: string }\n>;\n// These are headers that we simply don't allow the developer to override because they're\n// fundamental to the operation of the JSON-RPC transport.\ntype DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';\ntype ForbiddenHeaders =\n    | 'Accept-Charset'\n    | 'Accept-Encoding'\n    | 'Access-Control-Request-Headers'\n    | 'Access-Control-Request-Method'\n    | 'Connection'\n    | 'Content-Length'\n    | 'Cookie'\n    | 'Date'\n    | 'DNT'\n    | 'Expect'\n    | 'Host'\n    | 'Keep-Alive'\n    | 'Origin'\n    | 'Permissions-Policy'\n    | 'Referer'\n    | 'TE'\n    | 'Trailer'\n    | 'Transfer-Encoding'\n    | 'Upgrade'\n    | 'Via'\n    | `Proxy-${string}`\n    | `Sec-${string}`;\n\n// These are headers which are fundamental to the JSON-RPC transport, and must not be modified.\nconst DISALLOWED_HEADERS: Record<string, boolean> = {\n    accept: true,\n    'content-length': true,\n    'content-type': true,\n};\n// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name\nconst FORBIDDEN_HEADERS: Record<string, boolean> = {\n    'accept-charset': true,\n    'accept-encoding': true,\n    'access-control-request-headers': true,\n    'access-control-request-method': true,\n    connection: true,\n    'content-length': true,\n    cookie: true,\n    date: true,\n    dnt: true,\n    expect: true,\n    host: true,\n    'keep-alive': true,\n    origin: true,\n    'permissions-policy': true,\n    // Prefix matching is implemented in code, below.\n    // 'proxy-': true,\n    // 'sec-': true,\n    referer: true,\n    te: true,\n    trailer: true,\n    'transfer-encoding': true,\n    upgrade: true,\n    via: true,\n};\n\nexport function assertIsAllowedHttpRequestHeaders(\n    headers: Record<string, string>,\n): asserts headers is AllowedHttpRequestHeaders {\n    const badHeaders = Object.keys(headers).filter(headerName => {\n        const lowercaseHeaderName = headerName.toLowerCase();\n        return (\n            DISALLOWED_HEADERS[headerName.toLowerCase()] === true ||\n            FORBIDDEN_HEADERS[headerName.toLowerCase()] === true ||\n            lowercaseHeaderName.startsWith('proxy-') ||\n            lowercaseHeaderName.startsWith('sec-')\n        );\n    });\n    if (badHeaders.length > 0) {\n        throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {\n            headers: badHeaders,\n        });\n    }\n}\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers, such as those defined\n * in the `DisallowedHeaders` type.\n */\nexport function normalizeHeaders<T extends Record<string, string>>(\n    headers: T,\n): { [K in string & keyof T as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in string & keyof T as Lowercase<K>]: T[K] };\n}\n"]}

package/dist/types/http-transport-headers.d.ts

@@ -0,0 +1,17 @@
+export type AllowedHttpRequestHeaders = Readonly<{
+    [K in DisallowedHeaders | ForbiddenHeaders as Capitalize<Lowercase<K>> | K | Lowercase<K> | Uncapitalize<K> | Uppercase<K>]?: never;
+} & {
+    [headerName: string]: string;
+}>;
+type DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';
+type ForbiddenHeaders = 'Accept-Charset' | 'Accept-Encoding' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Connection' | 'Content-Length' | 'Cookie' | 'Date' | 'DNT' | 'Expect' | 'Host' | 'Keep-Alive' | 'Origin' | 'Permissions-Policy' | 'Referer' | 'TE' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Via' | `Proxy-${string}` | `Sec-${string}`;
+export declare function assertIsAllowedHttpRequestHeaders(headers: Record<string, string>): asserts headers is AllowedHttpRequestHeaders;
+/**
+ * Lowercasing header names makes it easier to override user-supplied headers, such as those defined
+ * in the `DisallowedHeaders` type.
+ */
+export declare function normalizeHeaders<T extends Record<string, string>>(headers: T): {
+    [K in string & keyof T as Lowercase<K>]: T[K];
+};
+export {};
+//# sourceMappingURL=http-transport-headers.d.ts.map

package/dist/types/http-transport-headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-transport-headers.d.ts","sourceRoot":"","sources":["../../src/http-transport-headers.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAC5C;KAGK,CAAC,IAAI,iBAAiB,GAAG,gBAAgB,IACpC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACxB,CAAC,GACD,SAAS,CAAC,CAAC,CAAC,GACZ,YAAY,CAAC,CAAC,CAAC,GAEf,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK;CAC9B,GAAG;IAAE,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CACvC,CAAC;AAGF,KAAK,iBAAiB,GAAG,QAAQ,GAAG,gBAAgB,GAAG,cAAc,GAAG,eAAe,CAAC;AACxF,KAAK,gBAAgB,GACf,gBAAgB,GAChB,iBAAiB,GACjB,gCAAgC,GAChC,+BAA+B,GAC/B,YAAY,GACZ,gBAAgB,GAChB,QAAQ,GACR,MAAM,GACN,KAAK,GACL,QAAQ,GACR,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,oBAAoB,GACpB,SAAS,GACT,IAAI,GACJ,SAAS,GACT,mBAAmB,GACnB,SAAS,GACT,KAAK,GACL,SAAS,MAAM,EAAE,GACjB,OAAO,MAAM,EAAE,CAAC;AAmCtB,wBAAgB,iCAAiC,CAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,OAAO,CAAC,OAAO,IAAI,yBAAyB,CAe9C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7D,OAAO,EAAE,CAAC,GACX;KAAG,CAAC,IAAI,MAAM,GAAG,MAAM,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAMnD"}

package/dist/types/http-transport.d.ts

@@ -0,0 +1,11 @@
+import { RpcTransport } from '@solana/rpc-spec';
+import type Dispatcher from 'undici/types/dispatcher';
+import { AllowedHttpRequestHeaders } from './http-transport-headers.js';
+type Config = Readonly<{
+    dispatcher_NODE_ONLY?: Dispatcher;
+    headers?: AllowedHttpRequestHeaders;
+    url: string;
+}>;
+export declare function createHttpTransport(config: Config): RpcTransport;
+export {};
+//# sourceMappingURL=http-transport.d.ts.map

package/dist/types/http-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-transport.d.ts","sourceRoot":"","sources":["../../src/http-transport.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,UAAU,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EACH,yBAAyB,EAG5B,MAAM,0BAA0B,CAAC;AAElC,KAAK,MAAM,GAAG,QAAQ,CAAC;IACnB,oBAAoB,CAAC,EAAE,UAAU,CAAC;IAClC,OAAO,CAAC,EAAE,yBAAyB,CAAC;IACpC,GAAG,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAgBH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAwChE"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './http-transport.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@solana/rpc-transport-http",
+  "version": "2.0.0-experimental.00fa195",
+  "description": "An RPC transport that uses HTTP requests",
+  "exports": {
+    "browser": {
+      "import": "./dist/index.browser.js",
+      "require": "./dist/index.browser.cjs"
+    },
+    "node": {
+      "import": "./dist/index.node.js",
+      "require": "./dist/index.node.cjs"
+    },
+    "react-native": "./dist/index.native.js",
+    "types": "./dist/types/index.d.ts"
+  },
+  "browser": {
+    "./dist/index.node.cjs": "./dist/index.browser.cjs",
+    "./dist/index.node.js": "./dist/index.browser.js"
+  },
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.js",
+  "react-native": "./dist/index.native.js",
+  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "files": [
+    "./dist/"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "blockchain",
+    "solana",
+    "web3"
+  ],
+  "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solana-labs/solana-web3.js"
+  },
+  "bugs": {
+    "url": "http://github.com/solana-labs/solana-web3.js/issues"
+  },
+  "browserslist": [
+    "supports bigint and not dead",
+    "maintained node versions"
+  ],
+  "dependencies": {
+    "undici": "^6.6.2",
+    "@solana/errors": "2.0.0-experimental.00fa195",
+    "@solana/rpc-spec": "2.0.0-experimental.00fa195"
+  },
+  "bundlewatch": {
+    "defaultCompression": "gzip",
+    "files": [
+      {
+        "path": "./dist/index*.js"
+      }
+    ]
+  },
+  "scripts": {
+    "benchmark": "./src/__benchmarks__/run.ts",
+    "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node ../../node_modules/@solana/build-scripts/add-js-extension-to-types.mjs",
+    "dev": "jest -c ../../node_modules/@solana/test-config/jest-dev.config.ts --rootDir . --watch",
+    "publish-impl": "npm view $npm_package_name@$npm_package_version > /dev/null 2>&1 || pnpm publish --tag experimental --access public --no-git-checks",
+    "publish-packages": "pnpm prepublishOnly && pnpm publish-impl",
+    "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/* package.json",
+    "test:lint": "jest -c ../../node_modules/@solana/test-config/jest-lint.config.ts --rootDir . --silent",
+    "test:prettier": "jest -c ../../node_modules/@solana/test-config/jest-prettier.config.ts --rootDir . --silent",
+    "test:treeshakability:browser": "agadoo dist/index.browser.js",
+    "test:treeshakability:native": "agadoo dist/index.native.js",
+    "test:treeshakability:node": "agadoo dist/index.node.js",
+    "test:typecheck": "tsc --noEmit",
+    "test:unit:browser": "jest -c ../../node_modules/@solana/test-config/jest-unit.config.browser.ts --rootDir . --silent",
+    "test:unit:node": "jest -c ../../node_modules/@solana/test-config/jest-unit.config.node.ts --rootDir . --silent"
+  }
+}