ripple-binary-codec 2.0.0-beta.0 → 2.0.0

package/src/hash-prefixes.ts

@@ -1,21 +1,21 @@
-import { Buffer } from 'buffer/'
+import { writeUInt32BE } from './utils'
 
 /**
- * Write a 32 bit integer to a Buffer
+ * Write a 32 bit integer to a Uint8Array
  *
- * @param uint32 32 bit integer to write to buffer
- * @returns a buffer with the bytes representation of uint32
+ * @param uint32 32 bit integer to write to Uint8Array
+ * @returns a Uint8Array with the bytes representation of uint32
  */
-function bytes(uint32: number): Buffer {
-  const result = Buffer.alloc(4)
-  result.writeUInt32BE(uint32, 0)
+function bytes(uint32: number): Uint8Array {
+  const result = new Uint8Array(4)
+  writeUInt32BE(result, uint32, 0)
   return result
 }
 
 /**
  * Maps HashPrefix names to their byte representation
  */
-const HashPrefix: Record<string, Buffer> = {
+const HashPrefix: Record<string, Uint8Array> = {
   transactionID: bytes(0x54584e00),
   // transaction plus metadata
   transaction: bytes(0x534e4400),

package/src/hashes.ts

@@ -1,7 +1,6 @@
 import { HashPrefix } from './hash-prefixes'
 import { Hash256 } from './types'
 import { BytesList } from './serdes/binary-serializer'
-import { Buffer } from 'buffer/'
 import { sha512 } from '@xrplf/isomorphic/sha512'
 
 /**
@@ -17,7 +16,7 @@ class Sha512Half extends BytesList {
    * @param bytes bytes to write to this.hash
    * @returns the new Sha512Hash object
    */
-  static put(bytes: Buffer): Sha512Half {
+  static put(bytes: Uint8Array): Sha512Half {
     return new Sha512Half().put(bytes)
   }
 
@@ -27,7 +26,7 @@ class Sha512Half extends BytesList {
    * @param bytes bytes to write to object
    * @returns the Sha512 object
    */
-  put(bytes: Buffer): Sha512Half {
+  put(bytes: Uint8Array): Sha512Half {
     this.hash.update(bytes)
     return this
   }
@@ -37,8 +36,8 @@ class Sha512Half extends BytesList {
    *
    * @returns half of a SHA512 hash
    */
-  finish256(): Buffer {
-    return Buffer.from(this.hash.digest().slice(0, 32))
+  finish256(): Uint8Array {
+    return Uint8Array.from(this.hash.digest().slice(0, 32))
   }
 
   /**
@@ -57,7 +56,7 @@ class Sha512Half extends BytesList {
  * @param args zero or more arguments to hash
  * @returns the sha512half hash of the arguments.
  */
-function sha512Half(...args: Buffer[]): Buffer {
+function sha512Half(...args: Uint8Array[]): Uint8Array {
   const hash = new Sha512Half()
   args.forEach((a) => hash.put(a))
   return hash.finish256()
@@ -69,7 +68,7 @@ function sha512Half(...args: Buffer[]): Buffer {
  * @param serialized bytes to hash
  * @returns a Hash256 object
  */
-function transactionID(serialized: Buffer): Hash256 {
+function transactionID(serialized: Uint8Array): Hash256 {
   return new Hash256(sha512Half(HashPrefix.transactionID, serialized))
 }
 

package/src/index.ts

@@ -9,6 +9,7 @@ import {
 } from './enums'
 import { XrplDefinitions } from './enums/xrpl-definitions'
 import { coreTypes } from './types'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
 
 const {
   signingData,
@@ -44,9 +45,7 @@ function encode(json: object, definitions?: XrplDefinitionsBase): string {
   if (typeof json !== 'object') {
     throw new Error()
   }
-  return serializeObject(json as JsonObject, { definitions })
-    .toString('hex')
-    .toUpperCase()
+  return bytesToHex(serializeObject(json as JsonObject, { definitions }))
 }
 
 /**
@@ -64,11 +63,11 @@ function encodeForSigning(
   if (typeof json !== 'object') {
     throw new Error()
   }
-  return signingData(json as JsonObject, HashPrefix.transactionSig, {
-    definitions,
-  })
-    .toString('hex')
-    .toUpperCase()
+  return bytesToHex(
+    signingData(json as JsonObject, HashPrefix.transactionSig, {
+      definitions,
+    }),
+  )
 }
 
 /**
@@ -83,9 +82,7 @@ function encodeForSigningClaim(json: object): string {
   if (typeof json !== 'object') {
     throw new Error()
   }
-  return signingClaimData(json as ClaimObject)
-    .toString('hex')
-    .toUpperCase()
+  return bytesToHex(signingClaimData(json as ClaimObject))
 }
 
 /**
@@ -108,9 +105,9 @@ function encodeForMultisigning(
     throw new Error()
   }
   const definitionsOpt = definitions ? { definitions } : undefined
-  return multiSigningData(json as JsonObject, signer, definitionsOpt)
-    .toString('hex')
-    .toUpperCase()
+  return bytesToHex(
+    multiSigningData(json as JsonObject, signer, definitionsOpt),
+  )
 }
 
 /**
@@ -123,7 +120,7 @@ function encodeQuality(value: string): string {
   if (typeof value !== 'string') {
     throw new Error()
   }
-  return quality.encode(value).toString('hex').toUpperCase()
+  return bytesToHex(quality.encode(value))
 }
 
 /**

package/src/quality.ts

@@ -1,6 +1,6 @@
 import { coreTypes } from './types'
-import { Buffer } from 'buffer/'
 import BigNumber from 'bignumber.js'
+import { bytesToHex, hexToBytes } from '@xrplf/isomorphic/utils'
 
 /**
  * class for encoding and decoding quality
@@ -12,7 +12,7 @@ class quality {
    * @param arg string representation of an amount
    * @returns Serialized quality
    */
-  static encode(quality: string): Buffer {
+  static encode(quality: string): Uint8Array {
     const decimal = BigNumber(quality)
     const exponent = (decimal?.e || 0) - 15
     const qualityString = decimal.times(`1e${-exponent}`).abs().toString()
@@ -28,9 +28,9 @@ class quality {
    * @returns deserialized quality
    */
   static decode(quality: string): BigNumber {
-    const bytes = Buffer.from(quality, 'hex').slice(-8)
+    const bytes = hexToBytes(quality).slice(-8)
     const exponent = bytes[0] - 100
-    const mantissa = new BigNumber(`0x${bytes.slice(1).toString('hex')}`)
+    const mantissa = new BigNumber(`0x${bytesToHex(bytes.slice(1))}`)
     return mantissa.times(`1e${exponent}`)
   }
 }

package/src/serdes/binary-parser.ts

@@ -4,13 +4,13 @@ import {
   FieldInstance,
 } from '../enums'
 import { type SerializedType } from '../types/serialized-type'
-import { Buffer } from 'buffer/'
+import { hexToBytes } from '@xrplf/isomorphic/utils'
 
 /**
  * BinaryParser is used to compute fields and values from a HexString
  */
 class BinaryParser {
-  private bytes: Buffer
+  private bytes: Uint8Array
   definitions: XrplDefinitionsBase
 
   /**
@@ -24,7 +24,7 @@ class BinaryParser {
     hexBytes: string,
     definitions: XrplDefinitionsBase = DEFAULT_DEFINITIONS,
   ) {
-    this.bytes = Buffer.from(hexBytes, 'hex')
+    this.bytes = hexToBytes(hexBytes)
     this.definitions = definitions
   }
 
@@ -58,7 +58,7 @@ class BinaryParser {
    * @param n The number of bytes to read
    * @return The bytes
    */
-  read(n: number): Buffer {
+  read(n: number): Uint8Array {
     if (n > this.bytes.byteLength) {
       throw new Error()
     }
@@ -107,7 +107,7 @@ class BinaryParser {
    *
    * @return The variable length bytes
    */
-  readVariableLength(): Buffer {
+  readVariableLength(): Uint8Array {
     return this.read(this.readVariableLengthLength())
   }
 

package/src/serdes/binary-serializer.ts

@@ -1,12 +1,12 @@
 import { FieldInstance } from '../enums'
 import { type SerializedType } from '../types/serialized-type'
-import { Buffer } from 'buffer/'
+import { bytesToHex, concat } from '@xrplf/isomorphic/utils'
 
 /**
- * Bytes list is a collection of buffer objects
+ * Bytes list is a collection of Uint8Array objects
  */
 class BytesList {
-  private bytesArray: Array<Buffer> = []
+  private bytesArray: Array<Uint8Array> = []
 
   /**
    * Get the total number of bytes in the BytesList
@@ -14,17 +14,17 @@ class BytesList {
    * @return the number of bytes
    */
   public getLength(): number {
-    return Buffer.concat(this.bytesArray).byteLength
+    return concat(this.bytesArray).byteLength
   }
 
   /**
    * Put bytes in the BytesList
    *
-   * @param bytesArg A Buffer
+   * @param bytesArg A Uint8Array
    * @return this BytesList
    */
-  public put(bytesArg: Buffer): BytesList {
-    const bytes = Buffer.from(bytesArg) // Temporary, to catch instances of Uint8Array being passed in
+  public put(bytesArg: Uint8Array): BytesList {
+    const bytes = Uint8Array.from(bytesArg) // Temporary, to catch instances of Uint8Array being passed in
     this.bytesArray.push(bytes)
     return this
   }
@@ -38,17 +38,17 @@ class BytesList {
     list.put(this.toBytes())
   }
 
-  public toBytes(): Buffer {
-    return Buffer.concat(this.bytesArray)
+  public toBytes(): Uint8Array {
+    return concat(this.bytesArray)
   }
 
   toHex(): string {
-    return this.toBytes().toString('hex').toUpperCase()
+    return bytesToHex(this.toBytes())
   }
 }
 
 /**
- * BinarySerializer is used to write fields and values to buffers
+ * BinarySerializer is used to write fields and values to Uint8Arrays
  */
 class BinarySerializer {
   private sink: BytesList = new BytesList()
@@ -71,7 +71,7 @@ class BinarySerializer {
    *
    * @param bytes the bytes to write
    */
-  put(bytes: Buffer): void {
+  put(bytes: Uint8Array): void {
     this.sink.put(bytes)
   }
 
@@ -99,8 +99,8 @@ class BinarySerializer {
    *
    * @param length the length of the bytes
    */
-  private encodeVariableLength(length: number): Buffer {
-    const lenBytes = Buffer.alloc(3)
+  private encodeVariableLength(length: number): Uint8Array {
+    const lenBytes = new Uint8Array(3)
     if (length <= 192) {
       lenBytes[0] = length
       return lenBytes.slice(0, 1)

package/src/shamap.ts

@@ -3,13 +3,12 @@ import { HashPrefix } from './hash-prefixes'
 import { Sha512Half } from './hashes'
 import { Hash256 } from './types/hash-256'
 import { BytesList } from './serdes/binary-serializer'
-import { Buffer } from 'buffer/'
 
 /**
  * Abstract class describing a SHAMapNode
  */
 abstract class ShaMapNode {
-  abstract hashPrefix(): Buffer
+  abstract hashPrefix(): Uint8Array
   abstract isLeaf(): boolean
   abstract isInner(): boolean
   abstract toBytesSink(list: BytesList): void
@@ -41,10 +40,10 @@ class ShaMapLeaf extends ShaMapNode {
   /**
    * Get the prefix of the this.item
    *
-   * @returns The hash prefix, unless this.item is undefined, then it returns an empty Buffer
+   * @returns The hash prefix, unless this.item is undefined, then it returns an empty Uint8Array
    */
-  hashPrefix(): Buffer {
-    return this.item === undefined ? Buffer.alloc(0) : this.item.hashPrefix()
+  hashPrefix(): Uint8Array {
+    return this.item === undefined ? new Uint8Array(0) : this.item.hashPrefix()
   }
 
   /**
@@ -100,7 +99,7 @@ class ShaMapInner extends ShaMapNode {
    *
    * @returns hash prefix describing an inner node
    */
-  hashPrefix(): Buffer {
+  hashPrefix(): Uint8Array {
     return HashPrefix.innerNode
   }
 

package/src/types/account-id.ts

@@ -5,7 +5,7 @@ import {
   xAddressToClassicAddress,
 } from 'ripple-address-codec'
 import { Hash160 } from './hash-160'
-import { Buffer } from 'buffer/'
+import { hexToBytes } from '@xrplf/isomorphic/utils'
 
 const HEX_REGEX = /^[A-F0-9]{40}$/
 
@@ -13,9 +13,11 @@ const HEX_REGEX = /^[A-F0-9]{40}$/
  * Class defining how to encode and decode an AccountID
  */
 class AccountID extends Hash160 {
-  static readonly defaultAccountID: AccountID = new AccountID(Buffer.alloc(20))
+  static readonly defaultAccountID: AccountID = new AccountID(
+    new Uint8Array(20),
+  )
 
-  constructor(bytes?: Buffer) {
+  constructor(bytes?: Uint8Array) {
     super(bytes ?? AccountID.defaultAccountID.bytes)
   }
 
@@ -36,7 +38,7 @@ class AccountID extends Hash160 {
       }
 
       return HEX_REGEX.test(value)
-        ? new AccountID(Buffer.from(value, 'hex'))
+        ? new AccountID(hexToBytes(value))
         : this.fromBase58(value)
     }
 
@@ -59,7 +61,7 @@ class AccountID extends Hash160 {
       value = classic.classicAddress
     }
 
-    return new AccountID(Buffer.from(decodeAccountID(value)))
+    return new AccountID(Uint8Array.from(decodeAccountID(value)))
   }
 
   /**
@@ -77,9 +79,7 @@ class AccountID extends Hash160 {
    * @returns the base58 string defined by this.bytes
    */
   toBase58(): string {
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    return encodeAccountID(this.bytes as any)
-    /* eslint-enable @typescript-eslint/no-explicit-any */
+    return encodeAccountID(this.bytes)
   }
 }
 

package/src/types/amount.ts

@@ -3,8 +3,9 @@ import { BinaryParser } from '../serdes/binary-parser'
 import { AccountID } from './account-id'
 import { Currency } from './currency'
 import { JsonObject, SerializedType } from './serialized-type'
-import { Buffer } from 'buffer/'
 import BigNumber from 'bignumber.js'
+import { bytesToHex, concat, hexToBytes } from '@xrplf/isomorphic/utils'
+import { readUInt32BE, writeUInt32BE } from '../utils'
 
 /**
  * Constants for validating amounts
@@ -52,11 +53,9 @@ function isAmountObject(arg): arg is AmountObject {
  * Class for serializing/Deserializing Amounts
  */
 class Amount extends SerializedType {
-  static defaultAmount: Amount = new Amount(
-    Buffer.from('4000000000000000', 'hex'),
-  )
+  static defaultAmount: Amount = new Amount(hexToBytes('4000000000000000'))
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? Amount.defaultAmount.bytes)
   }
 
@@ -72,17 +71,17 @@ class Amount extends SerializedType {
       return value
     }
 
-    let amount = Buffer.alloc(8)
+    let amount = new Uint8Array(8)
     if (typeof value === 'string') {
       Amount.assertXrpIsValid(value)
 
       const number = BigInt(value)
 
-      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
-      intBuf[0].writeUInt32BE(Number(number >> BigInt(32)), 0)
-      intBuf[1].writeUInt32BE(Number(number & BigInt(mask)), 0)
+      const intBuf = [new Uint8Array(4), new Uint8Array(4)]
+      writeUInt32BE(intBuf[0], Number(number >> BigInt(32)), 0)
+      writeUInt32BE(intBuf[1], Number(number & BigInt(mask)), 0)
 
-      amount = Buffer.concat(intBuf)
+      amount = concat(intBuf)
 
       amount[0] |= 0x40
 
@@ -102,11 +101,11 @@ class Amount extends SerializedType {
           .toString()
 
         const num = BigInt(integerNumberString)
-        const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
-        intBuf[0].writeUInt32BE(Number(num >> BigInt(32)), 0)
-        intBuf[1].writeUInt32BE(Number(num & BigInt(mask)), 0)
+        const intBuf = [new Uint8Array(4), new Uint8Array(4)]
+        writeUInt32BE(intBuf[0], Number(num >> BigInt(32)), 0)
+        writeUInt32BE(intBuf[1], Number(num & BigInt(mask)), 0)
 
-        amount = Buffer.concat(intBuf)
+        amount = concat(intBuf)
 
         amount[0] |= 0x80
 
@@ -122,7 +121,7 @@ class Amount extends SerializedType {
 
       const currency = Currency.from(value.currency).toBytes()
       const issuer = AccountID.from(value.issuer).toBytes()
-      return new Amount(Buffer.concat([amount, currency, issuer]))
+      return new Amount(concat([amount, currency, issuer]))
     }
 
     throw new Error('Invalid type to construct an Amount')
@@ -152,8 +151,8 @@ class Amount extends SerializedType {
       const sign = isPositive ? '' : '-'
       bytes[0] &= 0x3f
 
-      const msb = BigInt(bytes.slice(0, 4).readUInt32BE(0))
-      const lsb = BigInt(bytes.slice(4).readUInt32BE(0))
+      const msb = BigInt(readUInt32BE(bytes.slice(0, 4), 0))
+      const lsb = BigInt(readUInt32BE(bytes.slice(4), 0))
       const num = (msb << BigInt(32)) | lsb
 
       return `${sign}${num.toString()}`
@@ -172,7 +171,7 @@ class Amount extends SerializedType {
 
       mantissa[0] = 0
       mantissa[1] &= 0x3f
-      const value = new BigNumber(`${sign}0x${mantissa.toString('hex')}`).times(
+      const value = new BigNumber(`${sign}0x${bytesToHex(mantissa)}`).times(
         `1e${exponent}`,
       )
       Amount.assertIouIsValid(value)

package/src/types/blob.ts

@@ -1,12 +1,12 @@
 import { SerializedType } from './serialized-type'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { hexToBytes } from '@xrplf/isomorphic/utils'
 
 /**
  * Variable length encoded type
  */
 class Blob extends SerializedType {
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes)
   }
 
@@ -33,7 +33,7 @@ class Blob extends SerializedType {
     }
 
     if (typeof value === 'string') {
-      return new Blob(Buffer.from(value, 'hex'))
+      return new Blob(hexToBytes(value))
     }
 
     throw new Error('Cannot construct Blob from value given')

package/src/types/currency.ts

@@ -1,5 +1,5 @@
 import { Hash160 } from './hash-160'
-import { Buffer } from 'buffer/'
+import { bytesToHex, hexToBytes, hexToString } from '@xrplf/isomorphic/utils'
 
 const XRP_HEX_REGEX = /^0{40}$/
 const ISO_REGEX = /^[A-Z0-9a-z?!@#$%^&*(){}[\]|]{3}$/
@@ -10,8 +10,8 @@ const STANDARD_FORMAT_HEX_REGEX = /^0{24}[\x00-\x7F]{6}0{10}$/
 /**
  * Convert an ISO code to a currency bytes representation
  */
-function isoToBytes(iso: string): Buffer {
-  const bytes = Buffer.alloc(20)
+function isoToBytes(iso: string): Uint8Array {
+  const bytes = new Uint8Array(20)
   if (iso !== 'XRP') {
     const isoBytes = iso.split('').map((c) => c.charCodeAt(0))
     bytes.set(isoBytes, 12)
@@ -26,8 +26,8 @@ function isIsoCode(iso: string): boolean {
   return ISO_REGEX.test(iso)
 }
 
-function isoCodeFromHex(code: Buffer): string | null {
-  const iso = code.toString()
+function isoCodeFromHex(code: Uint8Array): string | null {
+  const iso = hexToString(bytesToHex(code))
   if (iso === 'XRP') {
     return null
   }
@@ -52,41 +52,41 @@ function isStringRepresentation(input: string): boolean {
 }
 
 /**
- * Tests if a Buffer is a valid representation of a currency
+ * Tests if a Uint8Array is a valid representation of a currency
  */
-function isBytesArray(bytes: Buffer): boolean {
+function isBytesArray(bytes: Uint8Array): boolean {
   return bytes.byteLength === 20
 }
 
 /**
  * Ensures that a value is a valid representation of a currency
  */
-function isValidRepresentation(input: Buffer | string): boolean {
-  return input instanceof Buffer
+function isValidRepresentation(input: Uint8Array | string): boolean {
+  return input instanceof Uint8Array
     ? isBytesArray(input)
     : isStringRepresentation(input)
 }
 
 /**
- * Generate bytes from a string or buffer representation of a currency
+ * Generate bytes from a string or UInt8Array representation of a currency
  */
-function bytesFromRepresentation(input: string): Buffer {
+function bytesFromRepresentation(input: string): Uint8Array {
   if (!isValidRepresentation(input)) {
     throw new Error(`Unsupported Currency representation: ${input}`)
   }
-  return input.length === 3 ? isoToBytes(input) : Buffer.from(input, 'hex')
+  return input.length === 3 ? isoToBytes(input) : hexToBytes(input)
 }
 
 /**
  * Class defining how to encode and decode Currencies
  */
 class Currency extends Hash160 {
-  static readonly XRP = new Currency(Buffer.alloc(20))
+  static readonly XRP = new Currency(new Uint8Array(20))
   private readonly _iso: string | null
 
-  constructor(byteBuf: Buffer) {
+  constructor(byteBuf: Uint8Array) {
     super(byteBuf ?? Currency.XRP.bytes)
-    const hex = this.bytes.toString('hex')
+    const hex = bytesToHex(this.bytes)
 
     if (XRP_HEX_REGEX.test(hex)) {
       this._iso = 'XRP'
@@ -133,7 +133,7 @@ class Currency extends Hash160 {
     if (iso !== null) {
       return iso
     }
-    return this.bytes.toString('hex').toUpperCase()
+    return bytesToHex(this.bytes)
   }
 }
 

package/src/types/hash-128.ts

@@ -1,14 +1,14 @@
 import { Hash } from './hash'
-import { Buffer } from 'buffer/'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
 
 /**
  * Hash with a width of 128 bits
  */
 class Hash128 extends Hash {
   static readonly width = 16
-  static readonly ZERO_128: Hash128 = new Hash128(Buffer.alloc(Hash128.width))
+  static readonly ZERO_128: Hash128 = new Hash128(new Uint8Array(Hash128.width))
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     if (bytes && bytes.byteLength === 0) {
       bytes = Hash128.ZERO_128.bytes
     }
@@ -22,7 +22,7 @@ class Hash128 extends Hash {
    * @returns hex String of this.bytes
    */
   toHex(): string {
-    const hex = this.toBytes().toString('hex').toUpperCase()
+    const hex = bytesToHex(this.toBytes())
     if (/^0+$/.exec(hex)) {
       return ''
     }

package/src/types/hash-160.ts

@@ -1,14 +1,13 @@
 import { Hash } from './hash'
-import { Buffer } from 'buffer/'
 
 /**
  * Hash with a width of 160 bits
  */
 class Hash160 extends Hash {
   static readonly width = 20
-  static readonly ZERO_160: Hash160 = new Hash160(Buffer.alloc(Hash160.width))
+  static readonly ZERO_160: Hash160 = new Hash160(new Uint8Array(Hash160.width))
 
-  constructor(bytes?: Buffer) {
+  constructor(bytes?: Uint8Array) {
     if (bytes && bytes.byteLength === 0) {
       bytes = Hash160.ZERO_160.bytes
     }

package/src/types/hash-256.ts

@@ -1,14 +1,13 @@
 import { Hash } from './hash'
-import { Buffer } from 'buffer/'
 
 /**
  * Hash with a width of 256 bits
  */
 class Hash256 extends Hash {
   static readonly width = 32
-  static readonly ZERO_256 = new Hash256(Buffer.alloc(Hash256.width))
+  static readonly ZERO_256 = new Hash256(new Uint8Array(Hash256.width))
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? Hash256.ZERO_256.bytes)
   }
 }