all files / lib/ index.test.js

1.16% Statements 1/86
0% Branches 0/24
0% Functions 0/8
1.16% Lines 1/86
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150                                                                                                                                                                                                                                                                                                         
'use strict';
 
/* eslint-env mocha */
assert = require('assert');
 
ecc = require('.');
 
describe('Common API', function () {
  it('randomKey', function () {
    cpuEntropyBits = 1;
    ecc.key_utils.addEntropy(1, 2, 3);
    assert(/^5[HJK]/.test(ecc.randomKey(cpuEntropyBits)));
  });
 
  it('seedPrivate', function () {
    wif = '5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss';
    assert.equal(ecc.seedPrivate(''), wif);
  });
 
  it('privateToPublic', function () {
    pub = 'EOS859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM';
    assert.equal(ecc.privateToPublic(wif), pub);
  });
 
  it('isValidPublic', function () {
    keys = [[true, 'EOS859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM'], [false, 'MOS859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVM'], [false, 'EOS859gxfnXyUriMgUeThh1fWv3oqcpLFyHa3TfFYC4PK2HqhToVm']];
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;
 
    try {
      for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var key = _step.value;
 
        assert.equal(key[0], ecc.isValidPublic(key[1]) === true);
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  });
 
  it('isValidPrivate', function () {
    keys = [[true, '5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss'], [false, '5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjsm']];
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;
 
    try {
      for (var _iterator2 = keys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        var key = _step2.value;
 
        assert.equal(key[0], ecc.isValidPrivate(key[1]) === true);
      }
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2.return) {
          _iterator2.return();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }
  });
 
  it('hashs', function () {
    hashes = [
    // ['sha1', 'da39a3ee5e6b4b0d3255bfef95601890afd80709'],
    ['sha256', 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855']];
    var _iteratorNormalCompletion3 = true;
    var _didIteratorError3 = false;
    var _iteratorError3 = undefined;
 
    try {
      for (var _iterator3 = hashes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
        hash = _step3.value;
 
        assert.equal(ecc[hash[0]](''), hash[1]);
        assert.equal(ecc[hash[0]](Buffer.from('')), hash[1]);
      }
    } catch (err) {
      _didIteratorError3 = true;
      _iteratorError3 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion3 && _iterator3.return) {
          _iterator3.return();
        }
      } finally {
        if (_didIteratorError3) {
          throw _iteratorError3;
        }
      }
    }
  });
 
  it('signatures', function () {
    wif = ecc.seedPrivate('');
    pubkey = ecc.privateToPublic(wif);
 
    data = 'hi';
    dataSha256 = ecc.sha256(data);
 
    sigs = [ecc.sign(data, wif), ecc.sign(dataSha256, wif, false)];
 
    var _iteratorNormalCompletion4 = true;
    var _didIteratorError4 = false;
    var _iteratorError4 = undefined;
 
    try {
      for (var _iterator4 = sigs[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
        sig = _step4.value;
 
        assert.equal(65, Buffer.from(sig, 'hex').length);
        assert(ecc.verify(sig, data, pubkey), 'verify data');
        assert(ecc.verify(sig, dataSha256, pubkey, false), 'verify hash');
        assert.equal(pubkey, ecc.recover(sig, data), 'recover from data');
        assert.equal(pubkey, ecc.recover(sig, dataSha256, false), 'recover from hash');
      }
    } catch (err) {
      _didIteratorError4 = true;
      _iteratorError4 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion4 && _iterator4.return) {
          _iterator4.return();
        }
      } finally {
        if (_didIteratorError4) {
          throw _iteratorError4;
        }
      }
    }
  });
});