ripple-binary-codec 1.11.0 → 2.0.0-beta.1

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,20 +1,21 @@
 import { UInt } from './uint'
 import { BinaryParser } from '../serdes/binary-parser'
-import bigInt = require('big-integer')
-import { isInstance } from 'big-integer'
-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)
+const mask = BigInt(0x00000000ffffffff)
 
 /**
  * Derived UInt class for serializing/deserializing 64 bit UInt
  */
 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)
   }
 
@@ -28,27 +29,25 @@ class UInt64 extends UInt {
    * @param val A UInt64, hex-string, bigInt, or number
    * @returns A UInt64 object
    */
-  static from<T extends UInt64 | string | bigInt.BigInteger | number>(
-    val: T,
-  ): UInt64 {
+  static from<T extends UInt64 | string | bigint | number>(val: T): UInt64 {
     if (val instanceof UInt64) {
       return val
     }
 
-    let buf = Buffer.alloc(UInt64.width)
+    let buf = new Uint8Array(UInt64.width)
 
     if (typeof val === 'number') {
       if (val < 0) {
         throw new Error('value must be an unsigned integer')
       }
 
-      const number = bigInt(val)
+      const number = BigInt(val)
 
-      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
-      intBuf[0].writeUInt32BE(Number(number.shiftRight(32)), 0)
-      intBuf[1].writeUInt32BE(Number(number.and(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') {
@@ -57,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 (isInstance(val)) {
-      const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]
-      intBuf[0].writeUInt32BE(Number(val.shiftRight(bigInt(32))), 0)
-      intBuf[1].writeUInt32BE(Number(val.and(mask)), 0)
+    if (typeof val === 'bigint') {
+      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')
@@ -78,7 +77,7 @@ class UInt64 extends UInt {
    * @returns a hex-string
    */
   toJSON(): string {
-    return this.bytes.toString('hex').toUpperCase()
+    return bytesToHex(this.bytes)
   }
 
   /**
@@ -86,10 +85,10 @@ class UInt64 extends UInt {
    *
    * @returns the number represented buy this.bytes
    */
-  valueOf(): bigInt.BigInteger {
-    const msb = bigInt(this.bytes.slice(0, 4).readUInt32BE(0))
-    const lsb = bigInt(this.bytes.slice(4).readUInt32BE(0))
-    return msb.shiftLeft(bigInt(32)).or(lsb)
+  valueOf(): bigint {
+    const msb = BigInt(readUInt32BE(this.bytes.slice(0, 4), 0))
+    const lsb = BigInt(readUInt32BE(this.bytes.slice(4), 0))
+    return (msb << BigInt(32)) | lsb
   }
 
   /**
@@ -97,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,6 +1,4 @@
-import bigInt = require('big-integer')
 import { Comparable } from './serialized-type'
-import { Buffer } from 'buffer/'
 
 /**
  * Compare numbers and bigInts n1 and n2
@@ -9,20 +7,17 @@ import { Buffer } from 'buffer/'
  * @param n2 Second object to compare
  * @returns -1, 0, or 1, depending on how the two objects compare
  */
-function compare(
-  n1: number | bigInt.BigInteger,
-  n2: number | bigInt.BigInteger,
-): number {
+function compare(n1: number | bigint, n2: number | bigint): number {
   return n1 < n2 ? -1 : n1 == n2 ? 0 : 1
 }
 
 /**
  * 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)
   }
 
@@ -32,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())
   }
 
@@ -51,7 +46,15 @@ abstract class UInt extends Comparable {
    *
    * @returns the value
    */
-  abstract valueOf(): number | bigInt.BigInteger
+  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
   }

package/src/types/xchain-bridge.ts

@@ -2,8 +2,8 @@ import { BinaryParser } from '../serdes/binary-parser'
 
 import { AccountID } from './account-id'
 import { JsonObject, SerializedType } from './serialized-type'
-import { Buffer } from 'buffer/'
 import { Issue, IssueObject } from './issue'
+import { concat } from '@xrplf/isomorphic/utils'
 
 /**
  * Interface for JSON objects that represent cross-chain bridges
@@ -34,11 +34,11 @@ function isXChainBridgeObject(arg): arg is XChainBridgeObject {
  */
 class XChainBridge extends SerializedType {
   static readonly ZERO_XCHAIN_BRIDGE: XChainBridge = new XChainBridge(
-    Buffer.concat([
-      Buffer.from([0x14]),
-      Buffer.alloc(40),
-      Buffer.from([0x14]),
-      Buffer.alloc(40),
+    concat([
+      Uint8Array.from([0x14]),
+      new Uint8Array(40),
+      Uint8Array.from([0x14]),
+      new Uint8Array(40),
     ]),
   )
 
@@ -50,7 +50,7 @@ class XChainBridge extends SerializedType {
       { name: 'IssuingChainIssue', type: Issue },
     ]
 
-  constructor(bytes: Buffer) {
+  constructor(bytes: Uint8Array) {
     super(bytes ?? XChainBridge.ZERO_XCHAIN_BRIDGE.bytes)
   }
 
@@ -71,16 +71,16 @@ class XChainBridge extends SerializedType {
       throw new Error('Invalid type to construct an XChainBridge')
     }
 
-    const bytes: Array<Buffer> = []
+    const bytes: Array<Uint8Array> = []
     this.TYPE_ORDER.forEach((item) => {
       const { name, type } = item
       if (type === AccountID) {
-        bytes.push(Buffer.from([0x14]))
+        bytes.push(Uint8Array.from([0x14]))
       }
       const object = type.from(value[name])
       bytes.push(object.toBytes())
     })
-    return new XChainBridge(Buffer.concat(bytes))
+    return new XChainBridge(concat(bytes))
   }
 
   /**
@@ -90,19 +90,19 @@ class XChainBridge extends SerializedType {
    * @returns An XChainBridge object
    */
   static fromParser(parser: BinaryParser): XChainBridge {
-    const bytes: Array<Buffer> = []
+    const bytes: Array<Uint8Array> = []
 
     this.TYPE_ORDER.forEach((item) => {
       const { type } = item
       if (type === AccountID) {
         parser.skip(1)
-        bytes.push(Buffer.from([0x14]))
+        bytes.push(Uint8Array.from([0x14]))
       }
       const object = type.fromParser(parser)
       bytes.push(object.toBytes())
     })
 
-    return new XChainBridge(Buffer.concat(bytes))
+    return new XChainBridge(concat(bytes))
   }
 
   /**

package/src/utils.ts

@@ -0,0 +1,152 @@
+// Even though this comes from NodeJS it is valid in the browser
+import TypedArray = NodeJS.TypedArray
+
+/**
+ * Writes value to array at the specified offset. The value must be a valid unsigned 8-bit integer.
+ * @param array Uint8Array to be written to
+ * @param value Number to be written to array.
+ * @param offset plus the number of bytes written.
+ */
+export function writeUInt8(
+  array: Uint8Array,
+  value: number,
+  offset: number,
+): void {
+  value = Number(value)
+  array[offset] = value
+}
+
+/**
+ * Writes value to array at the specified offset as big-endian. The value must be a valid unsigned 16-bit integer.
+ * @param array Uint8Array to be written to
+ * @param value Number to be written to array.
+ * @param offset plus the number of bytes written.
+ */
+export function writeUInt16BE(
+  array: Uint8Array,
+  value: number,
+  offset: number,
+): void {
+  value = Number(value)
+
+  array[offset] = value >>> 8
+  array[offset + 1] = value
+}
+
+/**
+ * Writes value to array at the specified offset as big-endian. The value must be a valid unsigned 32-bit integer.
+ * @param array Uint8Array to be written to
+ * @param value Number to be written to array.
+ * @param offset plus the number of bytes written.
+ */
+export function writeUInt32BE(
+  array: Uint8Array,
+  value: number,
+  offset: number,
+): void {
+  array[offset] = (value >>> 24) & 0xff
+  array[offset + 1] = (value >>> 16) & 0xff
+  array[offset + 2] = (value >>> 8) & 0xff
+  array[offset + 3] = value & 0xff
+}
+
+/**
+ * Reads an unsigned, big-endian 16-bit integer from the array at the specified offset.
+ * @param array Uint8Array to read
+ * @param offset Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - 2
+ */
+export function readUInt16BE(array: Uint8Array, offset: number): string {
+  return new DataView(array.buffer).getUint16(offset, false).toString(10)
+}
+
+/**
+ * Reads an unsigned, big-endian 16-bit integer from the array at the specified offset.
+ * @param array Uint8Array to read
+ * @param offset Number of bytes to skip before starting to read. Must satisfy 0 <= offset <= buf.length - 4
+ */
+export function readUInt32BE(array: Uint8Array, offset: number): string {
+  return new DataView(array.buffer).getUint32(offset, false).toString(10)
+}
+
+/**
+ * Compares two Uint8Array or ArrayBuffers
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+export function equal(
+  a: Uint8Array | ArrayBuffer,
+  b: Uint8Array | ArrayBuffer,
+): boolean {
+  const aUInt = a instanceof ArrayBuffer ? new Uint8Array(a, 0) : a
+  const bUInt = b instanceof ArrayBuffer ? new Uint8Array(b, 0) : b
+  if (aUInt.byteLength != bUInt.byteLength) return false
+  if (aligned32(aUInt) && aligned32(bUInt)) return compare32(aUInt, bUInt) === 0
+  if (aligned16(aUInt) && aligned16(bUInt)) return compare16(aUInt, bUInt) === 0
+  return compare8(aUInt, bUInt) === 0
+}
+
+/**
+ * Compares two 8 bit aligned arrays
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+function compare8(a, b) {
+  const ua = new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
+  const ub = new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+  return compare(ua, ub)
+}
+
+/**
+ * Compares two 16 bit aligned arrays
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+function compare16(a: Uint8Array, b: Uint8Array) {
+  const ua = new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2)
+  const ub = new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
+  return compare(ua, ub)
+}
+
+/**
+ * Compares two 32 bit aligned arrays
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+function compare32(a: Uint8Array, b: Uint8Array) {
+  const ua = new Uint32Array(a.buffer, a.byteOffset, a.byteLength / 4)
+  const ub = new Uint32Array(b.buffer, b.byteOffset, b.byteLength / 4)
+  return compare(ua, ub)
+}
+
+/**
+ * Compare two TypedArrays
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+export function compare(a: TypedArray, b: TypedArray): 1 | -1 | 0 {
+  if (a.byteLength !== b.byteLength) {
+    throw new Error('Cannot compare arrays of different length')
+  }
+
+  for (let i = 0; i < a.length - 1; i += 1) {
+    if (a[i] > b[i]) return 1
+    if (a[i] < b[i]) return -1
+  }
+  return 0
+}
+
+/**
+ * Determine if TypedArray is 16 bit aligned
+ * @param array The array to check
+ */
+function aligned16(array: TypedArray) {
+  return array.byteOffset % 2 === 0 && array.byteLength % 2 === 0
+}
+
+/**
+ * Determine if TypedArray is 32 bit aligned
+ * @param array The array to check
+ */
+function aligned32(array: TypedArray) {
+  return array.byteOffset % 4 === 0 && array.byteLength % 4 === 0
+}