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

package/src/types/hash.ts

@@ -1,16 +1,17 @@
 import { Comparable } from './serialized-type'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { hexToBytes } from '@xrplf/isomorphic/utils'
+import { compare } from '../utils'
 
 /**
  * Base class defining how to encode and decode hashes
  */
-class Hash extends Comparable {
+class Hash extends Comparable<Hash | string> {
   static readonly width: number
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes)
-    if (this.bytes.byteLength !== (this.constructor as typeof Hash).width) {
+    if (this.bytes.length !== (this.constructor as typeof Hash).width) {
       throw new Error(`Invalid Hash length ${this.bytes.byteLength}`)
     }
   }
@@ -26,7 +27,7 @@ class Hash extends Comparable {
     }
 
     if (typeof value === 'string') {
-      return new this(Buffer.from(value, 'hex'))
+      return new this(hexToBytes(value))
     }
 
     throw new Error('Cannot construct Hash from given value')
@@ -48,7 +49,8 @@ class Hash extends Comparable {
    * @param other The Hash to compare this to
    */
   compareTo(other: Hash): number {
-    return this.bytes.compare(
+    return compare(
+      this.bytes,
       (this.constructor as typeof Hash).from(other).bytes,
     )
   }

package/src/types/issue.ts

@@ -1,9 +1,9 @@
+import { concat } from '@xrplf/isomorphic/utils'
 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/'
 
 /**
  * Interface for JSON objects that represent amounts
@@ -28,9 +28,9 @@ function isIssueObject(arg): arg is IssueObject {
  * Class for serializing/Deserializing Amounts
  */
 class Issue extends SerializedType {
-  static readonly ZERO_ISSUED_CURRENCY: Issue = new Issue(Buffer.alloc(20))
+  static readonly ZERO_ISSUED_CURRENCY: Issue = new Issue(new Uint8Array(20))
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? Issue.ZERO_ISSUED_CURRENCY.bytes)
   }
 
@@ -52,7 +52,7 @@ class Issue extends SerializedType {
         return new Issue(currency)
       }
       const issuer = AccountID.from(value.issuer).toBytes()
-      return new Issue(Buffer.concat([currency, issuer]))
+      return new Issue(concat([currency, issuer]))
     }
 
     throw new Error('Invalid type to construct an Amount')
@@ -70,7 +70,7 @@ class Issue extends SerializedType {
       return new Issue(currency)
     }
     const currencyAndIssuer = [currency, parser.read(20)]
-    return new Issue(Buffer.concat(currencyAndIssuer))
+    return new Issue(concat(currencyAndIssuer))
   }
 
   /**

package/src/types/path-set.ts

@@ -2,7 +2,7 @@ import { AccountID } from './account-id'
 import { Currency } from './currency'
 import { BinaryParser } from '../serdes/binary-parser'
 import { SerializedType, JsonObject } from './serialized-type'
-import { Buffer } from 'buffer/'
+import { bytesToHex, concat } from '@xrplf/isomorphic/utils'
 
 /**
  * Constants for separating Paths in a PathSet
@@ -63,7 +63,7 @@ class Hop extends SerializedType {
       return value
     }
 
-    const bytes: Array<Buffer> = [Buffer.from([0])]
+    const bytes: Array<Uint8Array> = [Uint8Array.from([0])]
 
     if (value.account) {
       bytes.push(AccountID.from(value.account).toBytes())
@@ -80,7 +80,7 @@ class Hop extends SerializedType {
       bytes[0][0] |= TYPE_ISSUER
     }
 
-    return new Hop(Buffer.concat(bytes))
+    return new Hop(concat(bytes))
   }
 
   /**
@@ -91,7 +91,7 @@ class Hop extends SerializedType {
    */
   static fromParser(parser: BinaryParser): Hop {
     const type = parser.readUInt8()
-    const bytes: Array<Buffer> = [Buffer.from([type])]
+    const bytes: Array<Uint8Array> = [Uint8Array.from([type])]
 
     if (type & TYPE_ACCOUNT) {
       bytes.push(parser.read(AccountID.width))
@@ -105,7 +105,7 @@ class Hop extends SerializedType {
       bytes.push(parser.read(AccountID.width))
     }
 
-    return new Hop(Buffer.concat(bytes))
+    return new Hop(concat(bytes))
   }
 
   /**
@@ -114,7 +114,7 @@ class Hop extends SerializedType {
    * @returns a HopObject, an JS object with optional account, issuer, and currency
    */
   toJSON(): HopObject {
-    const hopParser = new BinaryParser(this.bytes.toString('hex'))
+    const hopParser = new BinaryParser(bytesToHex(this.bytes))
     const type = hopParser.readUInt8()
 
     let account, currency, issuer
@@ -171,12 +171,12 @@ class Path extends SerializedType {
       return value
     }
 
-    const bytes: Array<Buffer> = []
+    const bytes: Array<Uint8Array> = []
     value.forEach((hop: HopObject) => {
       bytes.push(Hop.from(hop).toBytes())
     })
 
-    return new Path(Buffer.concat(bytes))
+    return new Path(concat(bytes))
   }
 
   /**
@@ -186,7 +186,7 @@ class Path extends SerializedType {
    * @returns the Path represented by the bytes read from the BinaryParser
    */
   static fromParser(parser: BinaryParser): Path {
-    const bytes: Array<Buffer> = []
+    const bytes: Array<Uint8Array> = []
     while (!parser.end()) {
       bytes.push(Hop.fromParser(parser).toBytes())
 
@@ -197,7 +197,7 @@ class Path extends SerializedType {
         break
       }
     }
-    return new Path(Buffer.concat(bytes))
+    return new Path(concat(bytes))
   }
 
   /**
@@ -233,16 +233,16 @@ class PathSet extends SerializedType {
     }
 
     if (isPathSet(value)) {
-      const bytes: Array<Buffer> = []
+      const bytes: Array<Uint8Array> = []
 
       value.forEach((path: Array<HopObject>) => {
         bytes.push(Path.from(path).toBytes())
-        bytes.push(Buffer.from([PATH_SEPARATOR_BYTE]))
+        bytes.push(Uint8Array.from([PATH_SEPARATOR_BYTE]))
       })
 
-      bytes[bytes.length - 1] = Buffer.from([PATHSET_END_BYTE])
+      bytes[bytes.length - 1] = Uint8Array.from([PATHSET_END_BYTE])
 
-      return new PathSet(Buffer.concat(bytes))
+      return new PathSet(concat(bytes))
     }
 
     throw new Error('Cannot construct PathSet from given value')
@@ -255,7 +255,7 @@ class PathSet extends SerializedType {
    * @returns the PathSet read from parser
    */
   static fromParser(parser: BinaryParser): PathSet {
-    const bytes: Array<Buffer> = []
+    const bytes: Array<Uint8Array> = []
 
     while (!parser.end()) {
       bytes.push(Path.fromParser(parser).toBytes())
@@ -266,7 +266,7 @@ class PathSet extends SerializedType {
       }
     }
 
-    return new PathSet(Buffer.concat(bytes))
+    return new PathSet(concat(bytes))
   }
 
   /**

package/src/types/serialized-type.ts

@@ -1,7 +1,7 @@
 import { BytesList } from '../serdes/binary-serializer'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
 import { XrplDefinitionsBase } from '../enums'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
 
 type JSON = string | number | boolean | null | undefined | JSON[] | JsonObject
 
@@ -11,10 +11,10 @@ type JsonObject = { [key: string]: JSON }
  * The base class for all binary-codec types
  */
 class SerializedType {
-  protected readonly bytes: Buffer = Buffer.alloc(0)
+  protected readonly bytes: Uint8Array = new Uint8Array(0)
 
-  constructor(bytes: Buffer) {
-    this.bytes = bytes ?? Buffer.alloc(0)
+  constructor(bytes?: Uint8Array) {
+    this.bytes = bytes ?? new Uint8Array(0)
   }
 
   static fromParser(parser: BinaryParser, hint?: number): SerializedType {
@@ -42,15 +42,15 @@ class SerializedType {
    * @returns hex String of this.bytes
    */
   toHex(): string {
-    return this.toBytes().toString('hex').toUpperCase()
+    return bytesToHex(this.toBytes())
   }
 
   /**
    * Get the bytes representation of a SerializedType
    *
-   * @returns A buffer of the bytes
+   * @returns A Uint8Array of the bytes
    */
-  toBytes(): Buffer {
+  toBytes(): Uint8Array {
     if (this.bytes) {
       return this.bytes
     }
@@ -80,26 +80,31 @@ class SerializedType {
 }
 
 /**
- * Base class for SerializedTypes that are comparable
+ * Base class for SerializedTypes that are comparable.
+ *
+ * @template T - What types you want to allow comparisons between. You must specify all types. Primarily used to allow
+ * comparisons between built-in types (like `string`) and SerializedType subclasses (like `Hash`).
+ *
+ * Ex. `class Hash extends Comparable<Hash | string>`
  */
-class Comparable extends SerializedType {
-  lt(other: Comparable): boolean {
+class Comparable<T extends Object> extends SerializedType {
+  lt(other: T): boolean {
     return this.compareTo(other) < 0
   }
 
-  eq(other: Comparable): boolean {
+  eq(other: T): boolean {
     return this.compareTo(other) === 0
   }
 
-  gt(other: Comparable): boolean {
+  gt(other: T): boolean {
     return this.compareTo(other) > 0
   }
 
-  gte(other: Comparable): boolean {
+  gte(other: T): boolean {
     return this.compareTo(other) > -1
   }
 
-  lte(other: Comparable): boolean {
+  lte(other: T): boolean {
     return this.compareTo(other) < 1
   }
 
@@ -109,7 +114,7 @@ class Comparable extends SerializedType {
    * @param other The comparable object to compare this to
    * @returns A number denoting the relationship of this and other
    */
-  compareTo(other: Comparable): number {
+  compareTo(other: T): number {
     throw new Error(`cannot compare ${this.toString()} and ${other.toString()}`)
   }
 }

package/src/types/st-array.ts

@@ -2,12 +2,12 @@ import { DEFAULT_DEFINITIONS, XrplDefinitionsBase } from '../enums'
 import { SerializedType, JsonObject } from './serialized-type'
 import { STObject } from './st-object'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { concat } from '@xrplf/isomorphic/utils'
 
-const ARRAY_END_MARKER = Buffer.from([0xf1])
+const ARRAY_END_MARKER = Uint8Array.from([0xf1])
 const ARRAY_END_MARKER_NAME = 'ArrayEndMarker'
 
-const OBJECT_END_MARKER = Buffer.from([0xe1])
+const OBJECT_END_MARKER = Uint8Array.from([0xe1])
 
 /**
  * TypeGuard for Array<JsonObject>
@@ -29,7 +29,7 @@ class STArray extends SerializedType {
    * @returns An STArray Object
    */
   static fromParser(parser: BinaryParser): STArray {
-    const bytes: Array<Buffer> = []
+    const bytes: Array<Uint8Array> = []
 
     while (!parser.end()) {
       const field = parser.readField()
@@ -45,7 +45,7 @@ class STArray extends SerializedType {
     }
 
     bytes.push(ARRAY_END_MARKER)
-    return new STArray(Buffer.concat(bytes))
+    return new STArray(concat(bytes))
   }
 
   /**
@@ -64,13 +64,13 @@ class STArray extends SerializedType {
     }
 
     if (isObjects(value)) {
-      const bytes: Array<Buffer> = []
+      const bytes: Array<Uint8Array> = []
       value.forEach((obj) => {
         bytes.push(STObject.from(obj, undefined, definitions).toBytes())
       })
 
       bytes.push(ARRAY_END_MARKER)
-      return new STArray(Buffer.concat(bytes))
+      return new STArray(concat(bytes))
     }
 
     throw new Error('Cannot construct STArray from value given')

package/src/types/st-object.ts

@@ -8,10 +8,10 @@ import { SerializedType, JsonObject } from './serialized-type'
 import { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'
 import { BinaryParser } from '../serdes/binary-parser'
 import { BinarySerializer, BytesList } from '../serdes/binary-serializer'
-import { Buffer } from 'buffer/'
+
 import { STArray } from './st-array'
 
-const OBJECT_END_MARKER_BYTE = Buffer.from([0xe1])
+const OBJECT_END_MARKER_BYTE = Uint8Array.from([0xe1])
 const OBJECT_END_MARKER = 'ObjectEndMarker'
 const ST_OBJECT = 'STObject'
 const DESTINATION = 'Destination'

package/src/types/uint-16.ts

@@ -1,15 +1,17 @@
 import { UInt } from './uint'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { readUInt16BE, writeUInt16BE } from '../utils'
 
 /**
  * Derived UInt class for serializing/deserializing 16 bit UInt
  */
 class UInt16 extends UInt {
   protected static readonly width: number = 16 / 8 // 2
-  static readonly defaultUInt16: UInt16 = new UInt16(Buffer.alloc(UInt16.width))
+  static readonly defaultUInt16: UInt16 = new UInt16(
+    new Uint8Array(UInt16.width),
+  )
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? UInt16.defaultUInt16.bytes)
   }
 
@@ -28,8 +30,10 @@ class UInt16 extends UInt {
     }
 
     if (typeof val === 'number') {
-      const buf = Buffer.alloc(UInt16.width)
-      buf.writeUInt16BE(val, 0)
+      UInt16.checkUintRange(val, 0, 0xffff)
+
+      const buf = new Uint8Array(UInt16.width)
+      writeUInt16BE(buf, val, 0)
       return new UInt16(buf)
     }
 
@@ -42,7 +46,7 @@ class UInt16 extends UInt {
    * @returns the number represented by this.bytes
    */
   valueOf(): number {
-    return this.bytes.readUInt16BE(0)
+    return parseInt(readUInt16BE(this.bytes, 0))
   }
 }
 

package/src/types/uint-32.ts

@@ -1,15 +1,17 @@
 import { UInt } from './uint'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { readUInt32BE, writeUInt32BE } from '../utils'
 
 /**
  * Derived UInt class for serializing/deserializing 32 bit UInt
  */
 class UInt32 extends UInt {
   protected static readonly width: number = 32 / 8 // 4
-  static readonly defaultUInt32: UInt32 = new UInt32(Buffer.alloc(UInt32.width))
+  static readonly defaultUInt32: UInt32 = new UInt32(
+    new Uint8Array(UInt32.width),
+  )
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? UInt32.defaultUInt32.bytes)
   }
 
@@ -27,16 +29,17 @@ class UInt32 extends UInt {
       return val
     }
 
-    const buf = Buffer.alloc(UInt32.width)
+    const buf = new Uint8Array(UInt32.width)
 
     if (typeof val === 'string') {
       const num = Number.parseInt(val)
-      buf.writeUInt32BE(num, 0)
+      writeUInt32BE(buf, num, 0)
       return new UInt32(buf)
     }
 
     if (typeof val === 'number') {
-      buf.writeUInt32BE(val, 0)
+      UInt32.checkUintRange(val, 0, 0xffffffff)
+      writeUInt32BE(buf, val, 0)
       return new UInt32(buf)
     }
 
@@ -49,7 +52,7 @@ class UInt32 extends UInt {
    * @returns the number represented by this.bytes
    */
   valueOf(): number {
-    return this.bytes.readUInt32BE(0)
+    return parseInt(readUInt32BE(this.bytes, 0), 10)
   }
 }
 

package/src/types/uint-64.ts

@@ -1,6 +1,7 @@
 import { UInt } from './uint'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { bytesToHex, concat, hexToBytes } from '@xrplf/isomorphic/utils'
+import { readUInt32BE, writeUInt32BE } from '../utils'
 
 const HEX_REGEX = /^[a-fA-F0-9]{1,16}$/
 const mask = BigInt(0x00000000ffffffff)
@@ -10,9 +11,11 @@ const mask = BigInt(0x00000000ffffffff)
  */
 class UInt64 extends UInt {
   protected static readonly width: number = 64 / 8 // 8
-  static readonly defaultUInt64: UInt64 = new UInt64(Buffer.alloc(UInt64.width))
+  static readonly defaultUInt64: UInt64 = new UInt64(
+    new Uint8Array(UInt64.width),
+  )
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? UInt64.defaultUInt64.bytes)
   }
 
@@ -31,7 +34,7 @@ class UInt64 extends UInt {
       return val
     }
 
-    let buf = Buffer.alloc(UInt64.width)
+    let buf = new Uint8Array(UInt64.width)
 
     if (typeof val === 'number') {
       if (val < 0) {
@@ -40,11 +43,11 @@ class UInt64 extends UInt {
 
       const number = BigInt(val)
 
-      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)
 
-      return new UInt64(Buffer.concat(intBuf))
+      return new UInt64(concat(intBuf))
     }
 
     if (typeof val === 'string') {
@@ -53,16 +56,16 @@ class UInt64 extends UInt {
       }
 
       const strBuf = val.padStart(16, '0')
-      buf = Buffer.from(strBuf, 'hex')
+      buf = hexToBytes(strBuf)
       return new UInt64(buf)
     }
 
     if (typeof val === 'bigint') {
-      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
-      intBuf[0].writeUInt32BE(Number(val >> BigInt(32)), 0)
-      intBuf[1].writeUInt32BE(Number(val & BigInt(mask)), 0)
+      const intBuf = [new Uint8Array(4), new Uint8Array(4)]
+      writeUInt32BE(intBuf[0], Number(Number(val >> BigInt(32))), 0)
+      writeUInt32BE(intBuf[1], Number(val & BigInt(mask)), 0)
 
-      return new UInt64(Buffer.concat(intBuf))
+      return new UInt64(concat(intBuf))
     }
 
     throw new Error('Cannot construct UInt64 from given value')
@@ -74,7 +77,7 @@ class UInt64 extends UInt {
    * @returns a hex-string
    */
   toJSON(): string {
-    return this.bytes.toString('hex').toUpperCase()
+    return bytesToHex(this.bytes)
   }
 
   /**
@@ -83,8 +86,8 @@ class UInt64 extends UInt {
    * @returns the number represented buy this.bytes
    */
   valueOf(): bigint {
-    const msb = BigInt(this.bytes.slice(0, 4).readUInt32BE(0))
-    const lsb = BigInt(this.bytes.slice(4).readUInt32BE(0))
+    const msb = BigInt(readUInt32BE(this.bytes.slice(0, 4), 0))
+    const lsb = BigInt(readUInt32BE(this.bytes.slice(4), 0))
     return (msb << BigInt(32)) | lsb
   }
 
@@ -93,7 +96,7 @@ class UInt64 extends UInt {
    *
    * @returns 8 bytes representing the UInt64
    */
-  toBytes(): Buffer {
+  toBytes(): Uint8Array {
     return this.bytes
   }
 }

package/src/types/uint-8.ts

@@ -1,15 +1,16 @@
 import { UInt } from './uint'
 import { BinaryParser } from '../serdes/binary-parser'
-import { Buffer } from 'buffer/'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
+import { writeUInt8 } from '../utils'
 
 /**
  * Derived UInt class for serializing/deserializing 8 bit UInt
  */
 class UInt8 extends UInt {
   protected static readonly width: number = 8 / 8 // 1
-  static readonly defaultUInt8: UInt8 = new UInt8(Buffer.alloc(UInt8.width))
+  static readonly defaultUInt8: UInt8 = new UInt8(new Uint8Array(UInt8.width))
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? UInt8.defaultUInt8.bytes)
   }
 
@@ -28,8 +29,10 @@ class UInt8 extends UInt {
     }
 
     if (typeof val === 'number') {
-      const buf = Buffer.alloc(UInt8.width)
-      buf.writeUInt8(val, 0)
+      UInt8.checkUintRange(val, 0, 0xff)
+
+      const buf = new Uint8Array(UInt8.width)
+      writeUInt8(buf, val, 0)
       return new UInt8(buf)
     }
 
@@ -42,7 +45,7 @@ class UInt8 extends UInt {
    * @returns the number represented by this.bytes
    */
   valueOf(): number {
-    return this.bytes.readUInt8(0)
+    return parseInt(bytesToHex(this.bytes), 16)
   }
 }
 

package/src/types/uint.ts

@@ -1,5 +1,4 @@
 import { Comparable } from './serialized-type'
-import { Buffer } from 'buffer/'
 
 /**
  * Compare numbers and bigInts n1 and n2
@@ -15,10 +14,10 @@ function compare(n1: number | bigint, n2: number | bigint): number {
 /**
  * Base class for serializing and deserializing unsigned integers.
  */
-abstract class UInt extends Comparable {
+abstract class UInt extends Comparable<UInt | number> {
   protected static width: number
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes)
   }
 
@@ -28,7 +27,7 @@ abstract class UInt extends Comparable {
    * @param other other UInt to compare this to
    * @returns -1, 0, or 1 depending on how the objects relate to each other
    */
-  compareTo(other: UInt): number {
+  compareTo(other: UInt | number): number {
     return compare(this.valueOf(), other.valueOf())
   }
 
@@ -48,6 +47,14 @@ abstract class UInt extends Comparable {
    * @returns the value
    */
   abstract valueOf(): number | bigint
+
+  static checkUintRange(val: number, min: number, max: number): void {
+    if (val < min || val > max) {
+      throw new Error(
+        `Invalid ${this.constructor.name}: ${val} must be >= ${min} and <= ${max}`,
+      )
+    }
+  }
 }
 
 export { UInt }

package/src/types/vector-256.ts

@@ -2,7 +2,7 @@ import { SerializedType } from './serialized-type'
 import { BinaryParser } from '../serdes/binary-parser'
 import { Hash256 } from './hash-256'
 import { BytesList } from '../serdes/binary-serializer'
-import { Buffer } from 'buffer/'
+import { bytesToHex } from '@xrplf/isomorphic/utils'
 
 /**
  * TypeGuard for Array<string>
@@ -15,7 +15,7 @@ function isStrings(arg): arg is Array<string> {
  * Class for serializing and deserializing vectors of Hash256
  */
 class Vector256 extends SerializedType {
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes)
   }
 
@@ -70,12 +70,7 @@ class Vector256 extends SerializedType {
 
     const result: Array<string> = []
     for (let i = 0; i < this.bytes.byteLength; i += 32) {
-      result.push(
-        this.bytes
-          .slice(i, i + 32)
-          .toString('hex')
-          .toUpperCase(),
-      )
+      result.push(bytesToHex(this.bytes.slice(i, i + 32)))
     }
     return result
   }