xrpl 2.14.0 → 3.0.0-beta.1

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/rfc1751.ts

@@ -10,6 +10,8 @@
  *is part of the public domain.
  */
 
+import { hexToBytes, concat } from '@xrplf/isomorphic/utils'
+
 import rfc1751Words from './rfc1751Words.json'
 
 const rfc1751WordList: string[] = rfc1751Words
@@ -59,7 +61,7 @@ function extract(key: string, start: number, length: number): number {
  */
 function keyToRFC1751Mnemonic(hex_key: string): string {
   // Remove whitespace and interpret hex
-  const buf = Buffer.from(hex_key.replace(/\s+/gu, ''), 'hex')
+  const buf = hexToBytes(hex_key.replace(/\s+/gu, ''))
   // Swap byte order and use rfc1751
   let key: number[] = bufferToArray(swap128(buf))
 
@@ -97,7 +99,7 @@ function keyToRFC1751Mnemonic(hex_key: string): string {
  * @throws Error if the parity after decoding does not match.
  * @returns A Buffer containing an encoded secret.
  */
-function rfc1751MnemonicToKey(english: string): Buffer {
+function rfc1751MnemonicToKey(english: string): Uint8Array {
   const words = english.split(' ')
   let key: number[] = []
 
@@ -123,7 +125,7 @@ function rfc1751MnemonicToKey(english: string): Buffer {
   }
 
   // This is a step specific to the XRPL's implementation
-  const bufferKey = swap128(Buffer.from(key))
+  const bufferKey = swap128(Uint8Array.from(key))
   return bufferKey
 }
 
@@ -165,26 +167,53 @@ function getSubKey(
   return { subKey, word }
 }
 
-function bufferToArray(buf: Buffer): number[] {
+function bufferToArray(buf: Uint8Array): number[] {
   /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We know the end type */
   return Array.prototype.slice.call(buf) as number[]
 }
 
+function swap(arr: Uint8Array, n: number, m: number): void {
+  const i = arr[n]
+  // eslint-disable-next-line no-param-reassign -- we have to swap
+  arr[n] = arr[m]
+  // eslint-disable-next-line no-param-reassign -- see above
+  arr[m] = i
+}
+
+/**
+ * Interprets arr as an array of 64-bit numbers and swaps byte order in 64 bit chunks.
+ * Example of two 64 bit numbers 0000000100000002 => 1000000020000000
+ *
+ * @param arr A Uint8Array representation of one or more 64 bit numbers
+ * @returns Uint8Array An array containing the bytes of 64 bit numbers each with reversed endianness
+ */
+function swap64(arr: Uint8Array): Uint8Array {
+  const len = arr.length
+
+  for (let i = 0; i < len; i += 8) {
+    swap(arr, i, i + 7)
+    swap(arr, i + 1, i + 6)
+    swap(arr, i + 2, i + 5)
+    swap(arr, i + 3, i + 4)
+  }
+
+  return arr
+}
+
 /**
- * Swap the byte order of a 128-bit buffer.
+ * Swap the byte order of a 128-bit array.
+ * Ex. 0000000100000002 => 2000000010000000
  *
- * @param buf - A 128-bit (16 byte) buffer
- * @returns A buffer containing the same data with reversed endianness
+ * @param arr - A 128-bit (16 byte) array
+ * @returns An array containing the same data with reversed endianness
  */
-function swap128(buf: Buffer): Buffer {
-  // Interprets buffer as an array of (two, in this case) 64-bit numbers and swaps byte order in-place.
-  const reversedBytes = buf.swap64()
-
-  // Swap the two 64-bit numbers since our buffer is 128 bits.
-  return Buffer.concat(
-    [reversedBytes.slice(8, 16), reversedBytes.slice(0, 8)],
-    16,
-  )
+function swap128(arr: Uint8Array): Uint8Array {
+  // Interprets arr as an array of (two, in this case) 64-bit numbers and swaps byte order in 64 bit chunks.
+  // Ex. 0000000100000002 => 1000000020000000
+  const reversedBytes = swap64(arr)
+  // Further swap the two 64-bit numbers since our buffer is 128 bits.
+  // Ex. 1000000020000000 => 2000000010000000
+  return concat([reversedBytes.slice(8, 16), reversedBytes.slice(0, 8)])
 }
 
 export { rfc1751MnemonicToKey, keyToRFC1751Mnemonic }

package/src/Wallet/signer.ts

@@ -1,20 +1,13 @@
+import { bytesToHex } from '@xrplf/isomorphic/utils'
 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 +55,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 +119,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 }
 }
@@ -155,7 +145,7 @@ function compareSigners(left: Signer, right: Signer): number {
 const NUM_BITS_IN_HEX = 16
 
 function addressToBigNumber(address: string): BigNumber {
-  const hex = Buffer.from(decodeAccountID(address)).toString('hex')
+  const hex = bytesToHex(decodeAccountID(address))
   return new BigNumber(hex, NUM_BITS_IN_HEX)
 }
 
@@ -170,4 +160,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,9 @@
 /* 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 { bytesToHex, hexToString } from '@xrplf/isomorphic/utils'
+import WebSocket, { ClientOptions } from '@xrplf/isomorphic/ws'
+import { EventEmitter } from 'eventemitter3'
 
 import {
   DisconnectedError,
@@ -11,6 +11,7 @@ import {
   ConnectionError,
   XrplError,
 } from '../errors'
+import type { RequestResponseMap } from '../models'
 import { BaseRequest } from '../models/methods/baseMethod'
 
 import ConnectionManager from './ConnectionManager'
@@ -26,17 +27,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 +50,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,37 +62,20 @@ 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
   }
   if (config.authorization != null) {
-    const base64 = Buffer.from(config.authorization).toString('base64')
     options.headers = {
       ...options.headers,
-      Authorization: `Basic ${base64}`,
+      Authorization: `Basic ${btoa(config.authorization)}`,
     }
   }
-  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)
@@ -451,7 +382,7 @@ export class Connection extends EventEmitter {
       this.emit('error', 'websocket', error.message, error),
     )
     // Handle a closed connection: reconnect if it was unexpected
-    this.ws.once('close', (code?: number, reason?: Buffer) => {
+    this.ws.once('close', (code?: number, reason?: Uint8Array) => {
       if (this.ws == null) {
         throw new XrplError('onceClose: ws is null')
       }
@@ -459,7 +390,9 @@ export class Connection extends EventEmitter {
       this.clearHeartbeatInterval()
       this.requestManager.rejectAll(
         new DisconnectedError(
-          `websocket was closed, ${new TextDecoder('utf-8').decode(reason)}`,
+          `websocket was closed, ${
+            reason ? hexToString(bytesToHex(reason)) : ''
+          }`,
         ),
       )
       this.ws.removeAllListeners()