xrpl 2.12.0 → 3.0.0-beta.0

package/src/Wallet/index.ts

@@ -1,7 +1,8 @@
+import { HDKey } from '@scure/bip32'
+import { mnemonicToSeedSync, validateMnemonic } from '@scure/bip39'
+import { wordlist } from '@scure/bip39/wordlists/english'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
 import BigNumber from 'bignumber.js'
-import { fromSeed } from 'bip32'
-import { mnemonicToSeedSync, validateMnemonic } from 'bip39'
-import omitBy from 'lodash/omitBy'
 import {
   classicAddressToXAddress,
   isValidXAddress,
@@ -9,7 +10,6 @@ import {
   encodeSeed,
 } from 'ripple-address-codec'
 import {
-  decode,
   encodeForSigning,
   encodeForMultisigning,
   encode,
@@ -18,7 +18,6 @@ import {
   deriveAddress,
   deriveKeypair,
   generateSeed,
-  verify,
   sign,
 } from 'ripple-keypairs'
 
@@ -26,15 +25,28 @@ import ECDSA from '../ECDSA'
 import { ValidationError } from '../errors'
 import { Transaction, validate } from '../models/transactions'
 import { ensureClassicAddress } from '../sugar/utils'
+import { omitBy } from '../utils/collections'
 import { hashSignedTx } from '../utils/hashes/hashLedger'
 
 import { rfc1751MnemonicToKey } from './rfc1751'
+import { verifySignature } from './signer'
 
 const DEFAULT_ALGORITHM: ECDSA = ECDSA.ed25519
 const DEFAULT_DERIVATION_PATH = "m/44'/144'/0'/0/0"
 
-function hexFromBuffer(buffer: Buffer): string {
-  return buffer.toString('hex').toUpperCase()
+type ValidHDKey = HDKey & {
+  privateKey: Uint8Array
+  publicKey: Uint8Array
+}
+
+function validateKey(node: HDKey): asserts node is ValidHDKey {
+  if (!(node.privateKey instanceof Uint8Array)) {
+    throw new ValidationError('Unable to derive privateKey from mnemonic input')
+  }
+
+  if (!(node.publicKey instanceof Uint8Array)) {
+    throw new ValidationError('Unable to derive publicKey from mnemonic input')
+  }
 }
 
 /**
@@ -137,7 +149,7 @@ export class Wallet {
       throw new ValidationError('Invalid cryptographic signing algorithm')
     }
     const seed = generateSeed({ algorithm })
-    return Wallet.fromSeed(seed)
+    return Wallet.fromSeed(seed, { algorithm })
   }
 
   /**
@@ -232,25 +244,21 @@ export class Wallet {
       })
     }
     // Otherwise decode using bip39's mnemonic standard
-    if (!validateMnemonic(mnemonic)) {
+    if (!validateMnemonic(mnemonic, wordlist)) {
       throw new ValidationError(
         'Unable to parse the given mnemonic using bip39 encoding',
       )
     }
 
     const seed = mnemonicToSeedSync(mnemonic)
-    const masterNode = fromSeed(seed)
-    const node = masterNode.derivePath(
+    const masterNode = HDKey.fromMasterSeed(seed)
+    const node = masterNode.derive(
       opts.derivationPath ?? DEFAULT_DERIVATION_PATH,
     )
-    if (node.privateKey === undefined) {
-      throw new ValidationError(
-        'Unable to derive privateKey from mnemonic input',
-      )
-    }
+    validateKey(node)
 
-    const publicKey = hexFromBuffer(node.publicKey)
-    const privateKey = hexFromBuffer(node.privateKey)
+    const publicKey = bytesToHex(node.publicKey)
+    const privateKey = bytesToHex(node.privateKey)
     return new Wallet(publicKey, `00${privateKey}`, {
       masterAddress: opts.masterAddress,
     })
@@ -434,15 +442,10 @@ export class Wallet {
    *
    * @param signedTransaction - A signed transaction (hex string of signTransaction result) to be verified offline.
    * @returns Returns true if a signedTransaction is valid.
+   * @throws {Error} Transaction is missing a signature, TxnSignature
    */
   public verifyTransaction(signedTransaction: Transaction | string): boolean {
-    const tx =
-      typeof signedTransaction === 'string'
-        ? decode(signedTransaction)
-        : signedTransaction
-    const messageHex: string = encodeForSigning(tx)
-    const signature = tx.TxnSignature
-    return verify(messageHex, signature, this.publicKey)
+    return verifySignature(signedTransaction, this.publicKey)
   }
 
   /**

package/src/Wallet/signer.ts

@@ -1,20 +1,12 @@
 import { BigNumber } from 'bignumber.js'
-import { flatMap } from 'lodash'
 import { decodeAccountID } from 'ripple-address-codec'
-import {
-  decode,
-  encode,
-  encodeForSigning,
-  encodeForSigningClaim,
-} from 'ripple-binary-codec'
-import { sign as signWithKeypair, verify } from 'ripple-keypairs'
+import { decode, encode, encodeForSigning } from 'ripple-binary-codec'
+import { verify } from 'ripple-keypairs'
 
 import { ValidationError } from '../errors'
 import { Signer } from '../models/common'
 import { Transaction, validate } from '../models/transactions'
 
-import { Wallet } from '.'
-
 /**
  * Takes several transactions with Signer fields (in object or blob form) and creates a
  * single transaction with all Signers that then gets signed and returned.
@@ -62,42 +54,40 @@ function multisign(transactions: Array<Transaction | string>): string {
   return encode(getTransactionWithAllSigners(decodedTransactions))
 }
 
-/**
- * Creates a signature that can be used to redeem a specific amount of XRP from a payment channel.
- *
- * @param wallet - The account that will sign for this payment channel.
- * @param channelId - An id for the payment channel to redeem XRP from.
- * @param amount - The amount in drops to redeem.
- * @returns A signature that can be used to redeem a specific amount of XRP from a payment channel.
- * @category Utilities
- */
-function authorizeChannel(
-  wallet: Wallet,
-  channelId: string,
-  amount: string,
-): string {
-  const signingData = encodeForSigningClaim({
-    channel: channelId,
-    amount,
-  })
-
-  return signWithKeypair(signingData, wallet.privateKey)
-}
-
 /**
  * Verifies that the given transaction has a valid signature based on public-key encryption.
  *
  * @param tx - A transaction to verify the signature of. (Can be in object or encoded string format).
+ * @param [publicKey] Specific public key to use to verify. If not specified the `SigningPublicKey` of tx will be used.
  * @returns Returns true if tx has a valid signature, and returns false otherwise.
+ * @throws Error when transaction is missing TxnSignature
+ * @throws Error when publicKey is not provided and transaction is missing SigningPubKey
  * @category Utilities
  */
-function verifySignature(tx: Transaction | string): boolean {
+function verifySignature(
+  tx: Transaction | string,
+  publicKey?: string,
+): boolean {
   const decodedTx: Transaction = getDecodedTransaction(tx)
-  return verify(
-    encodeForSigning(decodedTx),
-    decodedTx.TxnSignature,
-    decodedTx.SigningPubKey,
-  )
+  let key = publicKey
+
+  // Need a SignedTransaction class where TxnSignature is not optional.
+  if (typeof decodedTx.TxnSignature !== 'string' || !decodedTx.TxnSignature) {
+    throw new Error('Transaction is missing a signature, TxnSignature')
+  }
+
+  if (!key) {
+    // Need a SignedTransaction class where TxnSignature is not optional.
+    if (
+      typeof decodedTx.SigningPubKey !== 'string' ||
+      !decodedTx.SigningPubKey
+    ) {
+      throw new Error('Transaction is missing a public key, SigningPubKey')
+    }
+    key = decodedTx.SigningPubKey
+  }
+
+  return verify(encodeForSigning(decodedTx), decodedTx.TxnSignature, key)
 }
 
 /**
@@ -128,10 +118,9 @@ function getTransactionWithAllSigners(
   transactions: Transaction[],
 ): Transaction {
   // Signers must be sorted in the combined transaction - See compareSigners' documentation for more details
-  const sortedSigners: Signer[] = flatMap(
-    transactions,
-    (tx) => tx.Signers ?? [],
-  ).sort(compareSigners)
+  const sortedSigners: Signer[] = transactions
+    .flatMap((tx) => tx.Signers ?? [])
+    .sort(compareSigners)
 
   return { ...transactions[0], Signers: sortedSigners }
 }
@@ -170,4 +159,4 @@ function getDecodedTransaction(txOrBlob: Transaction | string): Transaction {
   return decode(txOrBlob) as unknown as Transaction
 }
 
-export { authorizeChannel, verifySignature, multisign }
+export { verifySignature, multisign }

package/src/Wallet/walletFromSecretNumbers.ts

@@ -1,4 +1,4 @@
-import { Account } from 'xrpl-secret-numbers'
+import { Account } from '@xrplf/secret-numbers'
 
 import ECDSA from '../ECDSA'
 

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)