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

package/test/hash-test.js

@@ -1,58 +0,0 @@
-const assert = require('assert');
-const {Hash160, Hash256, Currency, AccountID} = require('../src/coretypes');
-
-describe('Hash160', function() {
-  it('has a static width membmer', function() {
-    assert.equal(Hash160.width, 20);
-  });
-  it('inherited by subclasses', function() {
-    assert.equal(AccountID.width, 20);
-    assert.equal(Currency.width, 20);
-  });
-  it('can be compared against another', function() {
-    const h1 = Hash160.from('1000000000000000000000000000000000000000');
-    const h2 = Hash160.from('2000000000000000000000000000000000000000');
-    const h3 = Hash160.from('0000000000000000000000000000000000000003');
-    assert(h1.lt(h2));
-    assert(h3.lt(h2));
-  });
-});
-
-describe('Hash256', function() {
-  it('has a static width membmer', function() {
-    assert.equal(Hash256.width, 32);
-  });
-  it('has a ZERO_256 member', function() {
-    assert.equal(
-      Hash256.ZERO_256.toJSON(),
-      '0000000000000000000000000000000000000000000000000000000000000000');
-  });
-  it('supports getting the nibblet values at given positions', function() {
-    const h = Hash256.from(
-      '1359BD0000000000000000000000000000000000000000000000000000000000');
-    assert.equal(h.nibblet(0), 0x1);
-    assert.equal(h.nibblet(1), 0x3);
-    assert.equal(h.nibblet(2), 0x5);
-    assert.equal(h.nibblet(3), 0x9);
-    assert.equal(h.nibblet(4), 0x0b);
-    assert.equal(h.nibblet(5), 0xd);
-  });
-});
-
-describe('Currency', function() {
-  it('Will have a null iso() for dodgy XRP ', function() {
-    const bad = Currency.from('0000000000000000000000005852500000000000');
-    assert.equal(bad.iso(), null);
-    assert.equal(bad.isNative(), false);
-  });
-  it('can be constructed from an Array', function() {
-    const xrp = Currency.from(new Uint8Array(20));
-    assert.equal(xrp.iso(), 'XRP');
-  });
-  it('throws on invalid reprs', function() {
-    assert.throws(() => Currency.from(new Uint8Array(19)));
-    assert.throws(() => Currency.from(1));
-    assert.throws(() => Currency.from(
-      '00000000000000000000000000000000000000m'));
-  });
-});

package/test/ledger-test.js

@@ -1,26 +0,0 @@
-const assert = require('assert');
-const {loadFixture} = require('./utils');
-const ledgerHashes = require('../src/ledger-hashes');
-const {transactionTreeHash, ledgerHash, accountStateHash} = ledgerHashes;
-
-describe('Ledger Hashes', function() {
-  function testFactory(ledgerFixture) {
-    describe(`can calculate hashes for ${ledgerFixture}`, function() {
-      const ledger = loadFixture(ledgerFixture);
-      it('computes correct account state hash', function() {
-        assert.equal(accountStateHash(ledger.accountState).toHex(),
-          ledger.account_hash);
-      });
-      it('computes correct transaction tree hash', function() {
-        assert.equal(transactionTreeHash(ledger.transactions).toHex(),
-          ledger.transaction_hash);
-      });
-      it('computes correct ledger header hash', function() {
-        assert.equal(ledgerHash(ledger).toHex(), ledger.hash);
-      });
-    });
-  }
-  testFactory('ledger-full-40000.json');
-  testFactory('ledger-full-38129.json');
-});
-

package/test/mocha.opts

@@ -1 +0,0 @@
---reporter spec --slow 500 --require babel-core/register

package/test/quality-test.js

