@solana/rpc-transport - npm Package Compare versions

Comparing version 2.0.0-experimental.66685ba to 2.0.0-experimental.6725a9f

dist/index.browser.js

@@ -1,41 +0,61 @@
-import 'node-fetch';
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
 
-// src/http-request-errors.ts
-var SolanaHttpError = class extends Error {
-  constructor(details) {
-    super(`HTTP error (${details.statusCode}): ${details.message}`);
-    Error.captureStackTrace(this, this.constructor);
-    this.statusCode = details.statusCode;
-  }
-  get name() {
-    return "SolanaHttpError";
-  }
-};
+// src/apis/methods/methods-api.ts
+function createJsonRpcApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const methodName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, methodName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        return {
+          methodName,
+          params,
+          responseTransformer
+        };
+      };
+    }
+  });
+}
 
-// ../fetch-impl-browser/dist/index.browser.js
-var { fetch } = globalThis;
-var src_default = fetch;
-async function makeHttpRequest({ payload, url }) {
-  const requestInfo = {
-    body: JSON.stringify(payload),
-    headers: {
-      "Content-type": "application/json"
+// src/apis/subscriptions/subscriptions-api.ts
+function createJsonRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
     },
-    method: "POST"
-  };
-  let response;
-  {
-    response = await src_default(url, requestInfo);
-  }
-  if (!response.ok) {
-    throw new SolanaHttpError({
-      message: response.statusText,
-      statusCode: response.status
-    });
-  }
-  return await response.json();
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const notificationName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, notificationName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        const subscribeMethodName = config?.subscribeNotificationNameTransformer ? config?.subscribeNotificationNameTransformer(notificationName) : notificationName;
+        const unsubscribeMethodName = config?.unsubscribeNotificationNameTransformer ? config?.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        return {
+          params,
+          responseTransformer,
+          subscribeMethodName,
+          unsubscribeMethodName
+        };
+      };
+    }
+  });
 }
 
