ripple-binary-codec 1.8.0 → 1.10.0-beta.0

package/src/types/uint.ts

@@ -0,0 +1,57 @@
+import bigInt = require('big-integer')
+import { Comparable } from './serialized-type'
+import { Buffer } from 'buffer/'
+
+/**
+ * Compare numbers and bigInts n1 and n2
+ *
+ * @param n1 First object to compare
+ * @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 {
+  return n1 < n2 ? -1 : n1 == n2 ? 0 : 1
+}
+
+/**
+ * Base class for serializing and deserializing unsigned integers.
+ */
+abstract class UInt extends Comparable {
+  protected static width: number
+
+  constructor(bytes: Buffer) {
+    super(bytes)
+  }
+
+  /**
+   * Overload of compareTo for 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 {
+    return compare(this.valueOf(), other.valueOf())
+  }
+
+  /**
+   * Convert a UInt object to JSON
+   *
+   * @returns number or string represented by this.bytes
+   */
+  toJSON(): number | string {
+    const val = this.valueOf()
+    return typeof val === 'number' ? val : val.toString()
+  }
+
+  /**
+   * Get the value of the UInt represented by this.bytes
+   *
+   * @returns the value
+   */
+  abstract valueOf(): number | bigInt.BigInteger
+}
+
+export { UInt }

package/src/types/vector-256.ts

@@ -0,0 +1,84 @@
+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/'
+
+/**
+ * TypeGuard for Array<string>
+ */
+function isStrings(arg): arg is Array<string> {
+  return Array.isArray(arg) && (arg.length === 0 || typeof arg[0] === 'string')
+}
+
+/**
+ * Class for serializing and deserializing vectors of Hash256
+ */
+class Vector256 extends SerializedType {
+  constructor(bytes: Buffer) {
+    super(bytes)
+  }
+
+  /**
+   * Construct a Vector256 from a BinaryParser
+   *
+   * @param parser BinaryParser to
+   * @param hint length of the vector, in bytes, optional
+   * @returns a Vector256 object
+   */
+  static fromParser(parser: BinaryParser, hint?: number): Vector256 {
+    const bytesList = new BytesList()
+    const bytes = hint ?? parser.size()
+    const hashes = bytes / 32
+    for (let i = 0; i < hashes; i++) {
+      Hash256.fromParser(parser).toBytesSink(bytesList)
+    }
+    return new Vector256(bytesList.toBytes())
+  }
+
+  /**
+   * Construct a Vector256 object from an array of hashes
+   *
+   * @param value A Vector256 object or array of hex-strings representing Hash256's
+   * @returns a Vector256 object
+   */
+  static from<T extends Vector256 | Array<string>>(value: T): Vector256 {
+    if (value instanceof Vector256) {
+      return value
+    }
+
+    if (isStrings(value)) {
+      const bytesList = new BytesList()
+      value.forEach((hash) => {
+        Hash256.from(hash).toBytesSink(bytesList)
+      })
+      return new Vector256(bytesList.toBytes())
+    }
+
+    throw new Error('Cannot construct Vector256 from given value')
+  }
+
+  /**
+   * Return an Array of hex-strings represented by this.bytes
+   *
+   * @returns An Array of strings representing the Hash256 objects
+   */
+  toJSON(): Array<string> {
+    if (this.bytes.byteLength % 32 !== 0) {
+      throw new Error('Invalid bytes for Vector256')
+    }
+
+    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(),
+      )
+    }
+    return result
+  }
+}
+
+export { Vector256 }

package/src/types/xchain-bridge.ts