@@ -1,16 +0,0 @@
-const assert = require('assert');
-const {quality, binary: {bytesToHex}} = require('../src/coretypes');
-
-describe('Quality encode/decode', function() {
-  const bookDirectory =
-    '4627DFFCFF8B5A265EDBD8AE8C14A52325DBFEDAF4F5C32E5D06F4C3362FE1D0';
-  const expectedQuality = '195796912.5171664';
-  it('can decode', function() {
-    const decimal = quality.decode(bookDirectory);
-    assert.equal(decimal.toString(), expectedQuality);
-  });
-  it('can encode', function() {
-    const bytes = quality.encode(expectedQuality);
-    assert.equal(bytesToHex(bytes), bookDirectory.slice(-16));
-  });
-});

package/test/shamap-test.js

@@ -1,88 +0,0 @@
-const assert = require('assert');
-const {ShaMap} = require('../src/shamap.js');
-const {binary: {serializeObject}, Hash256, HashPrefix}
-  = require('../src/coretypes');
-const {loadFixture} = require('./utils');
-
-function now() {
-  return (Number(Date.now())) / 1000;
-}
-
-const ZERO =
-  '0000000000000000000000000000000000000000000000000000000000000000';
-
-function makeItem(indexArg) {
-  let str = indexArg;
-  while (str.length < 64) {
-    str += '0';
-  }
-  const index = Hash256.from(str);
-  const item = {
-    toBytesSink(sink) {
-      index.toBytesSink(sink);
-    },
-    hashPrefix() {
-      return [1, 3, 3, 7];
-    }
-  };
-  return [index, item];
-}
-
-describe('ShaMap', () => {
-  now();
-
-  it('hashes to zero when empty', () => {
-    const map = new ShaMap();
-    assert.equal(map.hash().toHex(), ZERO);
-  });
-  it('creates the same hash no matter which order items are added', () => {
-    let map = new ShaMap();
-    const items = [
-      '0',
-      '1',
-      '11',
-      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E20000000000000000',
-      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E21000000000000000',
-      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E22000000000000000',
-      '7000DE445E22CB9BB7E1717589FA858736BAA5FD192310E23000000000000000',
-      '12',
-      '122'
-    ];
-    items.forEach(i => map.addItem(...makeItem(i)));
-    const h1 = map.hash();
-    assert(h1.eq(h1));
-    map = new ShaMap();
-    items.reverse().forEach(i => map.addItem(...makeItem(i)));
-    assert(map.hash().eq(h1));
-  });
-  function factory(fixture) {
-    it(`recreate account state hash from ${fixture}`, () => {
-      const map = new ShaMap();
-      const ledger = loadFixture(fixture);
-      // const t = now();
-      const leafNodePrefix = HashPrefix.accountStateEntry;
-      ledger.accountState.map((e, i) => {
-        if (i > 1000 & (i % 1000) === 0) {
-          console.log(e.index);
-          console.log(i);
-        }
-        const bytes = serializeObject(e);
-        return {
-          index: Hash256.from(e.index),
-          hashPrefix() {
-            return leafNodePrefix;
-          },
-          toBytesSink(sink) {
-            sink.put(bytes);
-          }
-        };
-      }).forEach(so => map.addItem(so.index, so));
-      assert.equal(map.hash().toHex(), ledger.account_hash);
-      // console.log('took seconds: ', (now() - t));
-    });
-  }
-  factory('ledger-full-38129.json');
-  factory('ledger-full-40000.json');
-  // factory('ledger-4320277.json');
-  // factory('14280680.json');
-});

package/test/signing-data-encoding-test.js

@@ -1,120 +0,0 @@
-const _ = require('lodash');
-const assert = require('assert');
-const {encodeForSigning, encodeForSigningClaim, encodeForMultisigning} =
-  require('../src');
-
-const tx_json = {
-  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
-  Amount: '1000',
-  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
-  Fee: '10',
-  Flags: 2147483648,
-  Sequence: 1,
-  TransactionType: 'Payment',
-  TxnSignature: '30440220718D264EF05CAED7C781FF6DE298DCAC68D002562C9BF3A07C1' +
-    'E721B420C0DAB02203A5A4779EF4D2CCC7BC3EF886676D803A9981B928D3B8ACA483B80' +
-    'ECA3CD7B9B',
-  Signature: '30440220718D264EF05CAED7C781FF6DE298DCAC68D002562C9BF3A07C1E72' +
-    '1B420C0DAB02203A5A4779EF4D2CCC7BC3EF886676D803A9981B928D3B8ACA483B80ECA' +
-    '3CD7B9B',
-  SigningPubKey:
-    'ED5F5AC8B98974A3CA843326D9B88CEBD0560177B973EE0B149F782CFAA06DC66A'
-};
-
-describe('Signing data', function() {
-  it('can create single signing blobs', function() {
-    const actual = encodeForSigning(tx_json);
-    assert.equal(actual,
-      ['53545800', // signingPrefix
-        // TransactionType
-        '12',
-        '0000',
-        // Flags
-        '22',
-        '80000000',
-        // Sequence
-        '24',
-        '00000001',
-        // Amount
-        '61',
-        // native amount
-        '40000000000003E8',
-        // Fee
-        '68',
-        // native amount
-        '400000000000000A',
-        // SigningPubKey
-        '73',
-        // VLLength
-        '21',
-        'ED5F5AC8B98974A3CA843326D9B88CEBD0560177B973EE0B149F782CFAA06DC66A',
-        // Account
-        '81',
-        // VLLength
-        '14',
-        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
-        // Destination
-        '83',
-        // VLLength
-        '14',
-        'B5F762798A53D543A014CAF8B297CFF8F2F937E8'].join('')
-    );
-  });
-  it('can create multi signing blobs', function() {
-    const signingAccount = 'rJZdUusLDtY9NEsGea7ijqhVrXv98rYBYN';
-    const signingJson = _.assign({}, tx_json, {SigningPubKey: ''});
-    const actual = encodeForMultisigning(signingJson, signingAccount);
-    assert.equal(actual,
-      ['534D5400', // signingPrefix
-        // TransactionType
-        '12',
-        '0000',
-        // Flags
-        '22',
-        '80000000',
-        // Sequence
-        '24',
-        '00000001',
-        // Amount
-        '61',
-        // native amount
-        '40000000000003E8',
-        // Fee
-        '68',
-        // native amount
-        '400000000000000A',
-        // SigningPubKey
-        '73',
-        // VLLength
-        '00',
-        // '',
-        // Account
-        '81',
-        // VLLength
-        '14',
-        '5B812C9D57731E27A2DA8B1830195F88EF32A3B6',
-        // Destination
-        '83',
-        // VLLength
-        '14',
-        'B5F762798A53D543A014CAF8B297CFF8F2F937E8',
-        // signingAccount suffix
-        'C0A5ABEF242802EFED4B041E8F2D4A8CC86AE3D1'].join('')
-    );
-  });
-  it('can create claim blob', function() {
-    const channel =
-      '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1'
-    const amount = '1000'
-    const json = {channel, amount}
-    const actual = encodeForSigningClaim(json)
-    assert.equal(actual, [
-      // hash prefix
-      '434C4D00',
-      // channel ID
-      '43904CBFCDCEC530B4037871F86EE90BF799DF8D2E0EA564BC8A3F332E4F5FB1',
-      // amount as a uint64
-      '00000000000003E8'
-    ].join(''))
-  })
-});

package/test/tx-encode-decode-test.js

