@opcat-labs/opcat 1.0.0

package/test/mnemonic/mnemonic.js

@@ -0,0 +1,259 @@
+'use strict';
+
+var chai = require('chai');
+var should = chai.should();
+var opcat = require('../../');
+var Mnemonic = opcat.Mnemonic;
+var errors = require('../../').errors;
+var bip39vectors = require('./data/fixtures.json');
+
+describe('Mnemonic', function () {
+  this.timeout(30000);
+
+  it('should initialize the class', function () {
+    should.exist(Mnemonic);
+  });
+
+  describe('@fromRandom', function () {
+    it('should make a new mnemonic', function () {
+      let mnemonic = Mnemonic.fromRandom();
+      let mnemonic2 = Mnemonic.fromRandom();
+      mnemonic.toString().should.not.equal(mnemonic2.toString());
+      Mnemonic.Words.ENGLISH.includes(mnemonic.toString().split(' ')[0]).should.equal(true);
+      Mnemonic.Words.ENGLISH.includes(mnemonic.toString().split(' ')[1]).should.equal(true);
+      Mnemonic.Words.ENGLISH.includes(mnemonic.toString().split(' ')[2]).should.equal(true);
+      let mnemonic3 = Mnemonic.fromRandom(Mnemonic.Words.SPANISH);
+      Mnemonic.Words.SPANISH.includes(mnemonic3.toString().split(' ')[0]).should.equal(true);
+      Mnemonic.Words.SPANISH.includes(mnemonic3.toString().split(' ')[1]).should.equal(true);
+      Mnemonic.Words.SPANISH.includes(mnemonic3.toString().split(' ')[2]).should.equal(true);
+    });
+  });
+
+  describe('# Mnemonic', function () {
+    describe('Constructor', function () {
+      it('does not require new keyword', function () {
+        var mnemonic = Mnemonic();
+        mnemonic.should.be.instanceof(Mnemonic);
+      });
+
+      it('should fail with invalid data', function () {
+        (function () {
+          return new Mnemonic({});
+        }).should.throw(errors.InvalidArgument);
+      });
+
+      it('should fail with unknown word list', function () {
+        (function () {
+          return new Mnemonic(
+            'pilots foster august tomorrow kit daughter unknown awesome model town village master',
+          );
+        }).should.throw(errors.Mnemonic.UnknownWordlist);
+      });
+
+      it('should fail with invalid mnemonic', function () {
+        (function () {
+          return new Mnemonic(
+            'monster foster august tomorrow kit daughter unknown awesome model town village pilot',
+          );
+        }).should.throw(errors.Mnemonic.InvalidMnemonic);
+      });
+
+      it('should fail with invalid ENT', function () {
+        (function () {
+          return new Mnemonic(64);
+        }).should.throw(errors.InvalidArgument);
+      });
+
+      it('constructor defaults to english worldlist', function () {
+        var mnemonic = new Mnemonic();
+        mnemonic.wordlist.should.equal(Mnemonic.Words.ENGLISH);
+      });
+
+      it('allow using different worldlists', function () {
+        var mnemonic = new Mnemonic(Mnemonic.Words.SPANISH);
+        mnemonic.wordlist.should.equal(Mnemonic.Words.SPANISH);
+      });
+
+      it('constructor honor both length and wordlist', function () {
+        var mnemonic = new Mnemonic(32 * 7, Mnemonic.Words.SPANISH);
+        mnemonic.phrase.split(' ').length.should.equal(21);
+        mnemonic.wordlist.should.equal(Mnemonic.Words.SPANISH);
+      });
+
+      it('constructor should detect standard wordlist', function () {
+        var mnemonic = new Mnemonic(
+          'afirmar diseño hielo fideo etapa ogro cambio fideo toalla pomelo número buscar',
+        );
+        mnemonic.wordlist.should.equal(Mnemonic.Words.SPANISH);
+      });
+    });
+
+    it('english wordlist is complete', function () {
+      Mnemonic.Words.ENGLISH.length.should.equal(2048);
+      Mnemonic.Words.ENGLISH[0].should.equal('abandon');
+    });
+
+    it('spanish wordlist is complete', function () {
+      Mnemonic.Words.SPANISH.length.should.equal(2048);
+      Mnemonic.Words.SPANISH[0].should.equal('ábaco');
+    });
+
+    it('japanese wordlist is complete', function () {
+      Mnemonic.Words.JAPANESE.length.should.equal(2048);
+      Mnemonic.Words.JAPANESE[0].should.equal('あいこくしん');
+    });
+
+    it('chinese wordlist is complete', function () {
+      Mnemonic.Words.CHINESE.length.should.equal(2048);
+      Mnemonic.Words.CHINESE[0].should.equal('的');
+    });
+
+    it('french wordlist is complete', function () {
+      Mnemonic.Words.FRENCH.length.should.equal(2048);
+      Mnemonic.Words.FRENCH[0].should.equal('abaisser');
+    });
+
+    it('italian wordlist is complete', function () {
+      Mnemonic.Words.ITALIAN.length.should.equal(2048);
+      Mnemonic.Words.ITALIAN[0].should.equal('abaco');
+    });
+
+    it('allows use different phrase lengths', function () {
+      var mnemonic;
+
+      mnemonic = new Mnemonic(32 * 4);
+      mnemonic.phrase.split(' ').length.should.equal(12);
+
+      mnemonic = new Mnemonic(32 * 5);
+      mnemonic.phrase.split(' ').length.should.equal(15);
+
+      mnemonic = new Mnemonic(32 * 6);
+      mnemonic.phrase.split(' ').length.should.equal(18);
+
+      mnemonic = new Mnemonic(32 * 7);
+      mnemonic.phrase.split(' ').length.should.equal(21);
+
+      mnemonic = new Mnemonic(32 * 8);
+      mnemonic.phrase.split(' ').length.should.equal(24);
+    });
+
+    it('validates a phrase', function () {
+      var valid = Mnemonic.isValid(
+        'afirmar diseño hielo fideo etapa ogro cambio fideo toalla pomelo número buscar',
+      );
+      valid.should.equal(true);
+
+      var invalid = Mnemonic.isValid(
+        'afirmar diseño hielo fideo etapa ogro cambio fideo hielo pomelo número buscar',
+      );
+      invalid.should.equal(false);
+
+      var invalid2 = Mnemonic.isValid(
+        'afirmar diseño hielo fideo etapa ogro cambio fideo hielo pomelo número oneInvalidWord',
+      );
+      invalid2.should.equal(false);
+
+      var invalid3 = Mnemonic.isValid('totally invalid phrase');
+      invalid3.should.equal(false);
+
+      var valid2 = Mnemonic.isValid(
+        'caution opprimer époque belote devenir ficeler filleul caneton apologie nectar frapper fouiller',
+      );
+      valid2.should.equal(true);
+    });
+
+    it('has a toString method', function () {
+      var mnemonic = new Mnemonic();
+      mnemonic.toString().should.equal(mnemonic.phrase);
+    });
+
+    it('has a fromString method', function () {
+      var mnemonic = Mnemonic.fromRandom();
+      mnemonic.toString().should.equal(mnemonic.phrase);
+      var mnemonic2 = Mnemonic.fromString(mnemonic.toString());
+      mnemonic2.toString().should.equal(mnemonic.toString());
+      var mnemonic3 = Mnemonic.fromRandom(Mnemonic.Words.SPANISH);
+      var mnemonic4 = Mnemonic.fromString(mnemonic3.toString(), Mnemonic.Words.SPANISH);
+      mnemonic3.toString().should.equal(mnemonic4.toString());
+    });
+
+    it('has a toString method', function () {
+      var mnemonic = new Mnemonic();
+      mnemonic.inspect().should.have.string('<Mnemonic:');
+    });
+
+    it('derives a seed without a passphrase', function () {
+      var mnemonic = new Mnemonic();
+      var seed = mnemonic.toSeed();
+      seed.length.should.equal(512 / 8);
+      should.exist(seed);
+    });
+
+    it('derives a seed using a passphrase', function () {
+      var mnemonic = new Mnemonic();
+      var seed = mnemonic.toSeed('my passphrase');
+      should.exist(seed);
+    });
+
+    it('derives an extended private key', function () {
+      var mnemonic = new Mnemonic();
+      var pk = mnemonic.toHDPrivateKey();
+      should.exist(pk);
+    });
+
+    it('Mnemonic.fromSeed should fail with invalid wordlist', function () {
+      (function () {
+        return Mnemonic.fromSeed(Buffer.alloc(1));
+      }).should.throw(errors.InvalidArgument);
+    });
+
+    it('Mnemonic.fromSeed should fail with invalid seed', function () {
+      (function () {
+        return Mnemonic.fromSeed();
+      }).should.throw(errors.InvalidArgument);
+    });
+
+    it('Constructor should fail with invalid seed', function () {
+      (function () {
+        return new Mnemonic(Buffer.alloc(1));
+      }).should.throw(errors.InvalidEntropy);
+    });
+
+    // To add new vectors for different languages:
+    // 1. Add and implement the wordlist so it appears in Mnemonic.Words
+    // 2. Add the vectors and make sure the key is lowercase of the key for Mnemonic.Words
+    var vectorwordlists = {};
+
+    for (var key in Mnemonic.Words) {
+      if (Mnemonic.Words.hasOwnProperty(key)) {
+        vectorwordlists[key.toLowerCase()] = Mnemonic.Words[key];
+      }
+    }
+
+    var testvector = function (v, lang) {
+      it('should pass test vector for ' + lang + ' #' + v, function () {
+        var wordlist = vectorwordlists[lang];
+        var vector = bip39vectors[lang][v];
+        var code = vector[1];
+        var mnemonic = vector[2];
+        var seed = vector[3];
+        var mnemonic1 = Mnemonic.fromSeed(Buffer.from(code, 'hex'), wordlist).phrase;
+        mnemonic1.should.equal(mnemonic);
+
+        var m = new Mnemonic(mnemonic);
+        var seed1 = m.toSeed(vector[0]);
+        seed1.toString('hex').should.equal(seed);
+
+        Mnemonic.isValid(mnemonic, wordlist).should.equal(true);
+      });
+    };
+
+    for (let key in bip39vectors) {
+      if (bip39vectors.hasOwnProperty(key)) {
+        for (var v = 0; v < bip39vectors[key].length; v++) {
+          testvector(v, key);
+        }
+      }
+    }
+  });
+});

