Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

@solana/rpc-transport

Package Overview
Dependencies
Maintainers
14
Versions
602
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@solana/rpc-transport - npm Package Compare versions

Comparing version 2.0.0-experimental.847f0a9 to 2.0.0-experimental.8488c9f

dist/types/apis/api-types.d.ts

508

dist/index.browser.js

@@ -1,41 +0,61 @@

import 'node-fetch';
// ../build-scripts/env-shim.ts
var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
// ../fetch-impl-browser/dist/index.browser.js
var { fetch } = globalThis;
var src_default = fetch;
// 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
};
};
}
});
}
// 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"
// 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

@@ -1,41 +0,61 @@

import 'node-fetch';
// ../build-scripts/env-shim.ts
var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
// ../fetch-impl-browser/dist/index.browser.js
var { fetch } = globalThis;
var src_default = fetch;
// 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
};
};
}
});
}
// 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"
// 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

@@ -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

@@ -1,2 +0,12 @@

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 type { IRpcApi, IRpcSubscriptionsApi, IRpcWebSocketTransport, PendingRpcSubscription, Rpc, RpcRequest, RpcSubscription, RpcSubscriptions, } from './json-rpc-types.js';
export * from './transports/http/http-transport.js';
export * from './transports/websocket/websocket-transport.js';
export type { IRpcTransport } from './transports/transport-types.js';
export * from './transports/websocket/websocket-transport.js';
//# sourceMappingURL=index.d.ts.map

58

package.json
{
"name": "@solana/rpc-transport",
"version": "2.0.0-experimental.847f0a9",
"version": "2.0.0-experimental.8488c9f",
"description": "Network transports for accessing the Solana JSON RPC API",

@@ -49,31 +49,32 @@ "exports": {

"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",
"@solana/fetch-impl-browser": "0.0.0-development",
"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": {

@@ -87,16 +88,13 @@ "defaultCompression": "gzip",

},
"dependencies": {
"node-fetch": "^2.6.7",
"@solana/keys": "2.0.0-experimental.847f0a9"
},
"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 +101,0 @@ "test:unit:browser": "jest -c node_modules/test-config/jest-unit.config.browser.ts --rootDir . --silent",

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc