@smartledger/bsv 5.5.0 → 5.5.2

package/test/networks.js

@@ -0,0 +1,162 @@
+'use strict'
+
+var expect = require('chai').expect
+var should = require('chai').should()
+var bsv = require('..')
+var networks = bsv.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 bsvstn cashAddrPrefix after enableStn is called', function () {
+    var network = networks.get('testnet')
+    networks.enableStn()
+    expect(network.cashAddrPrefix).to.equal('bsvstn')
+  })
+
+  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 bsv = require('..')
+var Opcode = bsv.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 121 elements', function () {
+      Object.keys(Opcode.map).length.should.equal(121)
+    })
+  })
+
+  describe('@reverseMap', function () {
+    it('should exist and have op 185', function () {
+      should.exist(Opcode.reverseMap)
+      Opcode.reverseMap[185].should.equal('OP_NOP7')
+    })
+  })
+  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>')
+    })
+  })
+})