package/test/mnemonic/mocha.opts

@@ -0,0 +1 @@
+--timeout 7000

package/test/mnemonic/pbkdf2.test.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var chai = require('chai');
+chai.should();
+
+var pbkdf2 = require('../../lib/mnemonic/pbkdf2');
+
+describe('pbkdf2', function () {
+  this.timeout(10000);
+
+  // http://stackoverflow.com/questions/15593184/pbkdf2-hmac-sha-512-test-vectors
+  it('passes test vector 1', function () {
+    var key = 'password';
+    var salt = 'salt';
+
+    var res = pbkdf2(key, salt, 1, 64);
+    res
+      .toString('hex')
+      .should.equal(
+        '867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce',
+      );
+  });
+
+  it('passes test vector 2', function () {
+    var key = 'password';
+    var salt = 'salt';
+
+    var res = pbkdf2(key, salt, 2, 64);
+    res
+      .toString('hex')
+      .should.equal(
+        'e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53cf76cab2868a39b9f7840edce4fef5a82be67335c77a6068e04112754f27ccf4e',
+      );
+  });
+
+  it('passes test vector 3', function () {
+    var key = 'password';
+    var salt = 'salt';
+
+    var res = pbkdf2(key, salt, 4096, 64);
+    res
+      .toString('hex')
+      .should.equal(
+        'd197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f87f6902e072f457b5143f30602641b3d55cd335988cb36b84376060ecd532e039b742a239434af2d5',
+      );
+  });
+
+  it('passes test vector 4', function () {
+    var key = 'passwordPASSWORDpassword';
+    var salt = 'saltSALTsaltSALTsaltSALTsaltSALTsalt';
+
+    var res = pbkdf2(key, salt, 4096, 64);
+    res
+      .toString('hex')
+      .should.equal(
+        '8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b868c005174dc4ee71115b59f9e60cd9532fa33e0f75aefe30225c583a186cd82bd4daea9724a3d3b8',
+      );
+  });
+});

package/test/networks.js

@@ -0,0 +1,159 @@
+'use strict';
+
+var expect = require('chai').expect;
+var should = require('chai').should();
+var opcat = require('..');
+var networks = opcat.Networks;
+
+describe('Networks', function () {
+  var customnet;
+
+  it('should contain all Networks', function () {
+    should.exist(networks.livenet);
+    should.exist(networks.testnet);
+    should.exist(networks.stn);
+    should.exist(networks.defaultNetwork);
+  });
+
+  it('should be able to define a custom Network', function () {
+    var custom = {
+      name: 'customnet',
+      alias: 'mynet',
+      pubkeyhash: 0x10,
+      privatekey: 0x90,
+      scripthash: 0x08,
+      xpubkey: 0x0278b20e,
+      xprivkey: 0x0278ade4,
+      networkMagic: 0xe7beb4d4,
+      port: 20001,
+      dnsSeeds: ['localhost', 'mynet.localhost'],
+    };
+    networks.add(custom);
+    customnet = networks.get('customnet');
+    for (var key in custom) {
+      if (key !== 'networkMagic') {
+        customnet[key].should.equal(custom[key]);
+      } else {
+        var expected = Buffer.from('e7beb4d4', 'hex');
+        customnet[key].should.deep.equal(expected);
+      }
+    }
+  });
+
+  it('should have network magic for testnet', function () {
+    var testnet = networks.get('testnet');
+    Buffer.isBuffer(testnet.networkMagic).should.equal(true);
+  });
+
+  it('should have network magic for stn', function () {
+    var stn = networks.get('stn');
+    Buffer.isBuffer(stn.networkMagic).should.equal(true);
+  });
+
+  it('can remove a custom network', function () {
+    networks.remove(customnet);
+    var net = networks.get('customnet');
+    should.equal(net, undefined);
+  });
+
+  it('should not set a network map for an undefined value', function () {
+    var custom = {
+      name: 'somenet',
+      pubkeyhash: 0x13,
+      privatekey: 0x93,
+      scripthash: 0x11,
+      xpubkey: 0x0278b20f,
+      xprivkey: 0x0278ade5,
+      networkMagic: 0xe7beb4d5,
+      port: 20008,
+      dnsSeeds: ['somenet.localhost'],
+    };
+    networks.add(custom);
+    var network = networks.get(undefined);
+    should.not.exist(network);
+    var somenet = networks.get('somenet');
+    should.exist(somenet);
+    somenet.name.should.equal('somenet');
+    networks.remove(somenet);
+  });
+
+  var constants = ['name', 'alias', 'pubkeyhash', 'scripthash', 'xpubkey', 'xprivkey'];
+
+  constants.forEach(function (key) {
+    it('should have constant ' + key + ' for livenet, testnet and stn', function () {
+      networks.testnet.hasOwnProperty(key).should.equal(true);
+      networks.livenet.hasOwnProperty(key).should.equal(true);
+      networks.stn.hasOwnProperty(key).should.equal(true);
+    });
+  });
+
+  it('tests only for the specified key', function () {
+    expect(networks.get(0x6f, 'pubkeyhash')).to.equal(networks.testnet);
+    expect(networks.get(0x6f, 'privatekey')).to.equal(undefined);
+  });
+
+  it('can test for multiple keys', function () {
+    expect(networks.get(0x6f, ['pubkeyhash', 'scripthash'])).to.equal(networks.testnet);
+    expect(networks.get(0xc4, ['pubkeyhash', 'scripthash'])).to.equal(networks.testnet);
+    expect(networks.get(0x6f, ['privatekey', 'port'])).to.equal(undefined);
+  });
+
+  it('should have regtest network', function () {
+    expect(networks.get('regtest').name).to.equal('regtest');
+  });
+
+  it('should have testnet network', function () {
+    expect(networks.get('testnet').name).to.equal('testnet');
+  });
+
+  it('should have stn network', function () {
+    expect(networks.get('stn').name).to.equal('stn');
+  });
+
+  it('should have livenet network', function () {
+    expect(networks.get('livenet').name).to.equal('livenet');
+  });
+
+  it('should have bchtest cashAddrPrefix', function () {
+    expect(networks.get('testnet').cashAddrPrefix).to.equal('bchtest');
+  });
+
+  it('should have bchreg cashAddrPrefix', function () {
+    expect(networks.get('regtest').cashAddrPrefix).to.equal('bchreg');
+  });
+
+  it('should have bchreg cashAddrPrefix after enableRegtest is called', function () {
+    var network = networks.get('testnet');
+    networks.enableRegtest();
+    expect(network.cashAddrPrefix).to.equal('bchreg');
+  });
+
+  it('should have bchtest cashAddrPrefix after disableRegtest is called', function () {
+    var network = networks.get('testnet');
+    networks.disableRegtest();
+    expect(network.cashAddrPrefix).to.equal('bchtest');
+  });
+  it('should have opcatstn cashAddrPrefix after enableStn is called', function () {
+    var network = networks.get('testnet');
+    networks.enableStn();
+    expect(network.cashAddrPrefix).to.equal('opcatstn');
+  });
+
+  it('should have bchtest cashAddrPrefix after disableStn is called', function () {
+    var network = networks.get('testnet');
+    networks.disableStn();
+    expect(network.cashAddrPrefix).to.equal('bchtest');
+  });
+
+  it('converts to string using the "name" property', function () {
+    networks.livenet.toString().should.equal('livenet');
+  });
+
+  it('network object should be immutable', function () {
+    expect(networks.testnet.name).to.equal('testnet');
+    var fn = function () {
+      networks.testnet.name = 'livenet';
+    };
+    expect(fn).to.throw(TypeError);
+  });
+});

package/test/opcode.js

@@ -0,0 +1,161 @@
+'use strict';
+
+var chai = require('chai');
+var should = chai.should();
+var expect = chai.expect;
+var opcat = require('..');
+var Opcode = opcat.Opcode;
+
+describe('Opcode', function () {
+  it('should create a new Opcode', function () {
+    var opcode = new Opcode(5);
+    should.exist(opcode);
+  });
+
+  it('should convert to a string with this handy syntax', function () {
+    Opcode(0).toString().should.equal('OP_0');
+    Opcode(96).toString().should.equal('OP_16');
+    Opcode(97).toString().should.equal('OP_NOP');
+  });
+
+  it('should convert to a number with this handy syntax', function () {
+    Opcode('OP_0').toNumber().should.equal(0);
+    Opcode('OP_16').toNumber().should.equal(96);
+    Opcode('OP_NOP').toNumber().should.equal(97);
+  });
+
+  describe('#fromNumber', function () {
+    it('should work for 0', function () {
+      Opcode.fromNumber(0).num.should.equal(0);
+    });
+    it('should fail for non-number', function () {
+      Opcode.fromNumber.bind(null, 'a string').should.throw('Invalid Argument');
+    });
+  });
+
+  describe('#set', function () {
+    it('should work for object', function () {
+      Opcode(42).num.should.equal(42);
+    });
+    it('should fail for empty-object', function () {
+      expect(function () {
+        Opcode();
+      }).to.throw(TypeError);
+    });
+  });
+
+  describe('#toNumber', function () {
+    it('should work for 0', function () {
+      Opcode.fromNumber(0).toNumber().should.equal(0);
+    });
+  });
+
+  describe('#buffer', function () {
+    it('should correctly input/output a buffer', function () {
+      var buf = Buffer.from('a6', 'hex');
+      Opcode.fromBuffer(buf).toBuffer().should.deep.equal(buf);
+    });
+  });
+
+  describe('#fromString', function () {
+    it('should work for OP_0', function () {
+      Opcode.fromString('OP_0').num.should.equal(0);
+    });
+    it('should fail for invalid string', function () {
+      Opcode.fromString.bind(null, 'OP_SATOSHI').should.throw('Invalid opcodestr');
+      Opcode.fromString.bind(null, 'BANANA').should.throw('Invalid opcodestr');
+    });
+    it('should fail for non-string', function () {
+      Opcode.fromString.bind(null, 123).should.throw('Invalid Argument');
+    });
+  });
+
+  describe('#toString', function () {
+    it('should work for OP_0', function () {
+      Opcode.fromString('OP_0').toString().should.equal('OP_0');
+    });
+
+    it('should not work for non-opcode', function () {
+      expect(function () {
+        Opcode('OP_NOTACODE').toString();
+      }).to.throw('Opcode does not have a string representation');
+    });
+  });
+
+  describe('@map', function () {
+    it('should have a map containing 118 elements', function () {
+      Object.keys(Opcode.map).length.should.equal(118);
+    });
+  });
+
+  describe('@reverseMap', function () {
+    it('should exist and have op 185', function () {
+      should.exist(Opcode.reverseMap);
+      Opcode.reverseMap[185].should.equal('OP_NOP10');
+    });
+  });
+  var smallints = [
+    Opcode('OP_0'),
+    Opcode('OP_1'),
+    Opcode('OP_2'),
+    Opcode('OP_3'),
+    Opcode('OP_4'),
+    Opcode('OP_5'),
+    Opcode('OP_6'),
+    Opcode('OP_7'),
+    Opcode('OP_8'),
+    Opcode('OP_9'),
+    Opcode('OP_10'),
+    Opcode('OP_11'),
+    Opcode('OP_12'),
+    Opcode('OP_13'),
+    Opcode('OP_14'),
+    Opcode('OP_15'),
+    Opcode('OP_16'),
+  ];
+
+  describe('@smallInt', function () {
+    var testSmallInt = function (n, op) {
+      Opcode.smallInt(n).toString().should.equal(op.toString());
+    };
+
+    for (var i = 0; i < smallints.length; i++) {
+      var op = smallints[i];
+      it('should work for small int ' + op, testSmallInt.bind(null, i, op));
+    }
+
+    it('with not number', function () {
+      Opcode.smallInt.bind(null, '2').should.throw('Invalid Argument');
+    });
+
+    it('with n equal -1', function () {
+      Opcode.smallInt.bind(null, -1).should.throw('Invalid Argument');
+    });
+
+    it('with n equal 17', function () {
+      Opcode.smallInt.bind(null, 17).should.throw('Invalid Argument');
+    });
+  });
+  describe('@isSmallIntOp', function () {
+    var testIsSmallInt = function (op) {
+      Opcode.isSmallIntOp(op).should.equal(true);
+    };
+    for (var i = 0; i < smallints.length; i++) {
+      var op = smallints[i];
+      it('should work for small int ' + op, testIsSmallInt.bind(null, op));
+    }
+
+    it('should work for non-small ints', function () {
+      Opcode.isSmallIntOp(Opcode('OP_RETURN')).should.equal(false);
+      Opcode.isSmallIntOp(Opcode('OP_CHECKSIG')).should.equal(false);
+      Opcode.isSmallIntOp(Opcode('OP_IF')).should.equal(false);
+      Opcode.isSmallIntOp(Opcode('OP_NOP')).should.equal(false);
+    });
+  });
+
+  describe('#inspect', function () {
+    it('should output opcode by name, hex, and decimal', function () {
+      Opcode.fromString('OP_NOP').inspect().should.equal('<Opcode: OP_NOP, hex: 61, decimal: 97>');
+    });
+  });
+});