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

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)
   }
 
@@ -67,20 +67,20 @@ class XChainBridge extends SerializedType {
       return value
     }
 
-    if (isXChainBridgeObject(value)) {
-      const bytes: Array<Buffer> = []
-      this.TYPE_ORDER.forEach((item) => {
-        const { name, type } = item
-        if (type === AccountID) {
-          bytes.push(Buffer.from([0x14]))
-        }
-        const object = type.from(value[name])
-        bytes.push(object.toBytes())
-      })
-      return new XChainBridge(Buffer.concat(bytes))
+    if (!isXChainBridgeObject(value)) {
+      throw new Error('Invalid type to construct an XChainBridge')
     }
 
-    throw new Error('Invalid type to construct an XChainBridge')
+    const bytes: Array<Uint8Array> = []
+    this.TYPE_ORDER.forEach((item) => {
+      const { name, type } = item
+      if (type === AccountID) {
+        bytes.push(Uint8Array.from([0x14]))
+      }
+      const object = type.from(value[name])
+      bytes.push(object.toBytes())
+    })
+    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
+}