ripple-binary-codec 1.7.1 → 1.9.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/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)
-        })
-      })
-    }
-  })
-})

package/test/binary-parser.test.js

@@ -1,396 +0,0 @@
-const { coreTypes } = require('../src/types')
-const Decimal = require('decimal.js')
-
-const { encodeAccountID } = require('ripple-address-codec')
-const { binary } = require('../src/coretypes')
-const { Amount, Hash160 } = coreTypes
-const { makeParser, readJSON } = binary
-const { Field, TransactionType } = require('./../src/enums')
-const { parseHexOnly, hexOnly, loadFixture } = require('./utils')
-const fixtures = loadFixture('data-driven-tests.json')
-const { BytesList } = require('../src/serdes/binary-serializer')
-const { Buffer } = require('buffer/')
-
-const __ = hexOnly
-function toJSON(v) {
-  return v.toJSON ? v.toJSON() : v
-}
-
-function assertEqualAmountJSON(actual, expected) {
-  expect(typeof actual === typeof expected).toBe(true)
-  if (typeof actual === 'string') {
-    expect(actual).toEqual(expected)
-    return
-  }
-  expect(actual.currency).toEqual(expected.currency)
-  expect(actual.issuer).toEqual(expected.issuer)
-  expect(
-    actual.value === expected.value ||
-      new Decimal(actual.value).equals(new Decimal(expected.value)),
-  ).toBe(true)
-}
-
-function basicApiTests() {
-  const bytes = parseHexOnly('00,01020304,0506', Uint8Array)
-  test('can read slices of bytes', () => {
-    const parser = makeParser(bytes)
-    expect(parser.bytes instanceof Buffer).toBe(true)
-    const read1 = parser.read(1)
-    expect(read1 instanceof Buffer).toBe(true)
-    expect(read1).toEqual(Buffer.from([0]))
-    expect(parser.read(4)).toEqual(Buffer.from([1, 2, 3, 4]))
-    expect(parser.read(2)).toEqual(Buffer.from([5, 6]))
-    expect(() => parser.read(1)).toThrow()
-  })
-  test('can read a Uint32 at full', () => {
-    const parser = makeParser('FFFFFFFF')
-    expect(parser.readUInt32()).toEqual(0xffffffff)
-  })
-}
-
-function transactionParsingTests() {
-  const transaction = {
-    json: {
-      Account: 'raD5qJMAShLeHZXf9wjUmo6vRK4arj9cF3',
-      Fee: '10',
-      Flags: 0,
-      Sequence: 103929,
-      SigningPubKey:
-        '028472865AF4CB32AA285834B57576B7290AA8C31B459047DB27E16F418D6A7166',
-      TakerGets: {
-        currency: 'ILS',
-        issuer: 'rNPRNzBB92BVpAhhZr4iXDTveCgV5Pofm9',
-        value: '1694.768',
-      },
-      TakerPays: '98957503520',
-      TransactionType: 'OfferCreate',
-      TxnSignature: __(`
-          304502202ABE08D5E78D1E74A4C18F2714F64E87B8BD57444AF
-          A5733109EB3C077077520022100DB335EE97386E4C0591CAC02
-          4D50E9230D8F171EEB901B5E5E4BD6D1E0AEF98C`),
-    },
-    binary: __(`
-      120007220000000024000195F964400000170A53AC2065D5460561E
-      C9DE000000000000000000000000000494C53000000000092D70596
-      8936C419CE614BF264B5EEB1CEA47FF468400000000000000A73210
-      28472865AF4CB32AA285834B57576B7290AA8C31B459047DB27E16F
-      418D6A71667447304502202ABE08D5E78D1E74A4C18F2714F64E87B
-      8BD57444AFA5733109EB3C077077520022100DB335EE97386E4C059
-      1CAC024D50E9230D8F171EEB901B5E5E4BD6D1E0AEF98C811439408
-      A69F0895E62149CFCC006FB89FA7D1E6E5D`),
-  }
-
-  const tx_json = transaction.json
-  // These tests are basically development logs
-
-  test('can be done with low level apis', () => {
-    const parser = makeParser(transaction.binary)
-
-    expect(parser.readField()).toEqual(Field.TransactionType)
-    expect(parser.readUInt16()).toEqual(7)
-    expect(parser.readField()).toEqual(Field.Flags)
-    expect(parser.readUInt32()).toEqual(0)
-    expect(parser.readField()).toEqual(Field.Sequence)
-    expect(parser.readUInt32()).toEqual(103929)
-    expect(parser.readField()).toEqual(Field.TakerPays)
-    parser.read(8)
-    expect(parser.readField()).toEqual(Field.TakerGets)
-    // amount value
-    expect(parser.read(8)).not.toBe([])
-    // amount currency
-    expect(Hash160.fromParser(parser)).not.toBe([])
-    expect(encodeAccountID(parser.read(20))).toEqual(tx_json.TakerGets.issuer)
-    expect(parser.readField()).toEqual(Field.Fee)
-    expect(parser.read(8)).not.toEqual([])
-    expect(parser.readField()).toEqual(Field.SigningPubKey)
-    expect(parser.readVariableLengthLength()).toBe(33)
-    expect(parser.read(33).toString('hex').toUpperCase()).toEqual(
-      tx_json.SigningPubKey,
-    )
-    expect(parser.readField()).toEqual(Field.TxnSignature)
-    expect(parser.readVariableLength().toString('hex').toUpperCase()).toEqual(
-      tx_json.TxnSignature,
-    )
-    expect(parser.readField()).toEqual(Field.Account)
-    expect(encodeAccountID(parser.readVariableLength())).toEqual(
-      tx_json.Account,
-    )
-    expect(parser.end()).toBe(true)
-  })
-
-  test('can be done with high level apis', () => {
-    const parser = makeParser(transaction.binary)
-    function readField() {
-      return parser.readFieldAndValue()
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.TransactionType)
-      expect(value).toEqual(TransactionType.OfferCreate)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.Flags)
-      expect(value.valueOf()).toEqual(0)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.Sequence)
-      expect(value.valueOf()).toEqual(103929)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.TakerPays)
-      expect(value.isNative()).toEqual(true)
-      expect(value.toJSON()).toEqual('98957503520')
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.TakerGets)
-      expect(value.isNative()).toEqual(false)
-      expect(value.toJSON().issuer).toEqual(tx_json.TakerGets.issuer)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.Fee)
-      expect(value.isNative()).toEqual(true)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.SigningPubKey)
-      expect(value.toJSON()).toEqual(tx_json.SigningPubKey)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.TxnSignature)
-      expect(value.toJSON()).toEqual(tx_json.TxnSignature)
-    }
-    {
-      const [field, value] = readField()
-      expect(field).toEqual(Field.Account)
-      expect(value.toJSON()).toEqual(tx_json.Account)
-    }
-    expect(parser.end()).toBe(true)
-  })
-
-  test('can be done with higher level apis', () => {
-    const parser = makeParser(transaction.binary)
-    const jsonFromBinary = readJSON(parser)
-    expect(jsonFromBinary).toEqual(tx_json)
-  })
-
-  test('readJSON (binary.decode) does not return STObject ', () => {
-    const parser = makeParser(transaction.binary)
-    const jsonFromBinary = readJSON(parser)
-    expect(jsonFromBinary instanceof coreTypes.STObject).toBe(false)
-    expect(jsonFromBinary instanceof Object).toBe(true)
-    expect(jsonFromBinary.prototype).toBe(undefined)
-  })
-}
-
-function amountParsingTests() {
-  fixtures.values_tests
-    .filter((obj) => obj.type === 'Amount')
-    .forEach((f, i) => {
-      if (f.error) {
-        return
-      }
-      const parser = makeParser(f.expected_hex)
-      const testName = `values_tests[${i}] parses ${f.expected_hex.slice(
-        0,
-        16,
-      )}...
-          as ${JSON.stringify(f.test_json)}`
-      test(testName, () => {
-        const value = parser.readType(Amount)
-        // May not actually be in canonical form. The fixtures are to be used
-        // also for json -> binary;
-        const json = toJSON(value)
-        assertEqualAmountJSON(json, f.test_json)
-        if (f.exponent) {
-          const exponent = new Decimal(json.value)
-          expect(exponent.e - 15).toEqual(f.exponent)
-        }
-      })
-    })
-}
-
-function fieldParsingTests() {
-  fixtures.fields_tests.forEach((f, i) => {
-    const parser = makeParser(f.expected_hex)
-    test(`fields[${i}]: parses ${f.expected_hex} as ${f.name}`, () => {
-      const field = parser.readField()
-      expect(field.name).toEqual(f.name)
-      expect(field.type.name).toEqual(f.type_name)
-    })
-  })
-  test('Field throws when type code out of range', () => {
-    const parser = makeParser('0101')
-    expect(() => parser.readField()).toThrow(
-      new Error('Cannot read FieldOrdinal, type_code out of range'),
-    )
-  })
-  test('Field throws when field code out of range', () => {
-    const parser = makeParser('1001')
-    expect(() => parser.readFieldOrdinal()).toThrowError(
-      new Error('Cannot read FieldOrdinal, field_code out of range'),
-    )
-  })
-  test('Field throws when both type and field code out of range', () => {
-    const parser = makeParser('000101')
-    expect(() => parser.readFieldOrdinal()).toThrowError(
-      new Error('Cannot read FieldOrdinal, type_code out of range'),
-    )
-  })
-}
-
-function assertRecyclable(json, forField) {
-  const Type = forField.associatedType
-  const recycled = Type.from(json).toJSON()
-  expect(recycled).toEqual(json)
-  const sink = new BytesList()
-  Type.from(recycled).toBytesSink(sink)
-  const recycledAgain = makeParser(sink.toHex()).readType(Type).toJSON()
-  expect(recycledAgain).toEqual(json)
-}
-
-function nestedObjectTests() {
-  fixtures.whole_objects.forEach((f, i) => {
-    test(`whole_objects[${i}]: can parse blob into
-          ${JSON.stringify(
-            f.tx_json,
-          )}`, /*                                              */ () => {
-      const parser = makeParser(f.blob_with_no_signing)
-      let ix = 0
-      while (!parser.end()) {
-        const [field, value] = parser.readFieldAndValue()
-        const expected = f.fields[ix]
-        const expectedJSON = expected[1].json
-        const expectedField = expected[0]
-        const actual = toJSON(value)
-
-        try {
-          expect(actual).toEqual(expectedJSON)
-        } catch (e) {
-          throw new Error(`${e} ${field} a: ${actual} e: ${expectedJSON}`)
-        }
-        expect(field.name).toEqual(expectedField)
-        assertRecyclable(actual, field)
-        ix++
-      }
-    })
-  })
-}
-
-function pathSetBinaryTests() {
-  const bytes = __(
-    `1200002200000000240000002E2E00004BF161D4C71AFD498D00000000000000
-     0000000000000055534400000000000A20B3C85F482532A9578DBB3950B85CA0
-     6594D168400000000000000A69D446F8038585E9400000000000000000000000
-     00425443000000000078CA21A6014541AB7B26C3929B9E0CD8C284D61C732103
-     A4665B1F0B7AE2BCA12E2DB80A192125BBEA660F80E9CEE137BA444C1B0769EC
-     7447304502205A964536805E35785C659D1F9670D057749AE39668175D6AA75D
-     25B218FE682E0221009252C0E5DDD5F2712A48F211669DE17B54113918E0D2C2
-     66F818095E9339D7D3811478CA21A6014541AB7B26C3929B9E0CD8C284D61C83
-     140A20B3C85F482532A9578DBB3950B85CA06594D1011231585E1F3BD02A15D6
-     185F8BB9B57CC60DEDDB37C10000000000000000000000004254430000000000
-     585E1F3BD02A15D6185F8BB9B57CC60DEDDB37C131E4FE687C90257D3D2D694C
-     8531CDEECBE84F33670000000000000000000000004254430000000000E4FE68
-     7C90257D3D2D694C8531CDEECBE84F3367310A20B3C85F482532A9578DBB3950
-     B85CA06594D100000000000000000000000042544300000000000A20B3C85F48
-     2532A9578DBB3950B85CA06594D1300000000000000000000000005553440000
-     0000000A20B3C85F482532A9578DBB3950B85CA06594D1FF31585E1F3BD02A15
-     D6185F8BB9B57CC60DEDDB37C100000000000000000000000042544300000000
-     00585E1F3BD02A15D6185F8BB9B57CC60DEDDB37C131E4FE687C90257D3D2D69
-     4C8531CDEECBE84F33670000000000000000000000004254430000000000E4FE
-     687C90257D3D2D694C8531CDEECBE84F33673115036E2D3F5437A83E5AC3CAEE
-     34FF2C21DEB618000000000000000000000000425443000000000015036E2D3F
-     5437A83E5AC3CAEE34FF2C21DEB6183000000000000000000000000055534400
-     000000000A20B3C85F482532A9578DBB3950B85CA06594D1FF31585E1F3BD02A
-     15D6185F8BB9B57CC60DEDDB37C1000000000000000000000000425443000000
-     0000585E1F3BD02A15D6185F8BB9B57CC60DEDDB37C13157180C769B66D942EE
-     69E6DCC940CA48D82337AD000000000000000000000000425443000000000057
-     180C769B66D942EE69E6DCC940CA48D82337AD10000000000000000000000000
-     00000000000000003000000000000000000000000055534400000000000A20B3
-     C85F482532A9578DBB3950B85CA06594D100`,
-  )
-
-  const expectedJSON = [
-    [
-      {
-        account: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
-        currency: 'BTC',
-        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
-      },
-      {
-        account: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
-        currency: 'BTC',
-        issuer: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
-      },
-      {
-        account: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
-        currency: 'BTC',
-        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
-      },
-      {
-        currency: 'USD',
-        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
-      },
-    ],
-    [
-      {
-        account: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
-        currency: 'BTC',
-        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
-      },
-      {
-        account: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
-        currency: 'BTC',
-        issuer: 'rM1oqKtfh1zgjdAgbFmaRm3btfGBX25xVo',
-      },
-      {
-        account: 'rpvfJ4mR6QQAeogpXEKnuyGBx8mYCSnYZi',
-        currency: 'BTC',
-        issuer: 'rpvfJ4mR6QQAeogpXEKnuyGBx8mYCSnYZi',
-      },
-      {
-        currency: 'USD',
-        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
-      },
-    ],
-    [
-      {
-        account: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
-        currency: 'BTC',
-        issuer: 'r9hEDb4xBGRfBCcX3E4FirDWQBAYtpxC8K',
-      },
-      {
-        account: 'r3AWbdp2jQLXLywJypdoNwVSvr81xs3uhn',
-        currency: 'BTC',
-        issuer: 'r3AWbdp2jQLXLywJypdoNwVSvr81xs3uhn',
-      },
-      { currency: 'XRP' },
-      {
-        currency: 'USD',
-        issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B',
-      },
-    ],
-  ]
-
-  test('works with long paths', () => {
-    const parser = makeParser(bytes)
-    const txn = readJSON(parser)
-    expect(txn.Paths).toEqual(expectedJSON)
-    // TODO: this should go elsewhere
-    expect(coreTypes.PathSet.from(txn.Paths).toJSON()).toEqual(expectedJSON)
-  })
-}
-
-describe('Binary Parser', function () {
-  describe('pathSetBinaryTests', () => pathSetBinaryTests())
-  describe('nestedObjectTests', () => nestedObjectTests())
-  describe('fieldParsingTests', () => fieldParsingTests())
-  describe('amountParsingTests', () => amountParsingTests())
-  describe('transactionParsingTests', () => transactionParsingTests())
-  describe('basicApiTests', () => basicApiTests())
-})