@@ -1,124 +0,0 @@
-const assert = require('assert');
-const {
-  encode,
-  decode
-} = require('../src')
-
-// Notice: no Amount or Fee
-const tx_json = {
-  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
-  // Amount: '1000',
-  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
-  // Fee: '10',
-
-  // JavaScript converts operands to 32-bit signed ints after doing bitwise
-  // operations. We need to convert it back to an unsigned int with >>> 0.
-  Flags: ((1 << 31) >>> 0), // tfFullyCanonicalSig
-
-  Sequence: 1,
-  TransactionType: 'Payment'
-  // TxnSignature,
-  // Signature,
-  // SigningPubKey
-};
-
-const amount_parameters_message = input => {
-  // disables the ESLint rule on the whole rest of the file
-  /* eslint-disable max-len */
-  return `${input} is an illegal amount
-
-Native values must be described in drops, a million of which equal one XRP.
-This must be an integer number, with the absolute value not exceeding 100000000000000000
-
-IOU values must have a maximum precision of 16 significant digits. They are serialized as
-a canonicalised mantissa and exponent.
-
-The valid range for a mantissa is between 1000000000000000 and 9999999999999999
-The exponent must be >= -96 and <= 80
-
-Thus the largest serializable IOU value is:
-999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000
-
-And the smallest:
-0.000000000000000000000000000000000000000000000000000000000000000000000000000000001
-`;
-};
-
-describe('encoding and decoding tx_json', function() {
-  it('can encode tx_json without Amount or Fee', function() {
-    const encoded = encode(tx_json);
-    const decoded = decode(encoded);
-    assert.deepStrictEqual(tx_json, decoded);
-  });
-  it('can encode tx_json with Amount and Fee', function() {
-    const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000',
-      Fee: '10'
-    });
-    const encoded = encode(my_tx);
-    const decoded = decode(encoded);
-    assert.deepStrictEqual(my_tx, decoded);
-  });
-  it('throws when Amount is invalid', function() {
-    const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000.001',
-      Fee: '10'
-    });
-    assert.throws(() => {
-      encode(my_tx);
-    }, {
-      name: 'Error',
-      message: amount_parameters_message('1000.001')
-    });
-  });
-  it('throws when Fee is invalid', function() {
-    const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000',
-      Fee: '10.123'
-    });
-    assert.throws(() => {
-      encode(my_tx);
-    }, {
-      name: 'Error',
-      message: amount_parameters_message('10.123')
-    });
-  });
-  it('throws when Amount and Fee are invalid', function() {
-    const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000.789',
-      Fee: '10.123'
-    });
-    assert.throws(() => {
-      encode(my_tx);
-    }, {
-      name: 'Error',
-      message: amount_parameters_message('1000.789')
-    });
-  });
-  it('throws when Amount is a number instead of a string-encoded integer',
-    function() {
-      const my_tx = Object.assign({}, tx_json, {
-        Amount: 1000.789
-      });
-      assert.throws(() => {
-        encode(my_tx);
-      },
-      {
-        name: 'Error',
-        message: 'unsupported value: 1000.789'
-      });
-    });
-  it('throws when Fee is a number instead of a string-encoded integer',
-    function() {
-      const my_tx = Object.assign({}, tx_json, {
-        Amount: 1234.56
-      });
-      assert.throws(() => {
-        encode(my_tx);
-      },
-      {
-        name: 'Error',
-        message: 'unsupported value: 1234.56'
-      });
-    });
-});

package/test/types-test.js

@@ -1,38 +0,0 @@
-const _ = require('lodash');
-const assert = require('assert');
-const coreTypes = require('../src/types');
-const {SerializedType} = require('../src/types/serialized-type');
-
-describe('SerializedType interfaces', () => {
-  _.forOwn(coreTypes, (Value, name) => {
-    it(`${name} has a \`from\` static constructor`, () => {
-      assert(Value.from && Value.from !== Array.from);
-    });
-    it(`${name} has a default constructor`, () => {
-      /* eslint-disable no-new*/
-      new Value();
-      /* eslint-enable no-new*/
-    });
-    it(`${name}.from will return the same object`, () => {
-      const instance = new Value();
-      assert(Value.from(instance) === instance);
-    });
-    it(`${name} instances have toBytesSink`, () => {
-      assert(new Value().toBytesSink);
-    });
-    it(`${name} instances have toJSON`, () => {
-      assert(new Value().toJSON);
-    });
-    it(`${name}.from(json).toJSON() == json`, () => {
-      const newJSON = new Value().toJSON();
-      assert.deepEqual(Value.from(newJSON).toJSON(), newJSON);
-    });
-    describe(`${name} supports all methods of the SerializedType mixin`, () => {
-      _.keys(SerializedType).forEach(k => {
-        it(`new ${name}.prototype.${k} !== undefined`, () => {
-          assert.notEqual(Value.prototype[k], undefined);
-        });
-      });
-    });
-  });
-});

