ripple-binary-codec 0.2.7 → 1.0.0-mpt-beta

package/distrib/npm/utils/make-class.js

@@ -1,83 +0,0 @@
-'use strict';var _ = require('lodash');
-var inherits = require('inherits');
-
-function forEach(obj, func) {
-  Object.keys(obj || {}).forEach(function (k) {
-    func(obj[k], k);
-  });
-}
-
-function ensureArray(val) {
-  return Array.isArray(val) ? val : [val];
-}
-
-module.exports = function makeClass(klass_, definition_) {
-  var definition = definition_ || klass_;
-  var klass = typeof klass_ === 'function' ? klass_ : null;
-  if (klass === null) {
-    for (var k in definition) {
-      if (k[0].match(/[A-Z]/)) {
-        klass = definition[k];
-        break;
-      }
-    }
-  }
-  var parent = definition.inherits;
-  if (parent) {
-    if (klass === null) {
-      klass = function klass() {
-        parent.apply(this, arguments);
-      };
-    }
-    inherits(klass, parent);
-    _.defaults(klass, parent);
-  }
-  if (klass === null) {
-    klass = function klass() {};
-  }
-  var proto = klass.prototype;
-  function addFunc(original, name, wrapper) {
-    proto[name] = wrapper || original;
-  }
-  (definition.getters || []).forEach(function (k) {
-    var key = '_' + k;
-    proto[k] = function () {
-      return this[key];
-    };
-  });
-  forEach(definition.virtuals, function (f, n) {
-    addFunc(f, n, function () {
-      throw new Error('unimplemented');
-    });
-  });
-  forEach(definition.methods, addFunc);
-  forEach(definition, function (f, n) {
-    if (_.isFunction(f) && f !== klass) {
-      addFunc(f, n);
-    }
-  });
-  _.assign(klass, definition.statics);
-  if (typeof klass.init === 'function') {
-    klass.init();
-  }
-  forEach(definition.cached, function (f, n) {
-    var key = '_' + n;
-    addFunc(f, n, function () {
-      var value = this[key];
-      if (value === undefined) {
-        value = this[key] = f.call(this);
-      }
-      return value;
-    });
-  });
-  if (definition.mixins) {
-    var mixins = {};
-    // Right-most in the list win
-    ensureArray(definition.mixins).reverse().forEach(function (o) {
-      _.defaults(mixins, o);
-    });
-    _.defaults(proto, mixins);
-  }
-
-  return klass;
-};

package/test/amount-test.js

@@ -1,43 +0,0 @@
-const _ = require('lodash');
-const assert = require('assert');
-const utils = require('./utils');
-const {Amount} = require('../src/coretypes');
-const {loadFixture} = utils;
-const fixtures = loadFixture('data-driven-tests.json');
-
-function amountErrorTests() {
-  _.filter(fixtures.values_tests, {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, () => {
-      assert.throws(() => {
-        Amount.from(f.test_json);
-      }, JSON.stringify(f.test_json));
-    });
-  });
-}
-
-describe('Amount', function() {
-  it('can be parsed from', function() {
-    assert(Amount.from('1000000') instanceof Amount);
-    assert.equal(Amount.from('1000000').valueString(), '1000000');
-    const fixture = {
-      'value': '1',
-      'issuer': '0000000000000000000000000000000000000000',
-      'currency': 'USD'
-    };
-    const amt = Amount.from(fixture);
-    const rewritten = {
-      'value': '1',
-      'issuer': 'rrrrrrrrrrrrrrrrrrrrrhoLvTp',
-      'currency': 'USD'
-    };
-    assert.deepEqual(amt.toJSON(), rewritten);
-  });
-  amountErrorTests()
-});
-

package/test/binary-json-test.js

