@transia/ripple-binary-codec 1.4.4-alpha.0

package/dist/types/vector-256.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector256 = void 0;
+const serialized_type_1 = require("./serialized-type");
+const hash_256_1 = require("./hash-256");
+const binary_serializer_1 = require("../serdes/binary-serializer");
+/**
+ * TypeGuard for Array<string>
+ */
+function isStrings(arg) {
+    return Array.isArray(arg) && (arg.length === 0 || typeof arg[0] === 'string');
+}
+/**
+ * Class for serializing and deserializing vectors of Hash256
+ */
+class Vector256 extends serialized_type_1.SerializedType {
+    constructor(bytes) {
+        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, hint) {
+        const bytesList = new binary_serializer_1.BytesList();
+        const bytes = hint !== null && hint !== void 0 ? hint : parser.size();
+        const hashes = bytes / 32;
+        for (let i = 0; i < hashes; i++) {
+            hash_256_1.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(value) {
+        if (value instanceof Vector256) {
+            return value;
+        }
+        if (isStrings(value)) {
+            const bytesList = new binary_serializer_1.BytesList();
+            value.forEach((hash) => {
+                hash_256_1.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() {
+        if (this.bytes.byteLength % 32 !== 0) {
+            throw new Error('Invalid bytes for Vector256');
+        }
+        const result = [];
+        for (let i = 0; i < this.bytes.byteLength; i += 32) {
+            result.push(this.bytes
+                .slice(i, i + 32)
+                .toString('hex')
+                .toUpperCase());
+        }
+        return result;
+    }
+}
+exports.Vector256 = Vector256;
+//# sourceMappingURL=vector-256.js.map

package/dist/types/vector-256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-256.js","sourceRoot":"","sources":["../../src/types/vector-256.ts"],"names":[],"mappings":";;;AAAA,uDAAkD;AAElD,yCAAoC;AACpC,mEAAuD;AAGvD;;GAEG;AACH,SAAS,SAAS,CAAC,GAAG;IACpB,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAA;AAC/E,CAAC;AAED;;GAEG;AACH,MAAM,SAAU,SAAQ,gCAAc;IACpC,YAAY,KAAa;QACvB,KAAK,CAAC,KAAK,CAAC,CAAA;IACd,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,MAAoB,EAAE,IAAa;QACnD,MAAM,SAAS,GAAG,IAAI,6BAAS,EAAE,CAAA;QACjC,MAAM,KAAK,GAAG,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,MAAM,CAAC,IAAI,EAAE,CAAA;QACnC,MAAM,MAAM,GAAG,KAAK,GAAG,EAAE,CAAA;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;YAC/B,kBAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;SAClD;QACD,OAAO,IAAI,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAA;IAC3C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAsC,KAAQ;QACvD,IAAI,KAAK,YAAY,SAAS,EAAE;YAC9B,OAAO,KAAK,CAAA;SACb;QAED,IAAI,SAAS,CAAC,KAAK,CAAC,EAAE;YACpB,MAAM,SAAS,GAAG,IAAI,6BAAS,EAAE,CAAA;YACjC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACrB,kBAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;YAC3C,CAAC,CAAC,CAAA;YACF,OAAO,IAAI,SAAS,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAA;SAC1C;QAED,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;IAChE,CAAC;IAED;;;;OAIG;IACH,MAAM;QACJ,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,EAAE,KAAK,CAAC,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAA;SAC/C;QAED,MAAM,MAAM,GAAkB,EAAE,CAAA;QAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;YAClD,MAAM,CAAC,IAAI,CACT,IAAI,CAAC,KAAK;iBACP,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC;iBAChB,QAAQ,CAAC,KAAK,CAAC;iBACf,WAAW,EAAE,CACjB,CAAA;SACF;QACD,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAEQ,8BAAS"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@transia/ripple-binary-codec",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.4.4-alpha.0",
+  "description": "XRP Ledger binary codec",
+  "files": [
+    "dist/*",
+    "bin/*",
+    "test/*"
+  ],
+  "main": "dist/",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "assert": "^2.0.0",
+    "big-integer": "^1.6.48",
+    "buffer": "5.6.0",
+    "create-hash": "^1.2.0",
+    "decimal.js": "^10.2.0",
+    "ripple-address-codec": "^4.2.5"
+  },
+  "scripts": {
+    "build": "tsc -b && copyfiles ./src/enums/definitions.json ./dist/enums/",
+    "clean": "rm -rf ./dist && rm -rf tsconfig.tsbuildinfo",
+    "prepare": "npm run build && npm test",
+    "test": "jest --verbose false --silent=false ./test/*.test.js",
+    "lint": "eslint . --ext .ts --ext .test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com/Transia-RnD/xrpl.js/tree/beta"
+  },
+  "bugs": {
+    "url": "https://github.com/XRPLF/xrpl.js/issues"
+  },
+  "homepage": "https://github.com/XRPLF/xrpl.js/tree/main/packages/ripple-binary-codec#readme",
+  "license": "ISC",
+  "readmeFilename": "README.md",
+  "prettier": "@xrplf/prettier-config",
+  "engines": {
+    "node": ">= 10"
+  },
+  "gitHead": "05bea18d66e528686e3822f559abbeed8086c8d8"
+}

package/test/amount.test.js

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,396 @@
+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())
+})