xrpl 2.13.0 → 3.0.0-beta.0

package/src/client/RequestManager.ts

@@ -4,9 +4,15 @@ import {
   TimeoutError,
   XrplError,
 } from '../errors'
-import { Response } from '../models/methods'
+import { Response, RequestResponseMap } from '../models/methods'
 import { BaseRequest, ErrorResponse } from '../models/methods/baseMethod'
 
+interface PromiseEntry<T> {
+  resolve: (value: T | PromiseLike<T>) => void
+  reject: (value: Error) => void
+  timer: ReturnType<typeof setTimeout>
+}
+
 /**
  * Manage all the requests made to the websocket, and their async responses
  * that come in from the WebSocket. Responses come in over the WS connection
@@ -17,13 +23,31 @@ export default class RequestManager {
   private nextId = 0
   private readonly promisesAwaitingResponse = new Map<
     string | number,
-    {
-      resolve: (value: Response | PromiseLike<Response>) => void
-      reject: (value: Error) => void
-      timer: ReturnType<typeof setTimeout>
-    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Necessary and typed wrapper in addPromise method
+    PromiseEntry<any>
   >()
 
+  /**
+   * Adds a promise to the collection of promises awaiting response. Handles typing with generics.
+   *
+   * @template T The generic type parameter representing the resolved value type.
+   * @param newId - The identifier for the new promise.
+   * @param timer - The timer associated with the promise.
+   * @returns A promise that resolves to the specified generic type.
+   */
+  public async addPromise<R extends BaseRequest, T = RequestResponseMap<R>>(
+    newId: string | number,
+    timer: ReturnType<typeof setTimeout>,
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      this.promisesAwaitingResponse.set(newId, {
+        resolve,
+        reject,
+        timer,
+      })
+    })
+  }
+
   /**
    * Successfully resolves a request.
    *
@@ -87,10 +111,10 @@ export default class RequestManager {
    * @returns Request ID, new request form, and the promise for resolving the request.
    * @throws XrplError if request with the same ID is already pending.
    */