-// src/json-rpc-transport/json-rpc-errors.ts
+// src/json-rpc-errors.ts
 var SolanaJsonRpcError = class extends Error {
+  code;
+  data;
   constructor(details) {
@@ -52,3 +72,3 @@ super(`JSON-RPC 2.0 error (${details.code}): ${details.message}`);
 
-// src/json-rpc-transport/json-rpc-message-id.ts
+// src/json-rpc-message-id.ts
 var _nextMessageId = 0;
@@ -61,3 +81,3 @@ function getNextMessageId() {
 
-// src/json-rpc-transport/json-rpc-message.ts
+// src/json-rpc-message.ts
 function createJsonRpcMessage(method, params) {
@@ -72,11 +92,11 @@ return {
 
-// src/json-rpc-transport/index.ts
-function createArmedJsonRpcTransport(transportConfig, pendingRequest) {
-  const overrides = {
-    async send() {
-      const { methodName, params, responseProcessor } = pendingRequest;
+// src/json-rpc.ts
+function createPendingRpcRequest(rpcConfig, pendingRequest) {
+  return {
+    async send(options) {
+      const { methodName, params, responseTransformer } = pendingRequest;
       const payload = createJsonRpcMessage(methodName, params);
-      const response = await makeHttpRequest({
+      const response = await rpcConfig.transport({
         payload,
-        url: transportConfig.url
+        signal: options?.abortSignal
       });
@@ -86,31 +106,96 @@ if ("error" in response) {
       } else {
-        return responseProcessor ? responseProcessor(response.result) : response.result;
+        return responseTransformer ? responseTransformer(response.result, methodName) : response.result;
       }
     }
   };
-  return makeProxy(transportConfig, overrides, pendingRequest);
 }
-function createArmedBatchJsonRpcTransport(transportConfig, pendingRequests) {
-  const overrides = {
-    async sendBatch() {
-      const payload = pendingRequests.map(({ methodName, params }) => createJsonRpcMessage(methodName, params));
-      const responses = await makeHttpRequest({
-        payload,
-        url: transportConfig.url
-      });
-      const requestOrder = payload.map((p) => p.id);
-      return responses.sort((a, b) => requestOrder.indexOf(a.id) - requestOrder.indexOf(b.id)).map((response, ii) => {
-        if ("error" in response) {
-          throw new SolanaJsonRpcError(response.error);
+function makeProxy(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(target, p, receiver) {
+      return function(...rawParams) {
+        const methodName = p.toString();
+        const createRpcRequest = Reflect.get(target, methodName, receiver);
+        const newRequest = createRpcRequest ? createRpcRequest(...rawParams) : { methodName, params: rawParams };
+        return createPendingRpcRequest(rpcConfig, newRequest);
+      };
+    }
+  });
+}
+function createJsonRpc(rpcConfig) {
+  return makeProxy(rpcConfig);
+}
+
+// src/json-rpc-subscription.ts
+function registerIterableCleanup(iterable, cleanupFn) {
+  (async () => {
+    try {
+      for await (const _ of iterable)
+        ;
+    } catch {
+    } finally {
+      cleanupFn();
+    }
+  })();
+}
+function createPendingRpcSubscription(rpcConfig, { params, subscribeMethodName, unsubscribeMethodName, responseTransformer }) {
+  return {
+    async subscribe({ abortSignal }) {
+      abortSignal.throwIfAborted();
+      let subscriptionId;
+      function handleCleanup() {
+        if (subscriptionId !== void 0) {
+          const payload = createJsonRpcMessage(unsubscribeMethodName, [subscriptionId]);
+          connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload).finally(() => {
+            connectionAbortController.abort();
+          });
         } else {
-          const { responseProcessor } = pendingRequests[ii];
-          return responseProcessor ? responseProcessor(response.result) : response.result;
+          connectionAbortController.abort();
         }
+      }
+      abortSignal.addEventListener("abort", handleCleanup);
+      const connectionAbortController = new AbortController();
+      const subscribeMessage = createJsonRpcMessage(subscribeMethodName, params);
+      const connection = await rpcConfig.transport({
+        payload: subscribeMessage,
+        signal: connectionAbortController.signal
       });
+      function handleConnectionCleanup() {
+        abortSignal.removeEventListener("abort", handleCleanup);
+      }
+      registerIterableCleanup(connection, handleConnectionCleanup);
+      for await (const message of connection) {
+        if ("id" in message && message.id === subscribeMessage.id) {
+          if ("error" in message) {
+            throw new SolanaJsonRpcError(message.error);
+          } else {
+            subscriptionId = message.result;
+            break;
+          }
+        }
+      }
+      if (subscriptionId == null) {
+        throw new Error("Failed to obtain a subscription id from the server");
+      }
+      return {
+        async *[Symbol.asyncIterator]() {
+          for await (const message of connection) {
+            if (!("params" in message) || message.params.subscription !== subscriptionId) {
+              continue;
+            }
+            const notification = message.params.result;
+            yield responseTransformer ? responseTransformer(notification, subscribeMethodName) : notification;
+          }
+        }
+      };
     }
   };
-  return makeProxy(transportConfig, overrides, pendingRequests);
 }
-function makeProxy(transportConfig, overrides, pendingRequestOrRequests) {
-  return new Proxy(transportConfig.api, {
+function makeProxy2(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
     defineProperty() {
@@ -123,15 +208,16 @@ return false;
     get(target, p, receiver) {
-      if (overrides && Reflect.has(overrides, p)) {
-        return Reflect.get(overrides, p, receiver);
-      }
       return function(...rawParams) {
         const methodName = p.toString();
-        const createTransportRequest = Reflect.get(target, methodName, receiver);
-        const newRequest = createTransportRequest ? createTransportRequest(...rawParams) : { methodName, params: rawParams };
-        if (pendingRequestOrRequests == null) {
-          return createArmedJsonRpcTransport(transportConfig, newRequest);
-        } else {
-          const nextPendingRequests = Array.isArray(pendingRequestOrRequests) ? [...pendingRequestOrRequests, newRequest] : [pendingRequestOrRequests, newRequest];
-          return createArmedBatchJsonRpcTransport(transportConfig, nextPendingRequests);
+        const createRpcSubscription = Reflect.get(target, methodName, receiver);
+        if (p.toString().endsWith("Notifications") === false && !createRpcSubscription) {
+          throw new Error(
+            "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function to map between the notification name and the subscribe/unsubscribe method names."
+          );
         }
+        const newRequest = createRpcSubscription ? createRpcSubscription(...rawParams) : {
+          params: rawParams,
+          subscribeMethodName: methodName.replace(/Notifications$/, "Subscribe"),
+          unsubscribeMethodName: methodName.replace(/Notifications$/, "Unsubscribe")
+        };
+        return createPendingRpcSubscription(rpcConfig, newRequest);
       };
@@ -141,8 +227,280 @@ }
 }
-function createJsonRpcTransport(transportConfig) {
-  return makeProxy(transportConfig);
+function createJsonSubscriptionRpc(rpcConfig) {
+  return makeProxy2(rpcConfig);
 }
 
-export { createJsonRpcTransport };
+// ../fetch-impl/dist/index.browser.js
+var e = globalThis.fetch;
+
+// src/transports/http/http-transport-errors.ts
+var SolanaHttpError = class extends Error {
+  statusCode;
+  constructor(details) {
+    super(`HTTP error (${details.statusCode}): ${details.message}`);
+    Error.captureStackTrace(this, this.constructor);
+    this.statusCode = details.statusCode;
+  }
+  get name() {
+    return "SolanaHttpError";
+  }
+};
+
+// src/transports/http/http-transport-headers.ts
+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,
+  // No currently available Typescript technique allows you to match on a prefix.
+  // '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 Error(
+      `${badHeaders.length > 1 ? "These headers are" : "This header is"} forbidden: \`${badHeaders.join("`, `")}\`. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.`
+    );
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/transports/http/http-transport.ts
+function createHttpTransport({ headers, url }) {
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      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 e(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaHttpError({
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+// ../ws-impl/dist/index.browser.js
+var e2 = globalThis.WebSocket;
+
+// src/transports/websocket/websocket-connection.ts
+var EXPLICIT_ABORT_TOKEN = Symbol(
+  __DEV__ ? "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" : void 0
+);
+async function createWebSocketConnection({
+  sendBufferHighWatermark,
+  signal,
+  url
+}) {
+  return new Promise((resolve, reject) => {
+    signal.addEventListener("abort", handleAbort, { once: true });
+    const iteratorState = /* @__PURE__ */ new Map();
+    function errorAndClearAllIteratorStates(reason) {
+      const errorCallbacks = [...iteratorState.values()].filter((state) => state.__hasPolled).map(({ onError }) => onError);
+      iteratorState.clear();
+      errorCallbacks.forEach((cb) => {
+        try {
+          cb(reason);
+        } catch {
+        }
+      });
+    }
+    function handleAbort() {
+      errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN);
+      if (webSocket.readyState !== e2.CLOSED && webSocket.readyState !== e2.CLOSING) {
+        webSocket.close(1e3);
+      }
+    }
+    function handleClose(ev) {
+      bufferDrainWatcher?.onCancel();
+      signal.removeEventListener("abort", handleAbort);
+      webSocket.removeEventListener("close", handleClose);
+      webSocket.removeEventListener("error", handleError);
+      webSocket.removeEventListener("open", handleOpen);
+      webSocket.removeEventListener("message", handleMessage);
+      errorAndClearAllIteratorStates(ev);
+    }
+    function handleError(ev) {
+      if (!hasConnected) {
+        reject(
+          // TODO: Coded error
+          new Error("WebSocket failed to connect", { cause: ev })
+        );
+      }
+    }
+    let hasConnected = false;
+    let bufferDrainWatcher;
+    function handleOpen() {
+      hasConnected = true;
+      resolve({
+        async send(payload) {
+          const message = JSON.stringify(payload);
+          if (!bufferDrainWatcher && webSocket.readyState === e2.OPEN && webSocket.bufferedAmount > sendBufferHighWatermark) {
+            let onCancel;
+            const promise = new Promise((resolve2, reject2) => {
+              const intervalId = setInterval(() => {
+                if (webSocket.readyState !== e2.OPEN || !(webSocket.bufferedAmount > sendBufferHighWatermark)) {
+                  clearInterval(intervalId);
+                  bufferDrainWatcher = void 0;
+                  resolve2();
+                }
+              }, 16);
+              onCancel = () => {
+                bufferDrainWatcher = void 0;
+                clearInterval(intervalId);
+                reject2(
+                  // TODO: Coded error
+                  new Error("WebSocket was closed before payload could be sent")
+                );
+              };
+            });
+            bufferDrainWatcher = {
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              onCancel,
+              promise
+            };
+          }
+          if (bufferDrainWatcher) {
+            await bufferDrainWatcher.promise;
+          }
+          webSocket.send(message);
+        },
+        async *[Symbol.asyncIterator]() {
+          const iteratorKey = Symbol();
+          iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
+          try {
+            while (true) {
+              const state = iteratorState.get(iteratorKey);
+              if (!state) {
+                throw new Error("Invariant: WebSocket message iterator is missing state storage");
+              }
+              if (state.__hasPolled) {
+                throw new Error(
+                  "Invariant: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise"
+                );
+              }
+              const queuedMessages = state.queuedMessages;
+              if (queuedMessages.length) {
+                state.queuedMessages = [];
+                yield* queuedMessages;
+              } else {
+                try {
+                  yield await new Promise((resolve2, reject2) => {
+                    iteratorState.set(iteratorKey, {
+                      __hasPolled: true,
+                      onError: reject2,
+                      onMessage: resolve2
+                    });
+                  });
+                } catch (e3) {
+                  if (e3 === EXPLICIT_ABORT_TOKEN) {
+                    return;
+                  } else {
+                    throw new Error("WebSocket connection closed", { cause: e3 });
+                  }
+                }
+              }
+            }
+          } finally {
+            iteratorState.delete(iteratorKey);
+          }
+        }
+      });
+    }
+    function handleMessage({ data }) {
+      const message = JSON.parse(data);
+      iteratorState.forEach((state, iteratorKey) => {
+        if (state.__hasPolled) {
+          const { onMessage } = state;
+          iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
+          onMessage(message);
+        } else {
+          state.queuedMessages.push(message);
+        }
+      });
+    }
+    const webSocket = new e2(url);
+    webSocket.addEventListener("close", handleClose);
+    webSocket.addEventListener("error", handleError);
+    webSocket.addEventListener("open", handleOpen);
+    webSocket.addEventListener("message", handleMessage);
+  });
+}
+
+// src/transports/websocket/websocket-transport.ts
+function createWebSocketTransport({ sendBufferHighWatermark, url }) {
+  if (/^wss?:/i.test(url) === false) {
+    const protocolMatch = url.match(/^([^:]+):/);
+    throw new DOMException(
+      protocolMatch ? `Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'. '${protocolMatch[1]}:' is not allowed.` : `Failed to construct 'WebSocket': The URL '${url}' is invalid.`
+    );
+  }
+  return async function sendWebSocketMessage({ payload, signal }) {
+    signal?.throwIfAborted();
+    const connection = await createWebSocketConnection({
+      sendBufferHighWatermark,
+      signal,
+      url
+    });
+    signal?.throwIfAborted();
+    await connection.send(payload);
+    return {
+      [Symbol.asyncIterator]: connection[Symbol.asyncIterator].bind(connection),
+      send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: connection.send.bind(connection)
+    };
+  };
+}
+
+export { createHttpTransport, createJsonRpc, createJsonRpcApi, createJsonRpcSubscriptionsApi, createJsonSubscriptionRpc, createWebSocketTransport };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map

dist/index.native.js

@@ -1,41 +0,61 @@
-import 'node-fetch';
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
 
-// src/http-request-errors.ts
-var SolanaHttpError = class extends Error {
-  constructor(details) {
-    super(`HTTP error (${details.statusCode}): ${details.message}`);
-    Error.captureStackTrace(this, this.constructor);
-    this.statusCode = details.statusCode;
-  }
-  get name() {
-    return "SolanaHttpError";
-  }
-};
+// src/apis/methods/methods-api.ts
+function createJsonRpcApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const methodName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, methodName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        return {
+          methodName,
+          params,
+          responseTransformer
+        };
+      };
+    }
+  });
+}
 
-// ../fetch-impl-browser/dist/index.browser.js
-var { fetch } = globalThis;
-var src_default = fetch;
-async function makeHttpRequest({ payload, url }) {
-  const requestInfo = {
-    body: JSON.stringify(payload),
-    headers: {
-      "Content-type": "application/json"
+// src/apis/subscriptions/subscriptions-api.ts
+function createJsonRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
     },
-    method: "POST"
-  };
-  let response;
-  {
-    response = await src_default(url, requestInfo);
-  }
-  if (!response.ok) {
-    throw new SolanaHttpError({
-      message: response.statusText,
-      statusCode: response.status
-    });
-  }
-  return await response.json();
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const notificationName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, notificationName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        const subscribeMethodName = config?.subscribeNotificationNameTransformer ? config?.subscribeNotificationNameTransformer(notificationName) : notificationName;
+        const unsubscribeMethodName = config?.unsubscribeNotificationNameTransformer ? config?.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        return {
+          params,
+          responseTransformer,
+          subscribeMethodName,
+          unsubscribeMethodName
+        };
+      };
+    }
+  });
 }
 
-// src/json-rpc-transport/json-rpc-errors.ts
+// src/json-rpc-errors.ts
 var SolanaJsonRpcError = class extends Error {
+  code;
+  data;
   constructor(details) {
@@ -52,3 +72,3 @@ super(`JSON-RPC 2.0 error (${details.code}): ${details.message}`);
 
-// src/json-rpc-transport/json-rpc-message-id.ts
+// src/json-rpc-message-id.ts
 var _nextMessageId = 0;
@@ -61,3 +81,3 @@ function getNextMessageId() {
 
-// src/json-rpc-transport/json-rpc-message.ts
+// src/json-rpc-message.ts
 function createJsonRpcMessage(method, params) {
@@ -72,11 +92,11 @@ return {
 
-// src/json-rpc-transport/index.ts
-function createArmedJsonRpcTransport(transportConfig, pendingRequest) {
-  const overrides = {
-    async send() {
-      const { methodName, params, responseProcessor } = pendingRequest;
+// src/json-rpc.ts
+function createPendingRpcRequest(rpcConfig, pendingRequest) {
+  return {
+    async send(options) {
+      const { methodName, params, responseTransformer } = pendingRequest;
       const payload = createJsonRpcMessage(methodName, params);
-      const response = await makeHttpRequest({
+      const response = await rpcConfig.transport({
         payload,
-        url: transportConfig.url
+        signal: options?.abortSignal
       });
@@ -86,31 +106,96 @@ if ("error" in response) {
       } else {
-        return responseProcessor ? responseProcessor(response.result) : response.result;
+        return responseTransformer ? responseTransformer(response.result, methodName) : response.result;
       }
     }
   };
-  return makeProxy(transportConfig, overrides, pendingRequest);
 }
-function createArmedBatchJsonRpcTransport(transportConfig, pendingRequests) {
-  const overrides = {
-    async sendBatch() {
-      const payload = pendingRequests.map(({ methodName, params }) => createJsonRpcMessage(methodName, params));
-      const responses = await makeHttpRequest({
-        payload,
-        url: transportConfig.url
-      });
-      const requestOrder = payload.map((p) => p.id);
-      return responses.sort((a, b) => requestOrder.indexOf(a.id) - requestOrder.indexOf(b.id)).map((response, ii) => {
-        if ("error" in response) {
-          throw new SolanaJsonRpcError(response.error);
+function makeProxy(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(target, p, receiver) {
+      return function(...rawParams) {
+        const methodName = p.toString();
+        const createRpcRequest = Reflect.get(target, methodName, receiver);
+        const newRequest = createRpcRequest ? createRpcRequest(...rawParams) : { methodName, params: rawParams };
+        return createPendingRpcRequest(rpcConfig, newRequest);
+      };
+    }
+  });
+}
+function createJsonRpc(rpcConfig) {
+  return makeProxy(rpcConfig);
+}
+
+// src/json-rpc-subscription.ts
+function registerIterableCleanup(iterable, cleanupFn) {
+  (async () => {
+    try {
+      for await (const _ of iterable)
+        ;
+    } catch {
+    } finally {
+      cleanupFn();
+    }
+  })();
+}
+function createPendingRpcSubscription(rpcConfig, { params, subscribeMethodName, unsubscribeMethodName, responseTransformer }) {
+  return {
+    async subscribe({ abortSignal }) {
+      abortSignal.throwIfAborted();
+      let subscriptionId;
+      function handleCleanup() {
+        if (subscriptionId !== void 0) {
+          const payload = createJsonRpcMessage(unsubscribeMethodName, [subscriptionId]);
+          connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload).finally(() => {
+            connectionAbortController.abort();
+          });
         } else {
-          const { responseProcessor } = pendingRequests[ii];
-          return responseProcessor ? responseProcessor(response.result) : response.result;
+          connectionAbortController.abort();
         }
+      }
+      abortSignal.addEventListener("abort", handleCleanup);
+      const connectionAbortController = new AbortController();
+      const subscribeMessage = createJsonRpcMessage(subscribeMethodName, params);
+      const connection = await rpcConfig.transport({
+        payload: subscribeMessage,
+        signal: connectionAbortController.signal
       });
+      function handleConnectionCleanup() {
+        abortSignal.removeEventListener("abort", handleCleanup);
+      }
+      registerIterableCleanup(connection, handleConnectionCleanup);
+      for await (const message of connection) {
+        if ("id" in message && message.id === subscribeMessage.id) {
+          if ("error" in message) {
+            throw new SolanaJsonRpcError(message.error);
+          } else {
+            subscriptionId = message.result;
+            break;
+          }
+        }
+      }
+      if (subscriptionId == null) {
+        throw new Error("Failed to obtain a subscription id from the server");
+      }
+      return {
+        async *[Symbol.asyncIterator]() {
+          for await (const message of connection) {
+            if (!("params" in message) || message.params.subscription !== subscriptionId) {
+              continue;
+            }
+            const notification = message.params.result;
+            yield responseTransformer ? responseTransformer(notification, subscribeMethodName) : notification;
+          }
+        }
+      };
     }
   };
-  return makeProxy(transportConfig, overrides, pendingRequests);
 }
-function makeProxy(transportConfig, overrides, pendingRequestOrRequests) {
-  return new Proxy(transportConfig.api, {
+function makeProxy2(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
     defineProperty() {
@@ -123,15 +208,16 @@ return false;
     get(target, p, receiver) {
-      if (overrides && Reflect.has(overrides, p)) {
-        return Reflect.get(overrides, p, receiver);
-      }
       return function(...rawParams) {
         const methodName = p.toString();
-        const createTransportRequest = Reflect.get(target, methodName, receiver);
-        const newRequest = createTransportRequest ? createTransportRequest(...rawParams) : { methodName, params: rawParams };
-        if (pendingRequestOrRequests == null) {
-          return createArmedJsonRpcTransport(transportConfig, newRequest);
-        } else {
-          const nextPendingRequests = Array.isArray(pendingRequestOrRequests) ? [...pendingRequestOrRequests, newRequest] : [pendingRequestOrRequests, newRequest];
-          return createArmedBatchJsonRpcTransport(transportConfig, nextPendingRequests);
+        const createRpcSubscription = Reflect.get(target, methodName, receiver);
+        if (p.toString().endsWith("Notifications") === false && !createRpcSubscription) {
+          throw new Error(
+            "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function to map between the notification name and the subscribe/unsubscribe method names."
+          );
         }
+        const newRequest = createRpcSubscription ? createRpcSubscription(...rawParams) : {
+          params: rawParams,
+          subscribeMethodName: methodName.replace(/Notifications$/, "Subscribe"),
+          unsubscribeMethodName: methodName.replace(/Notifications$/, "Unsubscribe")
+        };
+        return createPendingRpcSubscription(rpcConfig, newRequest);
       };
@@ -141,8 +227,280 @@ }
 }
-function createJsonRpcTransport(transportConfig) {
-  return makeProxy(transportConfig);
+function createJsonSubscriptionRpc(rpcConfig) {
+  return makeProxy2(rpcConfig);
 }
 
-export { createJsonRpcTransport };
+// ../fetch-impl/dist/index.browser.js
+var e = globalThis.fetch;
+
+// src/transports/http/http-transport-errors.ts
+var SolanaHttpError = class extends Error {
+  statusCode;
+  constructor(details) {
+    super(`HTTP error (${details.statusCode}): ${details.message}`);
+    Error.captureStackTrace(this, this.constructor);
+    this.statusCode = details.statusCode;
+  }
+  get name() {
+    return "SolanaHttpError";
+  }
+};
+
+// src/transports/http/http-transport-headers.ts
+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,
+  // No currently available Typescript technique allows you to match on a prefix.
+  // '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 Error(
+      `${badHeaders.length > 1 ? "These headers are" : "This header is"} forbidden: \`${badHeaders.join("`, `")}\`. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.`
+    );
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/transports/http/http-transport.ts
+function createHttpTransport({ headers, url }) {
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      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 e(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaHttpError({
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+
+// ../ws-impl/dist/index.browser.js
+var e2 = globalThis.WebSocket;
+
+// src/transports/websocket/websocket-connection.ts
+var EXPLICIT_ABORT_TOKEN = Symbol(
+  __DEV__ ? "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" : void 0
+);
+async function createWebSocketConnection({
+  sendBufferHighWatermark,
+  signal,
+  url
+}) {
+  return new Promise((resolve, reject) => {
+    signal.addEventListener("abort", handleAbort, { once: true });
+    const iteratorState = /* @__PURE__ */ new Map();
+    function errorAndClearAllIteratorStates(reason) {
+      const errorCallbacks = [...iteratorState.values()].filter((state) => state.__hasPolled).map(({ onError }) => onError);
+      iteratorState.clear();
+      errorCallbacks.forEach((cb) => {
+        try {
+          cb(reason);
+        } catch {
+        }
+      });
+    }
+    function handleAbort() {
+      errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN);
+      if (webSocket.readyState !== e2.CLOSED && webSocket.readyState !== e2.CLOSING) {
+        webSocket.close(1e3);
+      }
+    }
+    function handleClose(ev) {
+      bufferDrainWatcher?.onCancel();
+      signal.removeEventListener("abort", handleAbort);
+      webSocket.removeEventListener("close", handleClose);
+      webSocket.removeEventListener("error", handleError);
+      webSocket.removeEventListener("open", handleOpen);
+      webSocket.removeEventListener("message", handleMessage);
+      errorAndClearAllIteratorStates(ev);
+    }
+    function handleError(ev) {
+      if (!hasConnected) {
+        reject(
+          // TODO: Coded error
+          new Error("WebSocket failed to connect", { cause: ev })
+        );
+      }
+    }
+    let hasConnected = false;
+    let bufferDrainWatcher;
+    function handleOpen() {
+      hasConnected = true;
+      resolve({
+        async send(payload) {
+          const message = JSON.stringify(payload);
+          if (!bufferDrainWatcher && webSocket.readyState === e2.OPEN && webSocket.bufferedAmount > sendBufferHighWatermark) {
+            let onCancel;
+            const promise = new Promise((resolve2, reject2) => {
+              const intervalId = setInterval(() => {
+                if (webSocket.readyState !== e2.OPEN || !(webSocket.bufferedAmount > sendBufferHighWatermark)) {
+                  clearInterval(intervalId);
+                  bufferDrainWatcher = void 0;
+                  resolve2();
+                }
+              }, 16);
+              onCancel = () => {
+                bufferDrainWatcher = void 0;
+                clearInterval(intervalId);
+                reject2(
+                  // TODO: Coded error
+                  new Error("WebSocket was closed before payload could be sent")
+                );
+              };
+            });
+            bufferDrainWatcher = {
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              onCancel,
+              promise
+            };
+          }
+          if (bufferDrainWatcher) {
+            await bufferDrainWatcher.promise;
+          }
+          webSocket.send(message);
+        },
+        async *[Symbol.asyncIterator]() {
+          const iteratorKey = Symbol();
+          iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
+          try {
+            while (true) {
+              const state = iteratorState.get(iteratorKey);
+              if (!state) {
+                throw new Error("Invariant: WebSocket message iterator is missing state storage");
+              }
+              if (state.__hasPolled) {
+                throw new Error(
+                  "Invariant: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise"
+                );
+              }
+              const queuedMessages = state.queuedMessages;
+              if (queuedMessages.length) {
+                state.queuedMessages = [];
+                yield* queuedMessages;
+              } else {
+                try {
+                  yield await new Promise((resolve2, reject2) => {
+                    iteratorState.set(iteratorKey, {
+                      __hasPolled: true,
+                      onError: reject2,
+                      onMessage: resolve2
+                    });
+                  });
+                } catch (e3) {
+                  if (e3 === EXPLICIT_ABORT_TOKEN) {
+                    return;
+                  } else {
+                    throw new Error("WebSocket connection closed", { cause: e3 });
+                  }
+                }
+              }
+            }
+          } finally {
+            iteratorState.delete(iteratorKey);
+          }
+        }
+      });
+    }
+    function handleMessage({ data }) {
+      const message = JSON.parse(data);
+      iteratorState.forEach((state, iteratorKey) => {
+        if (state.__hasPolled) {
+          const { onMessage } = state;
+          iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
+          onMessage(message);
+        } else {
+          state.queuedMessages.push(message);
+        }
+      });
+    }
+    const webSocket = new e2(url);
+    webSocket.addEventListener("close", handleClose);
+    webSocket.addEventListener("error", handleError);
+    webSocket.addEventListener("open", handleOpen);
+    webSocket.addEventListener("message", handleMessage);
+  });
+}
+
+// src/transports/websocket/websocket-transport.ts
+function createWebSocketTransport({ sendBufferHighWatermark, url }) {
+  if (/^wss?:/i.test(url) === false) {
+    const protocolMatch = url.match(/^([^:]+):/);
+    throw new DOMException(
+      protocolMatch ? `Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'. '${protocolMatch[1]}:' is not allowed.` : `Failed to construct 'WebSocket': The URL '${url}' is invalid.`
+    );
+  }
+  return async function sendWebSocketMessage({ payload, signal }) {
+    signal?.throwIfAborted();
+    const connection = await createWebSocketConnection({
+      sendBufferHighWatermark,
+      signal,
+      url
+    });
+    signal?.throwIfAborted();
+    await connection.send(payload);
+    return {
+      [Symbol.asyncIterator]: connection[Symbol.asyncIterator].bind(connection),
+      send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: connection.send.bind(connection)
+    };
+  };
+}
+
+export { createHttpTransport, createJsonRpc, createJsonRpcApi, createJsonRpcSubscriptionsApi, createJsonSubscriptionRpc, createWebSocketTransport };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map

dist/index.node.js

@@ -1,37 +0,63 @@
-import fetchImplNode from 'node-fetch';
+import e2 from 'ws';
 
-// src/http-request-errors.ts
-var SolanaHttpError = class extends Error {
-  constructor(details) {
-    super(`HTTP error (${details.statusCode}): ${details.message}`);
-    Error.captureStackTrace(this, this.constructor);
-    this.statusCode = details.statusCode;
-  }
-  get name() {
-    return "SolanaHttpError";
-  }
-};
-async function makeHttpRequest({ payload, url }) {
-  const requestInfo = {
-    body: JSON.stringify(payload),
-    headers: {
-      "Content-type": "application/json"
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+
+// src/apis/methods/methods-api.ts
+function createJsonRpcApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
     },
-    method: "POST"
-  };
-  let response;
-  {
-    response = await fetchImplNode(url, requestInfo);
-  }
-  if (!response.ok) {
-    throw new SolanaHttpError({
-      message: response.statusText,
-      statusCode: response.status
-    });
-  }
-  return await response.json();
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const methodName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, methodName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        return {
+          methodName,
+          params,
+          responseTransformer
+        };
+      };
+    }
+  });
 }
 
-// src/json-rpc-transport/json-rpc-errors.ts
+// src/apis/subscriptions/subscriptions-api.ts
+function createJsonRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const notificationName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, notificationName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        const subscribeMethodName = config?.subscribeNotificationNameTransformer ? config?.subscribeNotificationNameTransformer(notificationName) : notificationName;
+        const unsubscribeMethodName = config?.unsubscribeNotificationNameTransformer ? config?.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        return {
+          params,
+          responseTransformer,
+          subscribeMethodName,
+          unsubscribeMethodName
+        };
+      };
+    }
+  });
+}
+
+// src/json-rpc-errors.ts
 var SolanaJsonRpcError = class extends Error {
+  code;
+  data;
   constructor(details) {
@@ -48,3 +74,3 @@ super(`JSON-RPC 2.0 error (${details.code}): ${details.message}`);
 
-// src/json-rpc-transport/json-rpc-message-id.ts
+// src/json-rpc-message-id.ts
 var _nextMessageId = 0;
@@ -57,3 +83,3 @@ function getNextMessageId() {
 
-// src/json-rpc-transport/json-rpc-message.ts
+// src/json-rpc-message.ts
 function createJsonRpcMessage(method, params) {
@@ -68,11 +94,11 @@ return {
 
-// src/json-rpc-transport/index.ts
-function createArmedJsonRpcTransport(transportConfig, pendingRequest) {
-  const overrides = {
-    async send() {
-      const { methodName, params, responseProcessor } = pendingRequest;
+// src/json-rpc.ts
+function createPendingRpcRequest(rpcConfig, pendingRequest) {
+  return {
+    async send(options) {
+      const { methodName, params, responseTransformer } = pendingRequest;
       const payload = createJsonRpcMessage(methodName, params);
-      const response = await makeHttpRequest({
+      const response = await rpcConfig.transport({
         payload,
-        url: transportConfig.url
+        signal: options?.abortSignal
       });
@@ -82,31 +108,96 @@ if ("error" in response) {
       } else {
-        return responseProcessor ? responseProcessor(response.result) : response.result;
+        return responseTransformer ? responseTransformer(response.result, methodName) : response.result;
       }
     }
   };
-  return makeProxy(transportConfig, overrides, pendingRequest);
 }
-function createArmedBatchJsonRpcTransport(transportConfig, pendingRequests) {
-  const overrides = {
-    async sendBatch() {
-      const payload = pendingRequests.map(({ methodName, params }) => createJsonRpcMessage(methodName, params));
-      const responses = await makeHttpRequest({
-        payload,
-        url: transportConfig.url
-      });
-      const requestOrder = payload.map((p) => p.id);
-      return responses.sort((a, b) => requestOrder.indexOf(a.id) - requestOrder.indexOf(b.id)).map((response, ii) => {
-        if ("error" in response) {
-          throw new SolanaJsonRpcError(response.error);
+function makeProxy(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(target, p, receiver) {
+      return function(...rawParams) {
+        const methodName = p.toString();
+        const createRpcRequest = Reflect.get(target, methodName, receiver);
+        const newRequest = createRpcRequest ? createRpcRequest(...rawParams) : { methodName, params: rawParams };
+        return createPendingRpcRequest(rpcConfig, newRequest);
+      };
+    }
+  });
+}
+function createJsonRpc(rpcConfig) {
+  return makeProxy(rpcConfig);
+}
+
+// src/json-rpc-subscription.ts
+function registerIterableCleanup(iterable, cleanupFn) {
+  (async () => {
+    try {
+      for await (const _ of iterable)
+        ;
+    } catch {
+    } finally {
+      cleanupFn();
+    }
+  })();
+}
+function createPendingRpcSubscription(rpcConfig, { params, subscribeMethodName, unsubscribeMethodName, responseTransformer }) {
+  return {
+    async subscribe({ abortSignal }) {
+      abortSignal.throwIfAborted();
+      let subscriptionId;
+      function handleCleanup() {
+        if (subscriptionId !== void 0) {
+          const payload = createJsonRpcMessage(unsubscribeMethodName, [subscriptionId]);
+          connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload).finally(() => {
+            connectionAbortController.abort();
+          });
         } else {
-          const { responseProcessor } = pendingRequests[ii];
-          return responseProcessor ? responseProcessor(response.result) : response.result;
+          connectionAbortController.abort();
         }
+      }
+      abortSignal.addEventListener("abort", handleCleanup);
+      const connectionAbortController = new AbortController();
+      const subscribeMessage = createJsonRpcMessage(subscribeMethodName, params);
+      const connection = await rpcConfig.transport({
+        payload: subscribeMessage,
+        signal: connectionAbortController.signal
       });
+      function handleConnectionCleanup() {
+        abortSignal.removeEventListener("abort", handleCleanup);
+      }
+      registerIterableCleanup(connection, handleConnectionCleanup);
+      for await (const message of connection) {
+        if ("id" in message && message.id === subscribeMessage.id) {
+          if ("error" in message) {
+            throw new SolanaJsonRpcError(message.error);
+          } else {
+            subscriptionId = message.result;
+            break;
+          }
+        }
+      }
+      if (subscriptionId == null) {
+        throw new Error("Failed to obtain a subscription id from the server");
+      }
+      return {
+        async *[Symbol.asyncIterator]() {
+          for await (const message of connection) {
+            if (!("params" in message) || message.params.subscription !== subscriptionId) {
+              continue;
+            }
+            const notification = message.params.result;
+            yield responseTransformer ? responseTransformer(notification, subscribeMethodName) : notification;
+          }
+        }
+      };
     }
   };
-  return makeProxy(transportConfig, overrides, pendingRequests);
 }
-function makeProxy(transportConfig, overrides, pendingRequestOrRequests) {
-  return new Proxy(transportConfig.api, {
+function makeProxy2(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
     defineProperty() {
@@ -119,15 +210,16 @@ return false;
     get(target, p, receiver) {
-      if (overrides && Reflect.has(overrides, p)) {
-        return Reflect.get(overrides, p, receiver);
-      }
       return function(...rawParams) {
         const methodName = p.toString();
-        const createTransportRequest = Reflect.get(target, methodName, receiver);
-        const newRequest = createTransportRequest ? createTransportRequest(...rawParams) : { methodName, params: rawParams };
-        if (pendingRequestOrRequests == null) {
-          return createArmedJsonRpcTransport(transportConfig, newRequest);
-        } else {
-          const nextPendingRequests = Array.isArray(pendingRequestOrRequests) ? [...pendingRequestOrRequests, newRequest] : [pendingRequestOrRequests, newRequest];
-          return createArmedBatchJsonRpcTransport(transportConfig, nextPendingRequests);
+        const createRpcSubscription = Reflect.get(target, methodName, receiver);
+        if (p.toString().endsWith("Notifications") === false && !createRpcSubscription) {
+          throw new Error(
+            "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function to map between the notification name and the subscribe/unsubscribe method names."
+          );
         }
+        const newRequest = createRpcSubscription ? createRpcSubscription(...rawParams) : {
+          params: rawParams,
+          subscribeMethodName: methodName.replace(/Notifications$/, "Subscribe"),
+          unsubscribeMethodName: methodName.replace(/Notifications$/, "Unsubscribe")
+        };
+        return createPendingRpcSubscription(rpcConfig, newRequest);
       };
@@ -137,8 +229,278 @@ }
 }
-function createJsonRpcTransport(transportConfig) {
-  return makeProxy(transportConfig);
+function createJsonSubscriptionRpc(rpcConfig) {
+  return makeProxy2(rpcConfig);
 }
 
-export { createJsonRpcTransport };
+// ../fetch-impl/dist/index.node.js
+var e = globalThis.fetch;
+
+// src/transports/http/http-transport-errors.ts
+var SolanaHttpError = class extends Error {
+  statusCode;
+  constructor(details) {
+    super(`HTTP error (${details.statusCode}): ${details.message}`);
+    Error.captureStackTrace(this, this.constructor);
+    this.statusCode = details.statusCode;
+  }
+  get name() {
+    return "SolanaHttpError";
+  }
+};
+
+// src/transports/http/http-transport-headers.ts
+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,
+  // No currently available Typescript technique allows you to match on a prefix.
+  // '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 Error(
+      `${badHeaders.length > 1 ? "These headers are" : "This header is"} forbidden: \`${badHeaders.join("`, `")}\`. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.`
+    );
+  }
+}
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/transports/http/http-transport.ts
+function createHttpTransport({ headers, url }) {
+  if (__DEV__ && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  const customHeaders = headers && normalizeHeaders(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = JSON.stringify(payload);
+    const requestInfo = {
+      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 e(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaHttpError({
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    return await response.json();
+  };
+}
+var t = e2;
+
+// src/transports/websocket/websocket-connection.ts
+var EXPLICIT_ABORT_TOKEN = Symbol(
+  __DEV__ ? "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" : void 0
+);
+async function createWebSocketConnection({
+  sendBufferHighWatermark,
+  signal,
+  url
+}) {
+  return new Promise((resolve, reject) => {
+    signal.addEventListener("abort", handleAbort, { once: true });
+    const iteratorState = /* @__PURE__ */ new Map();
+    function errorAndClearAllIteratorStates(reason) {
+      const errorCallbacks = [...iteratorState.values()].filter((state) => state.__hasPolled).map(({ onError }) => onError);
+      iteratorState.clear();
+      errorCallbacks.forEach((cb) => {
+        try {
+          cb(reason);
+        } catch {
+        }
+      });
+    }
+    function handleAbort() {
+      errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN);
+      if (webSocket.readyState !== t.CLOSED && webSocket.readyState !== t.CLOSING) {
+        webSocket.close(1e3);
+      }
+    }
+    function handleClose(ev) {
+      bufferDrainWatcher?.onCancel();
+      signal.removeEventListener("abort", handleAbort);
+      webSocket.removeEventListener("close", handleClose);
+      webSocket.removeEventListener("error", handleError);
+      webSocket.removeEventListener("open", handleOpen);
+      webSocket.removeEventListener("message", handleMessage);
+      errorAndClearAllIteratorStates(ev);
+    }
+    function handleError(ev) {
+      if (!hasConnected) {
+        reject(
+          // TODO: Coded error
+          new Error("WebSocket failed to connect", { cause: ev })
+        );
+      }
+    }
+    let hasConnected = false;
+    let bufferDrainWatcher;
+    function handleOpen() {
+      hasConnected = true;
+      resolve({
+        async send(payload) {
+          const message = JSON.stringify(payload);
+          if (!bufferDrainWatcher && webSocket.readyState === t.OPEN && webSocket.bufferedAmount > sendBufferHighWatermark) {
+            let onCancel;
+            const promise = new Promise((resolve2, reject2) => {
+              const intervalId = setInterval(() => {
+                if (webSocket.readyState !== t.OPEN || !(webSocket.bufferedAmount > sendBufferHighWatermark)) {
+                  clearInterval(intervalId);
+                  bufferDrainWatcher = void 0;
+                  resolve2();
+                }
+              }, 16);
+              onCancel = () => {
+                bufferDrainWatcher = void 0;
+                clearInterval(intervalId);
+                reject2(
+                  // TODO: Coded error
+                  new Error("WebSocket was closed before payload could be sent")
+                );
+              };
+            });
+            bufferDrainWatcher = {
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              onCancel,
+              promise
+            };
+          }
+          if (bufferDrainWatcher) {
+            await bufferDrainWatcher.promise;
+          }
+          webSocket.send(message);
+        },
+        async *[Symbol.asyncIterator]() {
+          const iteratorKey = Symbol();
+          iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
+          try {
+            while (true) {
+              const state = iteratorState.get(iteratorKey);
+              if (!state) {
+                throw new Error("Invariant: WebSocket message iterator is missing state storage");
+              }
+              if (state.__hasPolled) {
+                throw new Error(
+                  "Invariant: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise"
+                );
+              }
+              const queuedMessages = state.queuedMessages;
+              if (queuedMessages.length) {
+                state.queuedMessages = [];
+                yield* queuedMessages;
+              } else {
+                try {
+                  yield await new Promise((resolve2, reject2) => {
+                    iteratorState.set(iteratorKey, {
+                      __hasPolled: true,
+                      onError: reject2,
+                      onMessage: resolve2
+                    });
+                  });
+                } catch (e3) {
+                  if (e3 === EXPLICIT_ABORT_TOKEN) {
+                    return;
+                  } else {
+                    throw new Error("WebSocket connection closed", { cause: e3 });
+                  }
+                }
+              }
+            }
+          } finally {
+            iteratorState.delete(iteratorKey);
+          }
+        }
+      });
+    }
+    function handleMessage({ data }) {
+      const message = JSON.parse(data);
+      iteratorState.forEach((state, iteratorKey) => {
+        if (state.__hasPolled) {
+          const { onMessage } = state;
+          iteratorState.set(iteratorKey, { __hasPolled: false, queuedMessages: [] });
+          onMessage(message);
+        } else {
+          state.queuedMessages.push(message);
+        }
+      });
+    }
+    const webSocket = new t(url);
+    webSocket.addEventListener("close", handleClose);
+    webSocket.addEventListener("error", handleError);
+    webSocket.addEventListener("open", handleOpen);
+    webSocket.addEventListener("message", handleMessage);
+  });
+}
+
+// src/transports/websocket/websocket-transport.ts
+function createWebSocketTransport({ sendBufferHighWatermark, url }) {
+  if (/^wss?:/i.test(url) === false) {
+    const protocolMatch = url.match(/^([^:]+):/);
+    throw new DOMException(
+      protocolMatch ? `Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'. '${protocolMatch[1]}:' is not allowed.` : `Failed to construct 'WebSocket': The URL '${url}' is invalid.`
+    );
+  }
+  return async function sendWebSocketMessage({ payload, signal }) {
+    signal?.throwIfAborted();
+    const connection = await createWebSocketConnection({
+      sendBufferHighWatermark,
+      signal,
+      url
+    });
+    signal?.throwIfAborted();
+    await connection.send(payload);
+    return {
+      [Symbol.asyncIterator]: connection[Symbol.asyncIterator].bind(connection),
+      send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: connection.send.bind(connection)
+    };
+  };
+}
+
+export { createHttpTransport, createJsonRpc, createJsonRpcApi, createJsonRpcSubscriptionsApi, createJsonSubscriptionRpc, createWebSocketTransport };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.node.js.map

dist/types/index.d.ts

@@ -1,2 +0,10 @@
-export * from './json-rpc-transport';
+export * from './apis/api-types.js';
+export * from './apis/methods/methods-api.js';
+export * from './apis/subscriptions/subscriptions-api.js';
+export * from './json-rpc.js';
+export type { SolanaJsonRpcErrorCode } from './json-rpc-errors.js';
+export * from './json-rpc-subscription.js';
+export * from './transports/http/http-transport.js';
+export type { IRpcTransport, IRpcWebSocketTransport } from './transports/transport-types.js';
+export * from './transports/websocket/websocket-transport.js';
 //# sourceMappingURL=index.d.ts.map

package.json

 {
   "name": "@solana/rpc-transport",
-  "version": "2.0.0-experimental.66685ba",
+  "version": "2.0.0-experimental.6725a9f",
   "description": "Network transports for accessing the Solana JSON RPC API",
@@ -48,31 +48,36 @@ "exports": {
   ],
+  "dependencies": {
+    "@solana/rpc-types": "2.0.0-experimental.6725a9f"
+  },
   "devDependencies": {
-    "@solana/eslint-config-solana": "^1.0.0",
-    "@swc/core": "^1.3.18",
-    "@swc/jest": "^0.2.23",
-    "@types/jest": "^29.5.0",
-    "@types/node-fetch": "2",
-    "@typescript-eslint/eslint-plugin": "^5.57.1",
-    "@typescript-eslint/parser": "^5.57.1",
+    "@solana/eslint-config-solana": "^1.0.2",
+    "@swc/jest": "^0.2.29",
+    "@types/jest": "^29.5.11",
+    "@types/node": "18.11.19",
+    "@typescript-eslint/eslint-plugin": "^6.13.2",
+    "@typescript-eslint/parser": "^6.3.0",
     "agadoo": "^3.0.0",
-    "eslint": "^8.37.0",
-    "eslint-plugin-jest": "^27.1.5",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint": "^8.45.0",
+    "eslint-plugin-jest": "^27.4.2",
     "eslint-plugin-sort-keys-fix": "^1.1.2",
-    "jest": "^29.5.0",
-    "jest-environment-jsdom": "^29.5.0",
-    "jest-fetch-mock": "^3.0.3",
-    "jest-runner-eslint": "^2.0.0",
+    "fast-stable-stringify": "^1.0.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jest-fetch-mock-fork": "^3.0.4",
+    "jest-runner-eslint": "^2.1.2",
     "jest-runner-prettier": "^1.0.0",
-    "postcss": "^8.4.12",
-    "prettier": "^2.7.1",
-    "ts-node": "^10.9.1",
-    "tsup": "6.7.0",
-    "turbo": "^1.6.3",
-    "typescript": "^5.0.3",
+    "jest-websocket-mock": "^2.5.0",
+    "prettier": "^3.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.2.2",
     "version-from-git": "^1.1.1",
     "build-scripts": "0.0.0",
+    "fetch-impl": "0.0.0",
     "test-config": "0.0.0",
-    "tsconfig": "0.0.0"
+    "tsconfig": "0.0.0",
+    "ws-impl": "0.0.0"
   },
+  "peerDependencies": {
+    "ws": "^8.14.0"
+  },
   "bundlewatch": {
@@ -86,17 +91,13 @@ "defaultCompression": "gzip",
   },
-  "dependencies": {
-    "node-fetch": "^2.6.7",
-    "@solana/keys": "2.0.0-experimental.66685ba",
-    "fetch-impl-browser": "0.0.0"
-  },
   "scripts": {
     "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
-    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node node_modules/build-scripts/add-js-extension-to-types.mjs",
     "dev": "jest -c node_modules/test-config/jest-dev.config.ts --rootDir . --watch",
     "publish-packages": "pnpm publish --tag experimental --access public --no-git-checks",
+    "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/* package.json",
     "test:lint": "jest -c node_modules/test-config/jest-lint.config.ts --rootDir . --silent",
     "test:prettier": "jest -c node_modules/test-config/jest-prettier.config.ts --rootDir . --silent",
     "test:treeshakability:browser": "agadoo dist/index.browser.js",
-    "test:treeshakability:native": "agadoo dist/index.node.js",
-    "test:treeshakability:node": "agadoo dist/index.native.js",
+    "test:treeshakability:native": "agadoo dist/index.native.js",
+    "test:treeshakability:node": "agadoo dist/index.node.js",
     "test:typecheck": "tsc --noEmit",
@@ -103,0 +104,0 @@ "test:unit:browser": "jest -c node_modules/test-config/jest-unit.config.browser.ts --rootDir . --silent",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

No README

Quality

Package does not have a README. This may indicate a failed publish or a low quality package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

330507

increased by201.92%

Dependency count

2

decreased by-33.33%

Dev dependency count

26

decreased by-3.7%

Number of package files

46

increased by58.62%

Lines of code

3090

increased by232.97%

Number of medium quality alerts

1

decreased by-50%

Number of lines in readme file

83

increased byInfinity%

Number of medium supply chain risk alerts

1

decreased by-66.67%

Worsened metrics

Published versions last year

157

decreased by-9.25%

Dependency changes

• + Added@solana/rpc-types@2.0.0-experimental.6725a9f

• + Added@solana/codecs-core@2.0.0-experimental.6725a9f(transitive)

• + Added@solana/codecs-numbers@2.0.0-experimental.6725a9f(transitive)

• + Added@solana/codecs-strings@2.0.0-experimental.6725a9f(transitive)

• + Added@solana/rpc-types@2.0.0-experimental.6725a9f(transitive)

• + Addedfastestsmallesttextencoderdecoder@1.0.22(transitive)

• + Addedws@8.18.0(transitive)

• - Removed@solana/keys@2.0.0-experimental.66685ba

• - Removedfetch-impl-browser@0.0.0

• - Removednode-fetch@^2.6.7

• - Removed@solana/keys@2.0.0-experimental.66685ba(transitive)

• - Removedbase-x@4.0.0(transitive)

• - Removedbs58@5.0.0(transitive)

• - Removednode-fetch@2.7.0(transitive)

• - Removedtr46@0.0.3(transitive)

• - Removedwebidl-conversions@3.0.1(transitive)

• - Removedwhatwg-url@5.0.0(transitive)