@@ -1,43 +0,0 @@
-const assert = require('assert');
-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, test_n) => {
-        // eslint-disable-next-line max-len
-        it(`${name}[${test_n}] can encode ${truncateForDisplay(json(t.json))} to ${truncateForDisplay(t.binary)}`,
-          () => {
-            assert.equal(t.binary, encode(t.json));
-          });
-        // eslint-disable-next-line max-len
-        it(`${name}[${test_n}] can decode ${truncateForDisplay(t.binary)} to ${truncateForDisplay(json(t.json))}`,
-          () => {
-            const decoded = decode(t.binary);
-            assert.deepEqual(t.json, decoded);
-          });
-      });
-    });
-  }
-  makeSuite('transactions', fixtures.transactions);
-  makeSuite('accountState', fixtures.accountState);
-
-  describe('ledgerData', function() {
-    fixtures.ledgerData.forEach((t, test_n) => {
-      it(`ledgerData[${test_n}] can decode ${t.binary} to ${json(t.json)}`,
-        () => {
-          const decoded = decodeLedgerData(t.binary);
-          assert.deepEqual(t.json, decoded);
-        });
-    });
-  })
-});

package/test/binary-parser-test.js

@@ -1,341 +0,0 @@
-/* eslint-disable func-style */
-
-const coreTypes = require('../src/coretypes');
-
-const _ = require('lodash');
-const assert = require('assert');
-const {encodeAccountID} = require('ripple-address-codec');
-const {binary: {makeParser, readJSON}, Field, Amount, Hash160} = coreTypes;
-const {enums: {TransactionType}} = coreTypes;
-const utils = require('./utils');
-const {parseHexOnly, assertEqualAmountJSON, hexOnly, loadFixture} = utils;
-const {bytesToHex} = require('../src/utils/bytes-utils');
-const fixtures = loadFixture('data-driven-tests.json');
-const {BytesList} = require('../src/serdes/binary-serializer');
-
-const __ = hexOnly;
-function unused() {}
-function toJSON(v) {
-  return v.toJSON ? v.toJSON() : v;
-}
-
-function basicApiTests() {
-  const bytes = parseHexOnly('00,01020304,0506', Uint8Array);
-  it('can read slices of bytes', () => {
-    const parser = makeParser(bytes);
-    assert.deepEqual(parser.pos(), 0);
-    assert(parser._buf instanceof Uint8Array);
-    const read1 = parser.read(1);
-    assert(read1 instanceof Uint8Array);
-    assert.deepEqual(read1, Uint8Array.from([0]));
-    assert.deepEqual(parser.read(4), Uint8Array.from([1, 2, 3, 4]));
-    assert.deepEqual(parser.read(2), Uint8Array.from([5, 6]));
-    assert.throws(() => parser.read(1));
-  });
-  it('can read a Uint32 at full', () => {
-    const parser = makeParser('FFFFFFFF');
-    assert.equal(parser.readUInt32(), 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
-
-  it('can be done with low level apis', () => {
-    const parser = makeParser(transaction.binary);
-
-    assert.equal(parser.readField(), Field.TransactionType);
-    assert.equal(parser.readUInt16(), 7);
-    assert.equal(parser.readField(), Field.Flags);
-    assert.equal(parser.readUInt32(), 0);
-    assert.equal(parser.readField(), Field.Sequence);
-    assert.equal(parser.readUInt32(), 103929);
-    assert.equal(parser.readField(), Field.TakerPays);
-    parser.read(8);
-    assert.equal(parser.readField(), Field.TakerGets);
-    // amount value
-    assert(parser.read(8));
-    // amount currency
-    assert(Hash160.fromParser(parser));
-    assert.equal(encodeAccountID(parser.read(20)),
-      tx_json.TakerGets.issuer);
-    assert.equal(parser.readField(), Field.Fee);
-    assert(parser.read(8));
-    assert.equal(parser.readField(), Field.SigningPubKey);
-    assert.equal(parser.readVLLength(), 33);
-    assert.equal(bytesToHex(parser.read(33)), tx_json.SigningPubKey);
-    assert.equal(parser.readField(), Field.TxnSignature);
-    assert.equal(bytesToHex(parser.readVL()), tx_json.TxnSignature);
-    assert.equal(parser.readField(), Field.Account);
-    assert.equal(encodeAccountID(parser.readVL()), tx_json.Account);
-    assert(parser.end());
-  });
-
-  it('can be done with high level apis', () => {
-    const parser = makeParser(transaction.binary);
-    function readField() {
-      return parser.readFieldAndValue();
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.TransactionType);
-      assert.equal(value, TransactionType.OfferCreate);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.Flags);
-      assert.equal(value, 0);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.Sequence);
-      assert.equal(value, 103929);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.TakerPays);
-      assert.equal(value.currency.isNative(), true);
-      assert.equal(value.currency.toJSON(), 'XRP');
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.TakerGets);
-      assert.equal(value.currency.isNative(), false);
-      assert.equal(value.issuer.toJSON(), tx_json.TakerGets.issuer);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.Fee);
-      assert.equal(value.currency.isNative(), true);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.SigningPubKey);
-      assert.equal(value.toJSON(), tx_json.SigningPubKey);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.TxnSignature);
-      assert.equal(value.toJSON(), tx_json.TxnSignature);
-    }
-    {
-      const [field, value] = readField();
-      assert.equal(field, Field.Account);
-      assert.equal(value.toJSON(), tx_json.Account);
-    }
-    assert(parser.end());
-  });
-
-  it('can be done with higher level apis', () => {
-    const parser = makeParser(transaction.binary);
-    const jsonFromBinary = readJSON(parser);
-    assert.deepEqual(jsonFromBinary, tx_json);
-  });
-
-  it('readJSON (binary.decode) does not return STObject ', () => {
-    const parser = makeParser(transaction.binary);
-    const jsonFromBinary = readJSON(parser);
-    assert((jsonFromBinary instanceof coreTypes.STObject) === false);
-    assert(_.isPlainObject(jsonFromBinary));
-  });
-}
-
-function amountParsingTests() {
-  _.filter(fixtures.values_tests, {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)}`;
-    it(testName, () => {
-      const value = parser.readType(Amount);
-      // May not actually be in canonical form. The fixtures are to be used
-      // also for json -> binary;
-      assertEqualAmountJSON(toJSON(value), f.test_json);
-      if (f.exponent) {
-        assert.equal(value.exponent(), f.exponent);
-      }
-    });
-  });
-}
-
-function fieldParsingTests() {
-  fixtures.fields_tests.forEach((f, i) => {
-    const parser = makeParser(f.expected_hex);
-    it(`fields[${i}]: parses ${f.expected_hex} as ${f.name}`, () => {
-      const field = parser.readField();
-      assert.equal(field.name, f.name);
-      assert.equal(field.type.name, f.type_name);
-    });
-  });
-}
-
-function assertRecyclable(json, forField) {
-  const Type = forField.associatedType;
-  const recycled = Type.from(json).toJSON();
-  assert.deepEqual(recycled, json);
-  const sink = new BytesList();
-  Type.from(recycled).toBytesSink(sink);
-  const recycledAgain = makeParser(sink.toHex())
-    .readType(Type)
-    .toJSON();
-  assert.deepEqual(recycledAgain, json);
-}
-
-function nestedObjectTests() {
-  function disabled(i) {
-    unused(i);
-    return false; // !_.includes([2], i);
-  }
-
-  fixtures.whole_objects.forEach((f, i) => {
-    if (disabled(i)) {
-      return;
-    }
-
-    it(`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 {
-          assert.deepEqual(actual, expectedJSON);
-        } catch (e) {
-          throw new Error(`${e} ${field} a: ${actual} e: ${expectedJSON}`);
-        }
-        assert.equal(field.name, 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
-     58525000000000003000000000000000000000000055534400000000000A20B3
-     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: '0000000000000000000000005852500000000000'},
-    {currency: 'USD',
-      issuer: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B'}]];
-
-  it('works with long paths', () => {
-    const parser = makeParser(bytes);
-    const txn = readJSON(parser);
-    assert.deepEqual(txn.Paths, expectedJSON);
-    // TODO: this should go elsewhere
-    assert.deepEqual(
-      coreTypes.PathSet.from(txn.Paths).toJSON(),
-      expectedJSON
-    );
-  });
-}
-
-describe('BinaryParser', function() {
-  function dataDrivenTests() {
-    describe('Amount parsing tests', amountParsingTests);
-    describe('Field Tests', fieldParsingTests);
-    describe('Parsing nested objects', nestedObjectTests);
-  }
-  describe('pathSetBinaryTests', pathSetBinaryTests);
-  describe('Basic API', basicApiTests);
-  describe('Parsing a transaction', transactionParsingTests);
-  describe('Data Driven Tests', dataDrivenTests);
-});

package/test/binary-serializer-test.js

@@ -1,194 +0,0 @@
-/* eslint-disable func-style */
-
-const BN = require('bn.js');
-const assert = require('assert');
-const lib = require('../src/coretypes');
-const encode = require('../src').encode;
-const {binary: {makeParser, BytesList, BinarySerializer}} = lib;
-const {UInt8, UInt16, UInt32, UInt64, STObject} = lib;
-const {loadFixture} = require('./utils');
-const fixtures = loadFixture('data-driven-tests.json');
-const deliverMinTx = require('./fixtures/delivermin-tx.json');
-const deliverMinTxBinary = require('./fixtures/delivermin-tx-binary.json');
-const SignerListSet = {
-  tx: require('./fixtures/signerlistset-tx.json'),
-  binary: require('./fixtures/signerlistset-tx-binary.json'),
-  meta: require('./fixtures/signerlistset-tx-meta-binary.json')
-};
-const DepositPreauth = {
-  tx: require('./fixtures/deposit-preauth-tx.json'),
-  binary: require('./fixtures/deposit-preauth-tx-binary.json'),
-  meta: require('./fixtures/deposit-preauth-tx-meta-binary.json')
-};
-const Escrow = {
-  create: {
-    tx: require('./fixtures/escrow-create-tx.json'),
-    binary: require('./fixtures/escrow-create-binary.json')
-  },
-  finish: {
-    tx: require('./fixtures/escrow-finish-tx.json'),
-    binary: require('./fixtures/escrow-finish-binary.json'),
-    meta: require('./fixtures/escrow-finish-meta-binary.json')
-  },
-  cancel: {
-    tx: require('./fixtures/escrow-cancel-tx.json'),
-    binary: require('./fixtures/escrow-cancel-binary.json')
-  }
-}
-const PaymentChannel = {
-  create: {
-    tx: require('./fixtures/payment-channel-create-tx.json'),
-    binary: require('./fixtures/payment-channel-create-binary.json')
-  },
-  fund: {
-    tx: require('./fixtures/payment-channel-fund-tx.json'),
-    binary: require('./fixtures/payment-channel-fund-binary.json')
-  },
-  claim: {
-    tx: require('./fixtures/payment-channel-claim-tx.json'),
-    binary: require('./fixtures/payment-channel-claim-binary.json')
-  }
-}
-
-function bytesListTest() {
-  const list = new BytesList().put([0]).put([2, 3]).put([4, 5]);
-  it('is an Array<Uint8Array>', function() {
-    assert(Array.isArray(list.arrays));
-    assert(list.arrays[0] instanceof Uint8Array);
-  });
-  it('keeps track of the length itself', function() {
-    assert.equal(list.length, 5);
-  });
-  it('can join all arrays into one via toBytes', function() {
-    const joined = list.toBytes();
-    assert(joined.length, 5);
-    assert.deepEqual(joined, Uint8Array.from([0, 2, 3, 4, 5]));
-  });
-}
-
-function assertRecycles(blob) {
-  const parser = makeParser(blob);
-  const so = parser.readType(STObject);
-  const out = new BytesList();
-  so.toBytesSink(out);
-  const hex = out.toHex();
-  assert.equal(hex, blob);
-  assert.notEqual(hex + ':', blob);
-}
-
-function nestedObjectTests() {
-  fixtures.whole_objects.forEach((f, i) => {
-    it(`whole_objects[${i}]: can parse blob and dump out same blob`,
-    /*                                              */ () => {
-        assertRecycles(f.blob_with_no_signing);
-      });
-  });
-}
-
-function UIntTest() {
-  function check(type, n, expected) {
-    it(`Uint${type.width * 8} serializes ${n} as ${expected}`, function() {
-      const bl = new BytesList();
-      const serializer = new BinarySerializer(bl);
-      if (expected === 'throws') {
-        assert.throws(() => serializer.writeType(type, n));
-        return;
-      }
-      serializer.writeType(type, n);
-      assert.deepEqual(bl.toBytes(), Uint8Array.from(expected));
-    });
-  }
-
-  check(UInt8, 5, [5]);
-  check(UInt16, 5, [0, 5]);
-  check(UInt32, 5, [0, 0, 0, 5]);
-  check(UInt32, 0xFFFFFFFF, [255, 255, 255, 255]);
-  check(UInt8, 0xFEFFFFFF, 'throws');
-  check(UInt16, 0xFEFFFFFF, 'throws');
-  check(UInt16, 0xFEFFFFFF, 'throws');
-  check(UInt64, 0xFEFFFFFF, [0, 0, 0, 0, 254, 255, 255, 255]);
-  check(UInt64, -1, 'throws');
-  check(UInt64, 0, [0, 0, 0, 0, 0, 0, 0, 0]);
-  check(UInt64, 1, [0, 0, 0, 0, 0, 0, 0, 1]);
-  check(UInt64, new BN(1), [0, 0, 0, 0, 0, 0, 0, 1]);
-}
-
-
-function parseLedger4320278() {
-  it('can parse object', done => {
-    this.timeout(30e3);
-    const json = loadFixture('as-ledger-4320278.json');
-    json.forEach(e => {
-      assertRecycles(e.binary);
-    });
-    done();
-  });
-}
-
-function deliverMinTest() {
-  it('can serialize DeliverMin', () => {
-    assert.strictEqual(encode(deliverMinTx), deliverMinTxBinary);
-  });
-}
-
-function SignerListSetTest() {
-  it('can serialize SignerListSet', () => {
-    assert.strictEqual(encode(SignerListSet.tx), SignerListSet.binary);
-  });
-  it('can serialize SignerListSet metadata', () => {
-    assert.strictEqual(encode(SignerListSet.tx.meta), SignerListSet.meta);
-  });
-}
-
-function DepositPreauthTest() {
-  it('can serialize DepositPreauth', () => {
-    assert.strictEqual(encode(DepositPreauth.tx), DepositPreauth.binary);
-  });
-  it('can serialize DepositPreauth metadata', () => {
-    assert.strictEqual(encode(DepositPreauth.tx.meta), DepositPreauth.meta);
-  });
-}
-
-function EscrowTest() {
-  it('can serialize EscrowCreate', () => {
-    assert.strictEqual(encode(Escrow.create.tx),
-      Escrow.create.binary);
-  });
-  it('can serialize EscrowFinish', () => {
-    assert.strictEqual(encode(Escrow.finish.tx),
-      Escrow.finish.binary);
-    assert.strictEqual(encode(Escrow.finish.tx.meta),
-      Escrow.finish.meta);
-  });
-  it('can serialize EscrowCancel', () => {
-    assert.strictEqual(encode(Escrow.cancel.tx),
-      Escrow.cancel.binary);
-  });
-}
-
-function PaymentChannelTest() {
-  it('can serialize PaymentChannelCreate', () => {
-    assert.strictEqual(encode(PaymentChannel.create.tx),
-      PaymentChannel.create.binary);
-  });
-  it('can serialize PaymentChannelFund', () => {
-    assert.strictEqual(encode(PaymentChannel.fund.tx),
-      PaymentChannel.fund.binary);
-  });
-  it('can serialize PaymentChannelClaim', () => {
-    assert.strictEqual(encode(PaymentChannel.claim.tx),
-      PaymentChannel.claim.binary);
-  });
-}
-
-describe('Binary Serialization', function() {
-  describe.skip('parseLedger4320278', parseLedger4320278);
-  describe('nestedObjectTests', nestedObjectTests);
-  describe('UIntTest', UIntTest);
-  describe('BytesList', bytesListTest);
-  describe('DeliverMin', deliverMinTest);
-  describe('DepositPreauth', DepositPreauthTest);
-  describe('SignerListSet', SignerListSetTest);
-  describe('Escrow', EscrowTest);
-  describe('PaymentChannel', PaymentChannelTest);
-});