-  public createRequest<T extends BaseRequest>(
-    request: T,
+  public createRequest<R extends BaseRequest, T = RequestResponseMap<R>>(
+    request: R,
     timeout: number,
-  ): [string | number, string, Promise<Response>] {
+  ): [string | number, string, Promise<T>] {
     let newId: string | number
     if (request.id == null) {
       newId = this.nextId
@@ -129,11 +153,13 @@ export default class RequestManager {
         request,
       )
     }
-    const newPromise = new Promise<Response>(
-      (resolve: (value: Response | PromiseLike<Response>) => void, reject) => {
-        this.promisesAwaitingResponse.set(newId, { resolve, reject, timer })
-      },
-    )
+    const newPromise = new Promise<T>((resolve, reject) => {
+      this.promisesAwaitingResponse.set(newId, {
+        resolve,
+        reject,
+        timer,
+      })
+    })
 
     return [newId, newRequest, newPromise]
   }

package/src/client/connection.ts

@@ -1,9 +1,8 @@
 /* eslint-disable max-lines -- Connection is a large file w/ lots of imports/exports */
-import { EventEmitter } from 'events'
-import { Agent } from 'http'
+import type { Agent } from 'http'
 
-import omitBy from 'lodash/omitBy'
-import WebSocket from 'ws'
+import WebSocket, { ClientOptions } from '@xrplf/isomorphic/ws'
+import { EventEmitter } from 'eventemitter3'
 
 import {
   DisconnectedError,
@@ -11,6 +10,7 @@ import {
   ConnectionError,
   XrplError,
 } from '../errors'
+import type { RequestResponseMap } from '../models'
 import { BaseRequest } from '../models/methods/baseMethod'
 
 import ConnectionManager from './ConnectionManager'
@@ -26,17 +26,11 @@ const CONNECTION_TIMEOUT = 5
  */
 interface ConnectionOptions {
   trace?: boolean | ((id: string, message: string) => void)
-  proxy?: string
-  proxyAuthorization?: string
+  headers?: { [key: string]: string }
+  agent?: Agent
   authorization?: string
-  trustedCertificates?: string[]
-  key?: string
-  passphrase?: string
-  certificate?: string
-  // request timeout
-  timeout: number
   connectionTimeout: number
-  headers?: { [key: string]: string }
+  timeout: number
 }
 
 /**
@@ -55,52 +49,6 @@ export const INTENTIONAL_DISCONNECT_CODE = 4000
 
 type WebsocketState = 0 | 1 | 2 | 3
 
-function getAgent(url: string, config: ConnectionOptions): Agent | undefined {
-  if (config.proxy == null) {
-    return undefined
-  }
-
-  const parsedURL = new URL(url)
-  const parsedProxyURL = new URL(config.proxy)
-
-  const proxyOptions = omitBy(
-    {
-      secureEndpoint: parsedURL.protocol === 'wss:',
-      secureProxy: parsedProxyURL.protocol === 'https:',
-      auth: config.proxyAuthorization,
-      ca: config.trustedCertificates,
-      key: config.key,
-      passphrase: config.passphrase,
-      cert: config.certificate,
-      href: parsedProxyURL.href,
-      origin: parsedProxyURL.origin,
-      protocol: parsedProxyURL.protocol,
-      username: parsedProxyURL.username,
-      password: parsedProxyURL.password,
-      host: parsedProxyURL.host,
-      hostname: parsedProxyURL.hostname,
-      port: parsedProxyURL.port,
-      pathname: parsedProxyURL.pathname,
-      search: parsedProxyURL.search,
-      hash: parsedProxyURL.hash,
-    },
-    (value) => value == null,
-  )
-
-  let HttpsProxyAgent: new (opt: typeof proxyOptions) => Agent
-  try {
-    /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports,
-      node/global-require, global-require, -- Necessary for the `require` */
-    HttpsProxyAgent = require('https-proxy-agent')
-    /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports,
-      node/global-require, global-require, */
-  } catch (_error) {
-    throw new Error('"proxy" option is not supported in the browser')
-  }
-
-  return new HttpsProxyAgent(proxyOptions)
-}
-
 /**
  * Create a new websocket given your URL and optional proxy/certificate
  * configuration.
@@ -113,8 +61,9 @@ function createWebSocket(
   url: string,
   config: ConnectionOptions,
 ): WebSocket | null {
-  const options: WebSocket.ClientOptions = {}
-  options.agent = getAgent(url, config)
+  const options: ClientOptions = {
+    agent: config.agent,
+  }
   if (config.headers) {
     options.headers = config.headers
   }
@@ -125,25 +74,8 @@ function createWebSocket(
       Authorization: `Basic ${base64}`,
     }
   }
-  const optionsOverrides = omitBy(
-    {
-      ca: config.trustedCertificates,
-      key: config.key,
-      passphrase: config.passphrase,
-      cert: config.certificate,
-    },
-    (value) => value == null,
-  )
-  const websocketOptions = { ...options, ...optionsOverrides }
-  const websocket = new WebSocket(url, websocketOptions)
-  /*
-   * we will have a listener for each outstanding request,
-   * so we have to raise the limit (the default is 10)
-   */
-  if (typeof websocket.setMaxListeners === 'function') {
-    websocket.setMaxListeners(Infinity)
-  }
-  return websocket
+  const websocketOptions = { ...options }
+  return new WebSocket(url, websocketOptions)
 }
 
 /**
@@ -177,7 +109,7 @@ export class Connection extends EventEmitter {
   private ws: WebSocket | null = null
   // Typing necessary for Jest tests running in browser
   private reconnectTimeoutID: null | ReturnType<typeof setTimeout> = null
-  // Typing necessary for Jest tetsts running in browser
+  // Typing necessary for Jest tests running in browser
   private heartbeatIntervalID: null | ReturnType<typeof setTimeout> = null
   private readonly retryConnectionBackoff = new ExponentialBackoff({
     min: 100,
@@ -196,7 +128,6 @@ export class Connection extends EventEmitter {
    */
   public constructor(url?: string, options: ConnectionUserOptions = {}) {
     super()
-    this.setMaxListeners(Infinity)
     this.url = url
     this.config = {
       timeout: TIMEOUT * 1000,
@@ -356,17 +287,17 @@ export class Connection extends EventEmitter {
    * @returns The response from the rippled server.
    * @throws NotConnectedError if the Connection isn't connected to a server.
    */
-  public async request<T extends BaseRequest>(
-    request: T,
+  public async request<R extends BaseRequest, T = RequestResponseMap<R>>(
+    request: R,
     timeout?: number,
-  ): Promise<unknown> {
+  ): Promise<T> {
     if (!this.shouldBeConnected || this.ws == null) {
       throw new NotConnectedError(JSON.stringify(request), request)
     }
-    const [id, message, responsePromise] = this.requestManager.createRequest(
-      request,
-      timeout ?? this.config.timeout,
-    )
+    const [id, message, responsePromise] = this.requestManager.createRequest<
+      R,
+      T
+    >(request, timeout ?? this.config.timeout)
     this.trace('send', message)
     websocketSendAsync(this.ws, message).catch((error) => {
       this.requestManager.reject(id, error)