@@ -0,0 +1,128 @@
+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'
+
+/**
+ * Interface for JSON objects that represent cross-chain bridges
+ */
+interface XChainBridgeObject extends JsonObject {
+  LockingChainDoor: string
+  LockingChainIssue: IssueObject | string
+  IssuingChainDoor: string
+  IssuingChainIssue: IssueObject | string
+}
+
+/**
+ * Type guard for XChainBridgeObject
+ */
+function isXChainBridgeObject(arg): arg is XChainBridgeObject {
+  const keys = Object.keys(arg).sort()
+  return (
+    keys.length === 4 &&
+    keys[0] === 'IssuingChainDoor' &&
+    keys[1] === 'IssuingChainIssue' &&
+    keys[2] === 'LockingChainDoor' &&
+    keys[3] === 'LockingChainIssue'
+  )
+}
+
+/**
+ * Class for serializing/deserializing XChainBridges
+ */
+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),
+    ]),
+  )
+
+  static readonly TYPE_ORDER: { name: string; type: typeof SerializedType }[] =
+    [
+      { name: 'LockingChainDoor', type: AccountID },
+      { name: 'LockingChainIssue', type: Issue },
+      { name: 'IssuingChainDoor', type: AccountID },
+      { name: 'IssuingChainIssue', type: Issue },
+    ]
+
+  constructor(bytes: Buffer) {
+    super(bytes ?? XChainBridge.ZERO_XCHAIN_BRIDGE.bytes)
+  }
+
+  /**
+   * Construct a cross-chain bridge from a JSON
+   *
+   * @param value XChainBridge or JSON to parse into a XChainBridge
+   * @returns A XChainBridge object
+   */
+  static from<T extends XChainBridge | XChainBridgeObject>(
+    value: T,
+  ): XChainBridge {
+    if (value instanceof XChainBridge) {
+      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))
+    }
+
+    throw new Error('Invalid type to construct a XChainBridge')
+  }
+
+  /**
+   * Read a XChainBridge from a BinaryParser
+   *
+   * @param parser BinaryParser to read the XChainBridge from
+   * @returns A XChainBridge object
+   */
+  static fromParser(parser: BinaryParser): XChainBridge {
+    const bytes: Array<Buffer> = []
+
+    this.TYPE_ORDER.forEach((item) => {
+      const { type } = item
+      if (type === AccountID) {
+        parser.skip(1)
+        bytes.push(Buffer.from([0x14]))
+      }
+      const object = type.fromParser(parser)
+      bytes.push(object.toBytes())
+    })
+
+    return new XChainBridge(Buffer.concat(bytes))
+  }
+
+  /**
+   * Get the JSON representation of this XChainBridge
+   *
+   * @returns the JSON interpretation of this.bytes
+   */
+  toJSON(): XChainBridgeObject {
+    const parser = new BinaryParser(this.toString())
+    const json = {}
+    XChainBridge.TYPE_ORDER.forEach((item) => {
+      const { name, type } = item
+      if (type === AccountID) {
+        parser.skip(1)
+      }
+      const object = type.fromParser(parser).toJSON()
+      json[name] = object
+    })
+    return json as XChainBridgeObject
+  }
+}
+
+export { XChainBridge, XChainBridgeObject }

package/test/amount.test.js

@@ -1,43 +0,0 @@
-const { loadFixture } = require('./utils')
-const { coreTypes } = require('../src/types')
-const { Amount } = coreTypes
-const fixtures = loadFixture('data-driven-tests.json')
-
-function amountErrorTests() {
-  fixtures.values_tests
-    .filter((obj) => obj.type === 'Amount')
-    .forEach((f) => {
-      // We only want these with errors
-      if (!f.error) {
-        return
-      }
-      const testName =
-        `${JSON.stringify(f.test_json)}\n\tis invalid ` + `because: ${f.error}`
-      it(testName, () => {
-        expect(() => {
-          Amount.from(f.test_json)
-          JSON.stringify(f.test_json)
-        }).toThrow()
-      })
-    })
-}
-
-describe('Amount', function () {
-  it('can be parsed from', function () {
-    expect(Amount.from('1000000') instanceof Amount).toBe(true)
-    expect(Amount.from('1000000').toJSON()).toEqual('1000000')
-    const fixture = {
-      value: '1',
-      issuer: '0000000000000000000000000000000000000000',
-      currency: 'USD',
-    }
-    const amt = Amount.from(fixture)
-    const rewritten = {
-      value: '1',
-      issuer: 'rrrrrrrrrrrrrrrrrrrrrhoLvTp',
-      currency: 'USD',
-    }
-    expect(amt.toJSON()).toEqual(rewritten)
-  })
-  amountErrorTests()
-})

package/test/binary-json.test.js

@@ -1,45 +0,0 @@
-const fixtures = require('./fixtures/codec-fixtures.json')
-const { decode, encode, decodeLedgerData } = require('../src')
-
-function json(object) {
-  return JSON.stringify(object)
-}
-
-function truncateForDisplay(longStr) {
-  return `${longStr.slice(0, 10)} ... ${longStr.slice(-10)}`
-}
-
-describe('ripple-binary-codec', function () {
-  function makeSuite(name, entries) {
-    describe(name, function () {
-      entries.forEach((t, testN) => {
-        test(`${name}[${testN}] can encode ${truncateForDisplay(
-          json(t.json),
-        )} to ${truncateForDisplay(t.binary)}`, () => {
-          expect(encode(t.json)).toEqual(t.binary)
-        })
-        test(`${name}[${testN}] can decode ${truncateForDisplay(
-          t.binary,
-        )} to ${truncateForDisplay(json(t.json))}`, () => {
-          const decoded = decode(t.binary)
-          expect(decoded).toEqual(t.json)
-        })
-      })
-    })
-  }
-  makeSuite('transactions', fixtures.transactions)
-  makeSuite('accountState', fixtures.accountState)
-
-  describe('ledgerData', function () {
-    if (fixtures.ledgerData) {
-      fixtures.ledgerData.forEach((t, testN) => {
-        test(`ledgerData[${testN}] can decode ${t.binary} to ${json(
-          t.json,
-        )}`, () => {
-          const decoded = decodeLedgerData(t.binary)
-          expect(t.json).toEqual(decoded)
-        })
-      })
-    }
-  })
-})