package/test/uint-test.js

@@ -1,38 +0,0 @@
-const assert = require('assert');
-const coreTypes = require('../src/coretypes');
-/* eslint-disable no-unused-vars */
-const {UInt8, UInt16, UInt32, UInt64} = coreTypes;
-/* eslint-enable no-unused-vars */
-
-function compareToTests() {
-
-  function check(expr, is) {
-    it(expr, function() {
-      /* eslint-disable no-eval */
-      assert.equal(eval(expr), is);
-      /* eslint-enable no-eval */
-    });
-  }
-  check('UInt8.from(124).compareTo(UInt64.from(124))', 0);
-  check('UInt64.from(124).compareTo(UInt8.from(124))', 0);
-  check('UInt64.from(124).compareTo(UInt8.from(123))', 1);
-  check('UInt8.from(124).compareTo(UInt8.from(13))', 1);
-  check('UInt8.from(124).compareTo(124)', 0);
-  check('UInt64.from(124).compareTo(124)', 0);
-  check('UInt64.from(124).compareTo(123)', 1);
-  check('UInt8.from(124).compareTo(13)', 1);
-}
-
-function valueOfTests() {
-  it('The Uint classes work with |= operator', function() {
-    let val = UInt8.from(1);
-    val |= 0x2;
-    assert.equal(val, 3);
-  });
-}
-
-describe('Uint*', function() {
-  describe('compareToTests', compareToTests);
-  describe('valueOfTests', valueOfTests);
-});
-

package/test/utils.js

@@ -1,93 +0,0 @@
-const intercept = require('intercept-stdout');
-const fs = require('fs');
-const fsExtra = require('fs-extra');
-const assert = require('assert');
-const Decimal = require('decimal.js');
-const {parseBytes} = require('../src/utils/bytes-utils');
-
-function hexOnly(hex) {
-  return hex.replace(/[^a-fA-F0-9]/g, '');
-}
-
-function unused() {}
-
-function captureLogsAsync() {
-  let log = '';
-  const unhook = intercept(txt => {
-    log += txt;
-    return '';
-  });
-  return function() {
-    unhook();
-    return log;
-  };
-}
-
-function captureLogs(func) {
-  const finished = captureLogsAsync();
-  try {
-    func();
-  } catch (e) {
-    const log = finished();
-    console.error(log);
-    throw e;
-  }
-  return finished();
-}
-
-function parseHexOnly(hex, to) {
-  return parseBytes(hexOnly(hex), to);
-}
-
-function loadFixture(relativePath) {
-  const fn = __dirname + '/fixtures/' + relativePath;
-  return require(fn);
-}
-
-function isBufferOrString(val) {
-  return Buffer.isBuffer(val) || (typeof val === 'string');
-}
-
-function loadFixtureText(relativePath) {
-  const fn = __dirname + '/fixtures/' + relativePath;
-  return fs.readFileSync(fn).toString('utf8');
-}
-
-function fixturePath(relativePath) {
-  return __dirname + '/fixtures/' + relativePath;
-}
-
-function prettyJSON(val) {
-  return JSON.stringify(val, null, 2);
-}
-
-function writeFixture(relativePath, data) {
-  const out = isBufferOrString(data) ? data : prettyJSON(data);
-  return fsExtra.outputFileSync(fixturePath(relativePath), out);
-}
-
-function assertEqualAmountJSON(actual, expected) {
-  const typeA = (typeof actual);
-  assert(typeA === (typeof expected));
-  if (typeA === 'string') {
-    assert.equal(actual, expected);
-    return;
-  }
-  assert.equal(actual.currency, expected.currency);
-  assert.equal(actual.issuer, expected.issuer);
-  assert(actual.value === expected.value ||
-            new Decimal(actual.value).equals(
-              new Decimal(expected.value)));
-}
-
-module.exports = {
-  hexOnly,
-  parseHexOnly,
-  loadFixture,
-  loadFixtureText,
-  assertEqualAmountJSON,
-  writeFixture,
-  unused,
-  captureLogs,
-  captureLogsAsync
-};